Committee hearings to begin again on HB 178 (Constitutional Carry, Concealed Weapons License & Remove Duty to Notify)

https://ift.tt/39RmrQG

guns

via Buckeye Firearms Association https://ift.tt/2h9uK1x

February 12, 2020 at 04:06PM

Ruger’s New Ruger American Rimfire Long-Range Target Bolt Action Rifle

https://ift.tt/2UJU8is

Ruger’s New Ruger American Rimfire Long-Range Target Bolt Action Rifle

Courtesy Ruger

From Ruger:

We are pleased to introduce the Ruger American® Rimfire Long-Range Target. This new rimfire offering bridges the gap between traditional wood stock rifles and full-featured chassis rifles. The accuracy of the exceptional Ruger American® Rimfire platform comes from a combination of the long, 22″ free-floating barrel, Ruger Marksman Adjustable™ Trigger and Patented Power Bedding® system. This new rifle delivers long-range performance in a .22 LR package.

Courtesy Ruger

• Two-tone target stock features a two-way adjustable comb, adjustable length of pull with soft rubber buttpad, QD attachment points and flush-mounted lower M-LOK® rail.
• Includes the patented, detachable, flush-mounted BX-1, 10-round rotary magazine and accepts all 10/22® magazines, including the BX-25®, BX-25®x2 and BX-15®.
• Easy-to-use, extended magazine release provides smooth, no-fuss removal of the flush-mounted magazine.
• Patented Power Bedding® integral bedding block system positively locates the receiver and free-floats the barrel for outstanding accuracy.
• Ruger Marksman Adjustable™ trigger offers a crisp release with a pull weight that is user adjustable between three and five pounds, allowing shooters to make that perfect shot.
• Features a visible, accessible and easy-to-actuate tang safety that provides instant security.
• Threaded 0.860″ bull barrel with factory-installed knurled thread protector is cold hammer-forged, resulting in ultra-precise rifling that provides exceptional accuracy and longevity.
• Factory-installed one-piece aluminum scope rail.
• A 60° bolt provides ample scope clearance and the easy-to-use, receiver-mounted bolt release allows the bolt to be readily removed without requiring a pull of the trigger, a unique safety feature among rimfire, bolt-action rifles.
• Compatible with the Silent-SR® sound suppressor
• Also includes: sling swivel studs.

 

Courtesy Ruger

 

guns

via The Truth About Guns https://ift.tt/1TozHfp

February 12, 2020 at 11:23AM

New Political Bible Adds (R) Or (D) After Each Character’s Name

https://ift.tt/2HhRtEB

GRAND RAPIDS, MI—Zondervan has announced an exciting new edition of the Bible that specifically mentions each character’s political affiliation.

Every name in the Bible will be followed by an “R” for Republican or a “D” for Democrat.

“Obviously, right off the bat, God is followed by an R, while the serpent is followed by a D,” the project’s chief editor, Dr. Gary Leyland, told reporters. “Those ones are easy. Some of the other characters are a little tougher, as we have little written evidence of their modern American political ideology. But we can usually figure it out with context. For instance, if a character works a lot and is rich, they’re a Republican. If a character is poor and wears sandals, definitely Democrat. Except for Jesus.”

“The weird characters no one likes are probably libertarians.”

Here are some of the characters whose political identity is revealed for the first time:

• The whore of Babylon: Democrat
• King David: Republican
• Balaam: Republican
• Balaam’s ass: Democrat
• Crying baby Jesus: Democrat
• Adolescent Jesus: Libertarian
• Mature, grown-up Jesus: Republican
• Judas Iscariot: Never Trumper but labeled as Democrat for accuracy’s sake
• Paul: Democrat before conversion, Republican after
• Greedy servant: Republican

Every name in those really long genealogies is assumed to be a Republican, since Democrats are against having kids.

Breaking: Paypal Now Available

Many of you told us you wouldn’t subscribe until we offered Paypal as a payment option. You apparently weren’t bluffing, so we finally caved and added Paypal. Now — like the unbeliever faced with God’s invisible qualities displayed in nature — you are without excuse.

fun

via The Babylon Bee https://babylonbee.com

February 11, 2020 at 06:39PM

Build an Angular 9/8 CRUD Example & Tutorial

https://ift.tt/2OG7zfs

In this tutorial, we’ll learn to build an Angular CRUD example from scratch using the latest version which is as the time of this writing Angular 9.
We’ll be using a CRUD REST API mocked using json-server which lets you generate a complete working API with nearly zero-lines of code.
We’ll not be learning how to use json-server but you can see the complete instructions from this tutorial after generating the Angular project.
Step 1 — Mocking the Backend Using json-server
Step 2 — Creating an Angular 9 Module Step 3 — Importing Angular HttpClientModule and FormsModule
Step 4 — Creating Angular Component(s)
Step 5 — Adding Angular Routing Step 6 — Creating an Angular Service Step 7 — Creating a Model Step 8 — Implementing the CRUD Methods Step 9 — Calling the CRUD Methods Prerequisites
As always, we’ll need to have a few prerequisites for this tutorial: The basic concepts of TypeScript. A local development machine with Node 10+, together with NPM installed. Angular CLI 9 installed on your machine,
An Angular project. In our case, it’s named angular-crud-example.
If your project is ready, let’s get started with our first step.
Angular CRUD Example, Step 1 — Mocking the Backend Using json-server
We have already covered how to mock the REST API in Mocking a REST API Back-End for Your Angular App with JSON-Server and Faker.js
You can simply follow the linked tutorial to quickly build a server that will be running from the http://localhost:3000 address and exposing the following endpoints:
GET /products for getting the products,
GET /products/<id> for getting a single product by id,
POST /products for creating a new product,
PUT /products/<id> for updating a product by id,
PATCH /products/<id> for partially updating a product by id,
DELETE /products/<id> for deleting a product by id.
Step 2 — Creating an Angular 9 Module
We’ll encapsulate the code for our CRUD interface inside a module called crud. Open a new command-line interface and generate a module using the following command:
$ cd ~/angular-crud-example
$ ng generate module crud –routing
This will create a src/app/crud/crud.module.ts file with the following code:
import { NgModule } from ‘@angular/core’;
import { CommonModule } from ‘@angular/common’;
import { CrudRoutingModule } from ‘./crud-routing.module’;
@NgModule({
declarations: [],
imports: [
CommonModule,
CrudRoutingModule
]
})
export class CrudModule { }
Step 3 — Importing Angular 9 HttpClientModule and FormsModule
In this step, we’ll proceed to add HttpClientModule and FormsModule in our project so we can use HttpClient and forms to implement the CRUD operations against the API server.
Open the src/app/crud/crud.module.ts file and add HttpClientModuleand FormsModuleto the imports array of the module as follows:
import { NgModule } from ‘@angular/core’;
import { CommonModule } from ‘@angular/common’;
import { HttpClientModule } from ‘@angular/common/http’;
import { FormsModule } from ‘@angular/forms’;
import { CrudRoutingModule } from ‘./crud-routing.module’;
@NgModule({
declarations: [],
imports: [
CommonModule,
CrudRoutingModule,
HttpClientModule,
FormsModule
]
})
export class CrudModule { }
Step 4 — Creating Angular 9 Component(s)
In this step, we’ll create the Angular components. that compose the UI of our CRUD application:
A home component that renders a table of products and contains the CRUD operations,
A details component that displays the details of a specific product,
A create component for creating products,
A update component for updating products.
Open a new command-line interface and run the following commands:
$ ng generate component crud/home
$ ng generate component crud/details
$ ng generate component crud/create
$ ng generate component crud/update
The CLI will create the necessary files for the components and add them to the declarations array in the src/app/crud/crud.module.ts file:
import { NgModule } from ‘@angular/core’;
import { CommonModule } from ‘@angular/common’;
import { HttpClientModule } from ‘@angular/common/http’;
import { CrudRoutingModule } from ‘./crud-routing.module’;
import { HomeComponent } from ‘./home/home.component’;
import { DetailsComponent } from ‘./details/details.component’;
import { CreateComponent } from ‘./create/create.component’;
import { UpdateComponent } from ‘./update/update.component’;
@NgModule({
declarations: [HomeComponent, DetailsComponent, CreateComponent, UpdateComponent],
imports: [
CommonModule,
CrudRoutingModule,
HttpClientModule
]
})
export class CrudModule { }
Step 5 — Adding Angular 9 Routing
In this step, we’ll add routing. to our CRUD module.
Head back to the src/app/crud/crud-routing.module.ts file, that was automatically created by Angular CLI for routing configuration, and import the components then add the routes as follows:
import { NgModule } from ‘@angular/core’;
import { Routes, RouterModule } from ‘@angular/router’;
import { HomeComponent } from ‘./home/home.component’;
import { DetailsComponent } from ‘./details/details.component’;
import { CreateComponent } from ‘./create/create.component’;
import { UpdateComponent } from ‘./update/update.component’;
const routes: Routes = [
{ path: ‘crud’, redirectTo: ‘crud/home’, pathMatch: ‘full’},
{ path: ‘crud/home’, component: HomeComponent },
{ path: ‘crud/details/:productId’, component: DetailsComponent },
{ path: ‘crud/create’, component: CreateComponent },
{ path: ‘crud/update/:productId’, component: UpdateComponent } ];
@NgModule({
imports: [RouterModule.forRoot(routes)],
exports: [RouterModule]
})
export class AppRoutingModule { }
We first imported the CRUD components, next we added five routes for each component and a redirection route which simply redirects users to the home component when they visit the empty path.
In the next step of our example, we’ll a service for crud methods.
Step 6 — Creating an Angular 9 Service
In this step, we’ll create an an Angular service that encapsulates the CRUD operations and make them available to the various UI components.
Go back to your command-line interface and run the following command:
$ ng generate service crud/crud
Next, open the src/app/crud/crud.service.ts file, and import and inject HttpClient as follows:
import { Injectable } from ‘@angular/core’;
import { HttpClient } from ‘@angular/common/http’;
@Injectable({
providedIn: ‘root’
})
export class CrudService {
private apiServer = "http://localhost:3000";
constructor(private httpClient: HttpClient) { }
}
We imported and injected the HttpClient service. We also defined the apiServer variable that contains the address of our REST API server.
Step 7 — Creating an Angular 9 Model
In this step, we’ll see how to create a model for using typed HTTP responses in our example.
Head back to your command-line interface and run the following command from the root of your project:
$ ng generate interface crud/product
Next, open the src/app/crud/product.ts file and update it as follows:
export interface Product {
id: number;
name: string;
description: string;
price: number;
quantity: number;
}
Step 8 — Implementing the CRUD Methods
Let’s now implement the CRUD operations for creating, reading. updating and deleting products using a service.
Open the src/app/crud/crud.service.ts file and update it as follows:
import { Injectable } from ‘@angular/core’;
import { HttpClient, HttpErrorResponse } from "@angular/common/http";
import { throwError } from ‘rxjs’;
import { catchError } from ‘rxjs/operators’;
import { Product } from ‘./product’;
@Injectable({
providedIn: ‘root’
})
export class CrudService {
private apiServer = "http://localhost:3000";
httpOptions = {
headers: new HttpHeaders({
‘Content-Type’: ‘application/json’
})
}
constructor(private httpClient: HttpClient) { }
create(product): Observable<Product> {
return this.httpClient.post<Product>(this.apiServer + ‘/products/’, JSON.stringify(product), this.httpOptions)
.pipe(
catchError(this.errorHandler)
)
} getById(id): Observable<Product> {
return this.httpClient.get<Product>(this.apiServer + ‘/products/’ + id)
.pipe(
catchError(this.errorHandler)
)
}
getAll(): Observable<Product[]> {
return this.httpClient.get<Product[]>(this.apiServer + ‘/products/’)
.pipe(
catchError(this.errorHandler)
)
}
update(id, product): Observable<Product> {
return this.httpClient.put<Product>(this.apiServer + ‘/products/’ + id, JSON.stringify(product), this.httpOptions)
.pipe(
catchError(this.errorHandler)
)
}
delete(id){
return this.httpClient.delete<Product>(this.apiServer + ‘/products/’ + id, this.httpOptions)
.pipe(
catchError(this.errorHandler)
)
}
errorHandler(error) {
let errorMessage = ”;
if(error.error instanceof ErrorEvent) {
// Get client-side error
errorMessage = error.error.message;
} else {
// Get server-side error
errorMessage = `Error Code: ${error.status}\nMessage: ${error.message}`;
}
console.log(errorMessage);
return throwError(errorMessage);
}
}
Step 9 — Calling the Angular 9 CRUD Methods
Next, let’s see how to make CRUD operations in our components. Open the src/app/crud/home/home.component.ts file, import and inject the Angular service as follows:
import { Component, OnInit } from ‘@angular/core’;
import { CrudService } from ‘../data.service’;
@Component({
selector: ‘app-home’,
templateUrl: ‘./home.component.html’,
styleUrls: [‘./home.component.css’]
})
export class HomeComponent implements OnInit {
products: Products[] = [];
constructor(public crudService: CrudService) { }
ngOnInit() {
this.crudService.getAll().subscribe((data: Products[])=>{
console.log(data);
this.products = data;
}) }
}
We imported and injected CrudService as a private crudService instance via the component constructor.
Next, we defined a products array and invoked the getAll() method for making a read operation against the API server.
Next, open the src/app/crud/home/home.component.html file and update it as follows:
<div>
<h1>My Products</h1>
<button type="button" [routerLink]="/crud/create/">Create new product</button>
<table>
<thead>
<tr>
<th>#</th>
<th>Product Name</th>
<th>Description</th>
<th>Price</th>
<th>Quantity</th> <th>Action</th>
</tr>
</thead>
<tbody>
<tr *ngFor="let product of products">
<td></td>
<td></td>
<td></td>
<td></td>
<td>
<button type="button" [routerLink]="[‘/crud/update/’, product.id]">Update</button>
<button type="button" (click)="crudService.delete(product.id)">Remove</button>
</td>
</tr>
</tbody>
</table>
</div>
We iterated over the products array using the ngFor directive and displayed the name, price, quantity, and description of each product. And we added two buttons for running the delete operations and navigating to the update component where we can run the update operation. We also added a button for navigation the user to the product creation component.
Next, open the src/app/crud/create/create.component.ts file and update it as follows to create an angular form:
import { Component, OnInit } from ‘@angular/core’;
import { CrudService } from ‘../crud.service’;
import { FormBuilder, FormGroup } from ‘@angular/forms’;
import { Router } from ‘@angular/router’;
@Component({
selector: ‘app-create’,
templateUrl: ‘./create.component.html’,
styleUrls: [‘./create.component.css’]
})
export class CreateComponent implements OnInit {
productForm: FormGroup;
ngOnInit() {
this.productForm = this.fb.group({
name: [”],
description: [”],
price: [”],
quantity: [”], })
}
constructor(
public fb: FormBuilder,
private router: Router,
public crudService: CrudService
){ }
submitForm() {
this.crudService.create(this.productForm.value).subscribe(res => {
console.log(‘Product created!’)
this.router.navigateByUrl(‘/crud/home/’))
}
}
Next, open the src/app/crud/create/create.component.html and add the following HTML form for creating a product:
<div>
<h1>Create Product</h1>
<form [formGroup]="productForm" (ngSubmit)="submitForm()" novalidate>
<div class="form-group">
<label>Name</label>
<input type="text" formControlName="name" class="form-control" maxlength="20">
</div>
<div class="form-group">
<label>Description</label>
<textarea class="form-control" formControlName="description" rows="3" maxlength="50"></textarea>
</div>
<div class="form-group">
<label>Price</label>
<input type="text" formControlName="price" class="form-control">
</div>
<div class="form-group">
<label>Quantity</label>
<input type="text" formControlName="quantity" class="form-control">
</div>
<button type="submit">Submit</button>
</form>
</div>
The implementation of the update operation is left as an exercise for the reader. It’s quite similar to the create operation except that we need to retrieve the ID of the product to update from the route parameter.
We have implemented the read operation for getting all the products but you also need to read a product by ID.
Conclusion
In this tutorial, we’ve built a CRUD example using the latest Angular 9 version.
We have created a service and implemented the create, read, update and delete operations against a REST API backend with a fake JSON database.

technology

via Planet MySQL https://ift.tt/2iO8Ob8

February 9, 2020 at 10:39PM

Comic for February 09, 2020

https://ift.tt/2Sc7h2f

fun

via Dilbert Daily Strip http://dilbert.com

February 9, 2020 at 02:11AM

The best cellular GPS tracker

https://ift.tt/2UwTYec

By Nick Guy

This post was done in partnership with Wirecutter. When readers choose to buy Wirecutter’s independently chosen editorial picks, Wirecutter and Engadget may earn affiliate commission. Read the full guide to cellular GPS trackers.

While a Bluetooth tracker is useful for finding your keys or wallet at home, if you want to keep track of your kids or where you left the car, get a cellular GPS tracker. Small enough for you to stow them in a bag or pocket, these devices connect to a cell signal so you can locate them with an app—from nearly any distance. The Samsung SmartThings Tracker (AT&T) is our pick because its battery lasts for days, its tracking is accurate, and it doesn’t require you to be a customer of a specific carrier.

The Samsung SmartThings Tracker (AT&T) provides fast and accurate location reporting, and it supports live tracking and geofencing alerts so you can receive notifications quickly if it leaves a zone you designate. In our tests, its battery lasted four-plus days, and Samsung says it can go as long as 10 depending on usage. The crucial differentiator between the Samsung tracker and other models we considered is that it’s not tied to a specific carrier: Although it relies on AT&T’s cell network for service, anyone can use it without being tied to any sort of smartphone contract.

Verizon’s Smart Locator updates its location a little more rapidly than the Samsung SmartThings Tracker but otherwise has similar features, including geofencing and live tracking, and in our testing its battery lasted four or five days before needing to be recharged. But the downside is that in order to buy or use this tracker you need to also have a new or existing Verizon cell phone plan. Although Verizon is a great network and has a huge customer base, we can’t recommend the Smart Locator for everyone since for many people it would require switching carriers. If you have a Verizon plan already, go for it.

Why you should trust me

I’ve been reviewing gadgets and accessories since 2011, and I’ve been at Wirecutter since 2014. During that time I’ve covered similar categories including Bluetooth trackers and pet trackers, so I know what to look for from this kind of device.

Who this is for

A cellular GPS tracker is like a Tile-style Bluetooth tracker but far more powerful. Instead of relying on Bluetooth wireless, which needs a direct connection to your device and has a top range of 400 feet (and typically far less), these trackers use a combination of cellular signal and GPS so that you can locate them from nearly anywhere, as long as they’re within range of cellular service. Whereas a Bluetooth tracker may be a good choice for finding your keys or your wallet around the house or in the office, a cellular GPS tracker is more versatile. If you have a sitter taking care of your child, for example, you could toss one in your kid’s backpack so you can see that the sitter picked them up safely. These trackers have value if you go hiking, biking, or snowboarding and want a guardian angel keeping tabs on your stuff, or you can chuck one in your bag at the lodge so you receive an alert if it moves. Or you might put one in your car when you go to a music festival and park in a big field, and need to navigate back to it when the show is over. Bluetooth trackers aren’t very useful in any of those cases, dedicated kid trackers are meant to be used every day (we hope to address those in the future), and satellite is overkill. There are also pet-centric trackers that we didn’t include in this guide.

Greater capability comes at a higher cost. Compared with a Bluetooth tracker, these trackers are more expensive to buy and require monthly service charges, and their batteries run dry and need recharging in just a few days rather than years.

Tracking devices necessarily raise issues of privacy and security, and these devices in particular, which are small and work anywhere a cell signal exists, could be used by nefarious people to track others. While federal laws on GPS tracking are still ambiguous, state laws vary, and it is generally illegal, not to mention unethical, to track another person without their consent. If you plan to use a tracker to keep tabs on another person, get their permission first.

How we picked and tested

The cellular GPS tracker category is young and in flux. After researching the limited field of competitors available through cellular carriers and independent manufacturers, we identified the most important criteria, which we used to narrow down the list of models we were interested in testing.

• No onerous carrier contracts: All of these trackers connect to a cellular network through a carrier, just as a cell phone does, but some require you to already have service with that provider. Our ideal tracker is carrier-agnostic, and we don’t recommend that anyone change their carrier simply to use a cellular GPS tracker.
• A good cellular network: A good cellular network means that your tracker is more likely to have service when you try to find it. We tested only those trackers whose labeling or specs made it clear what network they use, and we gave preference to those on larger carriers such as Verizon and AT&T.
• Battery life of five-plus days: Unlike Bluetooth trackers, which can run for one to three years before the battery or the tracker itself needs to be replaced, cellular GPS trackers provide only a few days of use per charge, but they are rechargeable. Most trackers advertise at least five days of battery life—anything less than that is just too little to be reliable.
• Geofencing capabilities: Cellular GPS trackers are useful because they can show you where something or someone is, but also because they can alert you when that something or someone is not where they’re supposed to be. The tracker you choose should have a geofence feature, which allows you to set a digital border; when the tracker enters or leaves that area, you get an alert on your phone.
• Live tracking: If the person or things you’re tracking aren’t where you expected them to be, seeing where they’re going can be important. Live tracking allows you to see the path they’re taking on a smartphone app (note that live tracking drains the battery at a faster rate).
• Ring options: Ideally, your phone can find your tracker, and your tracker can find your phone. We prefer a tracker that has a built-in speaker that you can ring from the app as well as a button to trigger an alert on your phone, but none of the top contenders have both features.
• IP67 or higher waterproof rating: Almost every tracker out there offers some degree of weatherproofing, so there’s no reason to choose one that doesn’t. The "6" in the IP67 rating represents the highest level of protection from dust, and the "7" indicates that the tracker will survive under 1 meter of water.
• Price: Although it can be hard to put a dollar figure on the security that tracking can provide, there is a point of diminishing returns. The top three models in our research all cost less than $150 during their first year (that’s the price of the hardware as well as the service plan, which some trackers include for free for a period). Anything higher than that is more than you should be paying, especially since none of the more expensive models promise any additional features or accuracy.

Once we narrowed down our picks to the top two options, we put them to the test, looking to confirm all the promised attributes, evaluate the GPS accuracy, and assess the app performance. I played around with both trackers for a few days before handing the logins off to my editor, stationed in Brooklyn, as I began a trek around nearby Queens and Manhattan. I walked from my apartment to the train, which I then took to the New York Times building in Times Square. (The New York Times is Wirecutter’s parent company.) After wandering around for a few congested blocks, I hopped back on the train, this time to Wirecutter’s Long Island City office. Along the way, my editor confirmed my location in both trackers’ apps at every stop and turned on their live-tracking features to test for accuracy.

Our pick: Samsung SmartThings Tracker (AT&T)

Samsung’s SmartThings Tracker (AT&T) is accurate, updates quickly, has about a week’s worth of battery life, and offers the best combination of features among an imperfect group of competitors. Notably, anyone can use the SmartThings Tracker, as Samsung doesn’t require you to have a phone service plan with any specific cellular carrier—a common issue for the other test models we considered. (A Verizon-based version of the Tracker is also available, but it doesn’t come with a free year of cell service like the AT&T model does.) No tracker we know of has features so valuable that it would be worth jumping to a different cell service provider. The SmartThings Tracker uses AT&T’s cellular service for data; judging from our experience, AT&T has a very good network, so there should be few areas where you don’t have service.

The most important thing a tracker can do is tell you where it is, and the SmartThings Tracker does that well. When you go through the app to view the map, you see the tracker’s location, with a circle around it showing the accuracy range (while the center of the circle may not be exactly where the tracker is, the tracker does fall somewhere within the area of the circle). From there, you have several options. You can see where the tracker has been, or you can turn on live tracking, which constantly updates the tracker’s location, as it moves, for a customizable period before turning off; you can select 10 minutes, 30 minutes, one hour, three hours, or five hours, and the more often it updates, the shorter its battery life will be.

Samsung advertises four to five days per charge on average, up to 10 days depending on how you use it, before the battery needs to be recharged. In our testing, the results were closer to that lower range. A push alert on your phone lets you know when the tracker’s battery is getting low and it needs to be plugged in.

The SmartThings Tracker also supports geofencing, allowing you to set up to five geographic zones, each with a minimum 700-foot radius. You can choose to receive notifications when the tracker enters that location, exits it, or both. For example, you might set your home as a zone so that you receive an alert when your kid gets home from school. I found the geofencing to work properly, although I traveled a few city blocks before I received the notification that I had left my apartment or the Wirecutter office (by comparison, the Verizon tracker sent an alert a block or two sooner).

Samsung’s SmartThings Tracker measures 1¾ inches square and ½ inch thick; it’s roughly the size of two Tile Pro trackers stacked. Frankly, it’s pretty boring looking, a simple white box with a single LED light, a button on the top, and a Micro-USB charging port on the bottom. This standard charging port means that if you lose the cables that come with the SmartThings Tracker you can easily find a replacement, or you might already have one lying around. Double-pressing the button on the tracker allows you to instantly send its location to the phone app, though there’s no way to ring your phone from the tracker or vice versa, as you can with a Tile (see Flaws but not dealbreakers). The SmartThings Tracker has an IP68 rating, which means it is resistant to damage from dust or water. A small fabric loop is included so you can attach the tracker to a bag or keychain.

Samsung offers the first year of AT&T service for free, making the SmartThings Tracker the least expensive to own and use over the course of its first year than anything else in this category. When that time is up, you can pay either $5 a month or $50 a year for continued service. That’s about average compared with what other companies charge.

The SmartThings Tracker is also available on the Verizon network, whether or not you’re already a Verizon customer, but the initial cost of ownership is higher because you have to pay for service for the first year. If you are a Verizon customer already, we think you should choose the Verizon Smart Locator, which provides slightly faster alerts and is more accurate.

Flaws but not dealbreakers

We found Samsung’s app to be less intuitive and more annoying than Verizon’s. For instance, because the SmartThings app is what you need to use to control all of Samsung’s smart-home gear, it opens to a splash screen that you have to tap through, rather than taking you directly to the tracker map as the Verizon app does. In our tests, the Verizon app also tended to be more precise, and it updated the location at a faster rate.

It would be better if the SmartThings Tracker could ring your phone and vice versa, making it a full replacement for a Tile.

Also great: Verizon Smart Locator

If you’re already a Verizon Wireless customer, we recommend Verizon’s Smart Locator. In our tests, compared with the SmartThings Tracker, its range was more accurate, its location reports updated a bit faster, and its alerts came faster when we left our preset geofence. But you can use the Smart Locator only if you have a Verizon cell phone plan, and we don’t think it’s worthwhile for anyone to change their cell phone plan just to get this GPS tracker.

Opening the Verizon Smart Locator app takes you right into the map, making it faster to find the tracker’s location than with the Samsung model. From there, you can easily access live tracking and location history. Digging into the settings a bit, you have the option to set location alerts via geofence, as well as a tracking schedule. For example, you might choose to have the Smart Locator check every five minutes between 3 p.m. and 4 p.m. on weekdays, when you expect your child to be getting home from school.

Rather than display a large radius, the Verizon tracker pinpoints its location in the app much more tightly than the SmartThings Tracker, the key reason you might choose this model over our top pick if you’re a Verizon customer. In our tests, instead of showing a range of a few buildings or even blocks, it showed us the location marked within a few feet.

The Smart Locator’s hardware is very similar to that of the SmartThings Tracker, which is to say, very plain. It’s a simple gray oval, bisected laterally, with a clicky segment on the bottom half. Rather than using a standard charging connector, it requires a less-convenient proprietary magnetic charger that isn’t as easily replaceable as the Samsung’s Micro-USB cable and can more readily disconnect. A built-in keychain loop sits at the top of the device.

The Verizon Smart Locator’s specs are otherwise very similar to those of the Samsung tracker. It gets about five days of battery life, and it’s a little less waterproof than the Samsung model at IP67, meaning it’s rated to survive under only 1 meter of water (that’s still pretty good). You can ring the tracker from the app, something you can’t do with the SmartThings Tracker, but you can’t use the Smart Locator to ring your phone.

At this writing, Verizon includes the first year of the Smart Locator’s service for free, and after that it’s $3 a month, a couple of bucks cheaper than service for the Samsung model.

The competition

Sprint’s Tracker + Safe & Found was the only other tracker we tested for this guide, but between issues with the hardware and software and the inferior network, we don’t recommend it. At the time we began our testing, the tracker was available for use only with a Sprint account; if you don’t use Sprint as your smartphone carrier, the feature set is limited. In our tests, the app regularly logged us out and forced us to log in every time, and it wasn’t particularly intuitive to use. The hardware button on the tracker, which you use for pairing, is difficult to press. You get no live tracking, and no way to ring your phone with the tracker. This model is also relatively expensive, costing almost twice as much during the first year as the Samsung SmartThings Tracker. And finally, we don’t recommend the Sprint network—as our reviewer says, its "coverage consistently ranks fourth in surveys and tests."

The Trax 4G North America is more expensive than the Samsung and Verizon trackers we recommend. It also has a limited battery life, lasting only two to three days.

The Pod 3 GPS Tracker is more expensive than our picks and relies on inferior 2G and 3G networks.

The Jiobit is by far the most expensive tracker we found, with an up-front cost that’s almost double the hardware and one-year service price of the SmartThings Tracker, plus a $9 to $13 charge per month depending on the length of the service plan you choose. In addition, it’s limited to 2G and 3G networks.

GeoZilla’s Tracker appears to be a generic tracker with branding slapped on it; Trackimo’s hardware looks to be identical. The tracker also has poor battery life of only two to three days and isn’t waterproof.

This guide may have been updated by Wirecutter. To see the current recommendation, please go here.

When readers choose to buy Wirecutter’s independently chosen editorial picks, Wirecutter and Engadget may earn affiliate commissions.

geeky,Tech,Database

via Engadget http://www.engadget.com

February 7, 2020 at 12:34PM

MySQL 8.0 DBA Certification Exam Now Available

https://ift.tt/31wbkt6

You can now earn your MySQL 8.0 DBA Certification Exam is now available. It is Oracle Exam 1Z0-908 and I was one of the many question writers.  Some of you may remember when I was the head of MySQL Certification and I can assure you this is a very complete test of all your MySQL DBA skills. And it asks very relevant questions and not trivial facts. So anyone taking this exam and earning this certification really knows their MySQL!

So what do you need to know:

Architecture

• Configure client connections to the server
• Understand how MySQL stores data
• Understand how InnoDB stores data and logs
• Configure buffers and caches
• Understand and use the Data Dictionary

Security

• Create user accounts and roles
• Use authentication plug-ins
• Control user and role permissions
• Recognize common security risks
• Secure MySQL server connections
• Provide password and login security
• Secure the MySQL host environment
• Prevent SQL injection attacks
• Encrypt MySQL data
• Configure MySQL Enterprise Firewall

Query Optimization

• Examine how MySQL optimizes queries
• Analyze queries with MySQL Enterprise Monitor
• Create indexes to improve server performance
• Monitor and understand index statistics

High Availability Techniques

• Explain how replication provides high availability and scalability
• Configure replication
• Explain the role of the binary log in replication
• Configure multisource replication
• Explain the role of replication threads
• Monitor and troubleshoot replication
• Describe MySQL InnoDB cluster and Group Replication
• Configure a MySQL InnoDB cluster
• Perform an InnoDB cluster recovery

Server Installation and Configuration

• Install and use the MySQL server and client programs
• Identify the files and folders created during installation
• Start and stop MySQL
• Upgrade MySQL
• Configure MySQL by using options and option files
• Configure MySQL variables
• Launch multiple MySQL servers on the same host

Monitoring and Maintenance

• Configure and view MySQL log files
• Monitor MySQL processes and status
• Configure MySQL Enterprise Audit
• Use MySQL Enterprise Monitor to view activity in MySQL
• Monitor database growth and explain capacity planning
• Troubleshoot problems with locked resources

Backups and Recovery

• Distinguish between the different types of backup
• Implement a backup strategy
• Backup and restore data with MySQL Enterprise Backup
• Use mysqldump and mysqlpump to perform logical backups
• Explain when and how to use raw file backups
• Back up the binary log

You can register for your exam here.

technology

via Planet MySQL https://ift.tt/2iO8Ob8

February 6, 2020 at 06:42PM

Netflix’s horrible autoplay previews can be turned off

https://ift.tt/2vXj77B

Listen, this week sucks. Last week pretty much sucked, too. Honestly, it’s probably time to just scrap this stupid jerk of a year and give 2021 a go. (Spoiler: That one will suck, too.) But you take your victories where you can get them, and Netflix just handed us a beautiful one for once in our sad, miserable lives.

Autoplay trailers are now optional. That’s it. That’s the news. The short but horrible tyranny of autoplay previews are at an end.

Here, do this now:

1. Click Manage Profiles
2. Choose your profile
3. Untick “Autoplay previews while browsing on all devices.
4. Now live, damnit! Live!

Scroll free, friends. 

technology

via TechCrunch https://techcrunch.com

February 6, 2020 at 03:24PM

How Wine Corks Are Made

https://ift.tt/2ulG2ZN

Link

When you pop open a bottle of wine, it’s easy to forget that its stopper comes from a tree. This footage captured by oenophile Jamie Goode at Portugal’s Cork Supply shows us the labor that goes into cutting pieces of cork tree bark, and punching out individual pieces. We wonder what they do with the leftover bark.

fun

via The Awesomer https://theawesomer.com

February 5, 2020 at 12:30PM

Guzzle API Requests With Tests

https://ift.tt/2UoG5i5

In this lesson, Bobby Bouwmann shows us how to use Guzzle to make API requests. He’ll also demonstrate how you might go about testing classes that perform lengthy network calls.

Published on Feb 4th, 2020.

programming

via Laracasts https://ift.tt/1eZ1zac

February 4, 2020 at 01:54PM