teleren/devto huggingface dataset:
All About Scott County Inmate Listing
Published: 2021-12-27 13:35:19

Scott County jail is the significant correction centre there.
The Scott County Justice Center is situated at 535 Scott High Drive in Huntsville. It has been in use since around 2008. You will know more ab scott County inmate listing below.

The city of Davenport is situated somewhere between Chicago and Des Moines on the eastern line of Iowa. Davenport was established in May 1936 by Antoine Le Claire, and was named for his companion George Davenport, a colonel at the close by Fort Armstrong. 
The Justice Center comprises two courts, a prison and a few office suites.

The Scott County Jail holds both pre-preliminary prisoners and post-conviction detainees condemned in the Scott County Court System to a timeframe of one year or less. As indicated by the 2010 enumeration, the number of inhabitants in Davenport was 99,685, making it Iowa's third biggest city.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zm21codyopjyht5zphc9.jpg)

**How To Find Inmates**

You have to visit Scott County's Sheriff's official website.
To look for a particular prisoner, click on the letter that starts their last name; detainees are arranged in order by their last name. The outline page shows the prisoner's mug shot, their complete name, booking date and time, delivery date and time, their capturing organization and their charges. It is important regarding scott county inmate listing.

Next, click on the prisoner's name for extra subtleties including: the detainee's ID number, sex, birth date, age, stature, weight, race, hair tone, hail length, eye tone, tone, false names, bond and charge data. Note, this list does exclude government detainees or keeps, or the individuals who were set free from the prison over one week prior.

The Jail is for County Jail wrongdoers condemned up to two years. The telephone transporter is Securus Tech, to see their rates and best-calling plans for your prisoner to call you.

All detainment facilities and prisons have Security or Custody levels relying upon the prisoner's grouping, sentence, and criminal history. Kindly survey the guidelines and guidelines for County - medium office regarding **[scott county inmate listing](https://johnhornbeck.com/tech/scott-county-inmate-listing/)**.

On the off chance that you are uncertain of your prisoner's area, you can look and find your detainee by composing in their last name, first name or first introductory, or potentially the wrongdoer ID number to get their exact data quickly Registered Offenders. 

So if you want to find any inmate there, you can always do that. But you have to remember a few things regarding scott county inmate listing that the Detention Center has a telephone program where detainees settle on outbound decisions no one but, you can't call into prison. Since you are paying for those calls don't make it a propensity for tolerating gathering calls.
Quest DB - My experience at QuestDB during Hacktoberfest
Tags: hacktoberfest, questdb, dev, webdev
Published: 2021-12-27 13:31:15

## Where did I find about "QuestDB" ?
Well it was mid of [#Hacktoberfest](https://dev.to/t/hacktoberfest) when I got to know about the Quest DB from [this site](https://hacktoberfest-swag.com/) https://hacktoberfest-swag.com

## How was my experience ?
My experience was was amazing! Actually in their swag referral program I was entitled for the Level - 1 Swag but after few days of hacktoberfest, I got an email from QuestDB community manager, stating due to some problems with manufacturer they will be sending me a T-shirt withinh the DEC 2021!!!! XD . 
{% spoiler :)%}I got my swag in the month of Nov 2021 only, but I didn't had the time to write a blog about this{% endspoiler %}

## What is QuestDB
```
QuestDB is the fastest open source time series database
```
and ofc they are amazing, even for my college projects we now use the Quest DB! Yup its that amazing!
You could know more about them from these links:

1. [site](https://questdb.io)
2. [questdb/questdb](https://github.com/questdb/questdb)
3. [docs](https://questdb.io/docs/introduction/)
4. [community page](https://questdb.io/community/) #Here about info their **swag referral program** is mentioned
5. [slack](https://slack.questdb.io/)
6. [stackoverflow](https://stackoverflow.com/questions/tagged/questdb)
7. [twitter](https://twitter.com/questdb)

# My Quest DB Swag
![My Quest DB swag](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/v1ujn80g1frz7kw9q2ab.jpg)

{% github questdb/questdb %}
Building a Mobile Document Scanner with Zero Dependencies: Environment and Setup

Tags: javascript, algorithms, computervision
Published: 2021-12-27 13:00:16

I had two primary goals for this project: to learn about the computer-vision algorithms and techniques used in document scanning, and to use that knowledge to build a program that I would actually prefer using over existing apps like CamScanner.

I wanted to be able to use my final product on iOS, macOS, Android, and Windows, but I did not want to have to maintain four separate native codebases. [Flutter](https://flutter.io) seemed to be a good option, but I'm not well-versed in Dart, and Flutter's supposed performance advantages over web apps are overblown according to my local tests. Therefore, I opted to use a [Progressive Web App](https://web.dev/what-are-pwas/) (PWA) architecture for my document scanner.

Computer vision often involves multiple expensive operations on an image, so it would be logical to use WebAssembly for the actual document detection and use JavaScript only for the UI. Although I'm quite familiar with Rust and compiling to WASM, I'm a fan of [pushing JS to its limits](https://github.com/101arrowz/fflate) and I wanted to see just how fast JavaScript can be for such a computationally intensive task; turns out, JS is actually fast enough for a document scanner even on low-end mobile devices. (Regardless, I am currently building a "final product" version of this app with WASM, a proper UI, and a few libraries. It should be faster and more user-friendly than the existing prototype).

With these constraints in mind, I got to work by hacking together a Parcel 2 project with TypeScript, the [Parcel service worker precaching integration](https://parceljs.org/languages/javascript/#service-workers), and my [PWA manifest generation plugin](https://www.npmjs.com/package/parcel-config-pwa-manifest). This is my standard setup for all my new projects, but I usually throw React and Emotion in there too; unfortunately, I was already committed to the "zero dependencies" mantra at this point, so the only packages I installed were build tools. Next step: figure out how exactly document detection works so I can actually build the app.
Building a Mobile Document Scanner with Zero Dependencies: Introduction
Tags: javascript, algorithms, computervision
Published: 2021-12-27 12:59:59

I've been using document scanning apps like [CamScanner](https://play.google.com/store/apps/details?id=com.intsig.camscanner&hl=en_US&gl=US) and [Smallpdf](https://play.google.com/store/apps/details?id=com.smallpdf.app.android&hl=en_US&gl=US) to send digital copies of physical documents for a long time, but I'd always wondered how exactly the apps worked. When you take a picture of a piece of paper, even without the paper perfectly centered, these apps automatically find its corners and warp the perspective of the image so it looks as if it were taken with a dedicated scanner. A few weeks ago, I started searching for open-source document scanners I could study.

The problem? There are none. Rather, the only open-source document scanners I could find basically handed everything off to [OpenCV](https://github.com/opencv/opencv), which unfortunately has very sparse internal documentation.

So I decided to build my own document scanner, with one catch: I would be using **zero third-party libraries**. One month later, I have a prototype I'm happy with, and it's worked well on most of the documents I've tested it with.

Let's try it with a random image from Google:

![Sample image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ctdbael4t7o0xdqy6txx.jpg)

Here's my document scanner at work:

![Edge detection on sample image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tok6oo9jxkum7f1l9uxm.png)

And here is our final result:

![Scanned document](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/m4pz5u2ojqpykwv43opc.PNG)
 
The quality isn't perfect because the original image wasn't very high resolution, but taking pictures of most documents with a decent smartphone yields great results. If you'd like to check it out, the code and a demo website are available [on GitHub](https://github.com/101arrowz/scanner).

However, I'd strongly suggest reading the rest of the articles in this series first to get a grasp on what exactly is happening under the hood. I believe that anyone can learn even the most complicated aspects of computer science, so I've written this series in such a way that you only need beginner programming skills and a basic understanding of algebra to follow along. Let's dive right in!
This Keyword Scenarios in JS
Tags: javascript, html, css, webdev
Published: 2021-12-27 12:57:30

**This Keyword:-**
It is an Object, that is executing the current function.
But, this keyword behaviour is different in different situations.

---
**1. _Global Space_** :- this keyword will always point to the global window object in global space.

``` javascript
console.log(this); //global window object
```

---
**2. _Normal Function_**:- If we wrote the normal function in global space, that function will always point to the window object, so if we print "this" inside a function. that will always be widow object.

``` javascript
function User() {
	console.log(this) //global window object
}
User();
```

---
**3. _Objects_**:- If we consider an object, functions inside the object will always have the parent. so "this" will not point to the global object. instead of that, it will point the particular object.

``` javascript
const data = {
  name: 'uma',
  age: 22,
  address: function() {
    console.log(this.age) //22
  }
}

data.address()
```

**Note**:- But Arrow Function will always point to the window object. 

``` javascript
const data = {
  name: 'uma',
  age: 22,
  address: () => {
    console.log(this.age) //undefined
  }	
}
data.address()
```

---
**4. _Constructor_**:- Constructor also have the same behaviour as Objects. it will also point to the particular object.

``` javascript
function User(name) {
  this.name = name,
  console.log(this.name)  //uma
}

const user1 = new User('uma')
```

Thanks for reading!
Big O notation
Tags: programming, algorithms, beginners, computerscience
Published: 2021-12-27 12:46:33

**Big O notation is a special way to describe the speed of algorithms.**

Let's say we need to find a name in the phone book (yes, that old book with phone numbers). We can, of course, search all the names one by one, but this will be time consuming, better at this point to open the phone book halfway and see if we hit it. If not we open the phone book in the middle again, this time between the previous middle and the beginning or end of the book, and so on until we find the right name.

To see which algorithm is faster we can measure the time between the two algorithms simply by measuring the time in which they executed. But what if we are looking for the first name in the phone book - the first way will prove to be more efficient as it will only need one operation to complete. But what if we are looking for the last name in the phone book - then the second algorithm will turn out to be incredibly faster.

Which algorithm to choose, then? With help comes the Big O notation

**The big O notation specifies the worst-case running time of the algorithm**

The information alone on how long an algorithm took to execute is not sufficient, more important information for the programmer is how much the execution time increases as the number of elements increases.

Big O notation looks like this: 

O(n) - First comes big O, and in parentheses the number of operations to be performed in the worst possible case

The name "Big O notation" comes from the fact that it puts the letter O in front of the number of operations (yes, seriously!)

Below is a list of the most common execution times expressed in the Big O notation:

- O(log n) - logarithmic time, e.g binary search

- O(n) - linear time, e.g linear search

- O(n ⋅ log n) - e.g quicksort

- O(n<sup>2</sup>) - e.g selection sort

- O(n!) - very slow algorithm, e.g traveling salesmen problem

##Summary

- the speed of execution of algorithms is not expressed in seconds, but in the rate of increase in the number of operations

- When discussing the speed of the algorithm, it is stated how fast the execution time increases as the size of the input set increases

- The execution time of the algorithms is expressed in the Big O notation

- The larger the dataset the greater the difference in algorithm execution time
Red is a beautiful color
Tags: programming, webdev, beginners, algorithms
Published: 2021-12-27 12:37:00


We're conditioned by society to be afraid of the color red. STOP, DANGER, DO NOT ENTER, all loud red signs telling us to turn around, don't go in there, you'll get hurt. It's so easy to carry this mindset over to coding that many new programmers get discouraged and distraught over the red error messages their compilers spit out.
Log In & Registration With Laravel/Ui - In Laravel
Tags: laravel, php, authentication
Published: 2021-12-27 12:32:30

Hello guys!

This post aims to give you the demonstration of " How to add authentication in laravel with laravel/ui package".

You can just follow some simple steps from this post to add log-in and registration options in laravel 8.x with the help of laravel/ui.

**Step # 01: Create Laravel App**

```
composer create-project laravel/laravel LaravelApp
```

Open this app in your vs code editor.

**Step # 02: Installing laravel/UI package**
Run in vs code terminal

```
composer require laravel/ui
```

**Step # 03: Installing front end scaffolding**
Now, You have three options here. (Bootstrap, Vue, React) You have to choose one.

For Bootstrap:

```
php artisan ui bootstrap
```
For Vue:

```
php artisan ui vue
```
For React:

```
php artisan ui react
```

**Step # 04: Now run**

```
npm install
```
and also

```
npm run dev
```

**Step # 05: Install Authentication**

But remember if you choose bootstrap scaffolding in previous 
command then you have to run the below command
```
php artisan ui bootstrap --auth
```
and if you choose Vue then
```
php artisan ui vue --auth
```
and if you choose React then
```
php artisan ui react --auth
```

**Now, you have successfully installed the authentication in your application.**

Let's just run

```
php artisan migrate
```


I hope this will help you to add authentication (login and registration) option in your laravel app with laravel/ui package.

If you are facing any issue regarding to this then feel free to mention in the comment.

Thanks!

Video Link:
https://www.youtube.com/watch?v=Agx4xITyYgQ&t
Real Estate Mobile App Development Company
Tags: news, webdev, react, android
Published: 2021-12-27 12:29:54

AppStudio is a renowned **[real estate app development company](https://www.appstudio.ca/real-estate-app-development-company.html)** offering best-in-class solutions to real estate industry. We have experienced developers in our real estate app development team who have created many unique Android and iOS apps for realtors, agents and brokers. We offer tailor-made services to meet specific business needs, thus ensuring unparalleled results.

## Our App Development Services to Bank on:
Our skilled app developers provide a plethora of mobile application development services by harnessing the power of leading-edge tools and tech stacks. We focus on delivering creatively crafted and strategically designed mobile apps that can take your business to a whole new level.

**[Android Application Development Company](https://www.appstudio.ca/android-application-development.html)**
**[iOS App Development Services](https://www.appstudio.ca/ios-app-development.html)**
**[Healthcare App Development Services](https://www.google.ca/url?sa=t&url=https%3A%2F%2Fwww.appstudio.ca/healthcare-app-development.html)**

## Hire Our Worldwide Developers for Your Business:
**[Mobile App Development Company Ottawa](https://www.appstudio.ca/app-development-company-in-ottawa.html)**
**[Mobile App Development Agency in Dubai](https://www.appstudio.ca/mobile-app-development-company-in-dubai.html)**

## AppStudio is your trusted technology partner. Contact us to discuss your project:- 
**Email:info@appstudio.ca**
**Phone:+1(800)-352-9138**
**Website:[https://www.appstudio.ca/](https://www.appstudio.ca/)**
Java 18 - Standardized efficiency
Published: 2021-12-27 12:26:09

---
title: Java 18 - Standardized efficiency
published: true
description: Java 18 is released, and the new JDK will bring a lot of interesting features to java. We go through all the features in 18 and talk about the performance benefits and some important caviats to keep track on in your code.
tags:
cover_image: https://i.ytimg.com/vi/t10UFNhdQps/maxresdefault.jpg
---

{% youtube t10UFNhdQps %}

Java 18 is released, and the new JDK will bring a lot of interesting features to java. We go through all the features in 18 and talk about the performance benefits and some important caviats to keep track on in your code.
Generate a Blockchain Key Pair Address in Rust
Published: 2021-12-27 12:06:17

Hi, in this tutorial, we will be looking at how to generate a blockchain key pair address with the rust programming language. 


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vq2o1fegotuf7q4sjs3n.jpeg)

[image credit : https://connects.world]

In this project,two crates were used namely:
- Secp256k1[https://docs.rs/secp256k1/latest/secp256k1/] 
- anyhow (https://crates.io/crates/anyhow). 

`Secp256k1` is a Rust implementation of [the Pieter Wuille’s secp256k1 eliptic curve](https://github.com/sipa/secp256k1). The bitcoin network uses this eliptic curve for its public key generation algorithm too.

The `anyhow` crate is used for handling errors graciously in Rust.

_Enough of the talking...._

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2a5g01dit0ztru9x6gda.png)

First, we declare a public function named `create_keypair()` which returns a public key and private (secret) key pair. We then initiate the `secp256k1` crate. On line 9 we used the random number generator `rng` on the `secp256k1` crate to generate a secure private key. On line 10, we generated the key-pairs by invoking the `generate_keypair` method which takes a rng from line 9.

The main function just makes a call to the `create_keypair()` function, and then prints the output.


Note: As you change the integer in `seed_from_u64`, you get a different set of private and public keys.


**Conclusion**

To run the code for this tutorial, add the following lines to your `Cargo.toml` file

```=toml
[dependencies]

secp256k1 = {version = "0.20.3", features = ["rand"]}
anyhow = "1.0.47"
```
Open your terminal then execute `cargo run`.


I hope you enjoyed the tutorial, you can drop your comments if you have questions.
Distinguish between Bind, Call and Apply methods in Javascript.
Tags: javascript
Published: 2021-12-27 11:34:00

**Bind**: If you want to use another object's property in an object method, you can bind it.
Just call the method and bind it to that object.
More important thing in the bind method is, the bind method returns a function. So you need to call the function again.
You can also pass more parameters, inside the bind method.


_For example_:

```javascript
let person = {
    
    fullName: function(city,country) {
        console.log(this.firstName + ' ' +this.lastName +' staying '+ city + ' ' +country);
    }
};

let person1 = {
    firstName: 'Faisal',
    lastName: 'Ahmed'
    
};

let person2 = {
    firstName: 'I am',
    lastName: 'FAS'
    
};

let binded = person.fullName.bind(person1,"Dhaka","Bangladesh");
binded();

```

`output: Faisal Ahmed staying Dhaka Bangladesh`

---




**Call**: The call method is similar to the bind method. But the difference is that the call method does not return a function like bind method. It directly shows the output.
More important thing in the call method is, the call method passes more parameters, inside the call method. But parameters are separated by comma, comma.


_For example_:

```javascript
const person = {
    
    fullName: function(city,country) {
        return this.firstName+ " " +this.lastName + " staying "  +city+  " in "  +country;
    }
};

const person1 = {
  firstName: "Faisal",
  lastName: "Ahmed"
}

const person2 = {
  firstName: "I am",
  lastName: "FAS"
}


console.log(person.fullName.call(person1,"Dhaka","Bangladesh"));

```

`output: Faisal Ahmed staying Dhaka in Bangladesh`

---




**Apply**: The apply method is similar to the call method. The apply method also does not return a function like bind method. It directly shows the output.
More important thing in the apply method is, the apply method passes more parameters, inside the apply method. But parameters will be an array.


_For example_:

```javascript
const person = {
    
    fullName: function(city,country) {
        return this.firstName+ " " +this.lastName + " staying "  +city+  " in "  +country;
    }
};

const person1 = {
  firstName: "Faisal",
  lastName: "Ahmed"
}

const person2 = {
  firstName: "I am",
  lastName: "FAS"
}


console.log(person.fullName.apply(person1,["Dhaka","Bangladesh"]));

```

`output: Faisal Ahmed staying Dhaka in Bangladesh`

---