Tips, Expertise, Articles and Advice from the Pro's for Your Website or Blog to Succeed
Technically, you can use any printer for your art and crafts. However, the best printer for crafters should have a high maximum DPI and be compatible with the materials you use for your crafting projects. Again, when your machine is both powerful and versatile, you will see the quality reflected in your DIY projects. This...
The post Best Printer for Crafters Reviews appeared first on DesignrFix.
WordPress sites may soon see a slight performance improvement on page loads, thanks to a fix for a performance regression in the core lazy loading feature. An analysis published in July 2021 showed that lazy loading applied too aggressively can have a negative impact on performance and that it’s better to eagerly load the images within the initial viewport.
WordPress’ default of lazy loading all images was causing slower performance on the Largest Contentful Paint metric (LCP) metric, which Google defines as “the render time of the largest image or text block visible within the viewport, relative to when the page first started loading.”
Google-sponsored WordPress contributors wrote a fix that avoids lazy-loading images above the fold and thoroughly tested it as part of their efforts to evaluate the impact of various past performance initiatives. The delayed LCP will be fixed in WordPress 5.9.
“This can be improved by skipping addition of loading='lazy' for the first content image or iframe, which in the vast majority of cases will appear within the initial viewport,” Felix Arntz said in the dev note. “WordPress can only make educated guesses around that and not be 100% certain, but an analysis taking into account 50 popular themes showed that the enhancement brought LCP improvements across the board, up to 30% faster page load.”
In the future, this implementation may be able to drill down further into the block content on the page and eagerly load whatever images the theme identifies as being within the viewport.
“Have you thought about how we could have more precise heuristics going forwards that can take the semantics and structure of blocks into account to get a sense for what is actually deferrable?” Matias Ventura commented on the ticket in process. “For example, an image block or a site logo used in a header template part would be strong indicatives of being above the fold. ‘The first image of the content’ seems instead like a rudimentary measure, that varies a lot depending on preceding layout. With block themes we should have some ahead-of-time awareness of layout which we can use to produce more meaningful instructions.”
Felix Arntz said he already has detecting the header template part on his radar and is willing to refine the implementation as the world of block themes expands.
“The refinement of the lazy-loading implementation should notably improve LCP performance for most sites that rely on it, while not having adverse effects for sites where the default heuristics described above do not apply to,” Arntz said. “That is only a solid starting point though. In the future, specifically with the more semantic content specification that block-based themes will facilitate, we will be able to further fine tune the lazy-loading implementation by using the available block information.”
There has been a couple of years since the announcement of the removal of Apache Zookeeper as a dependency to manage Apache Kafka metadata. Since version 2.8, we now can run a Kafka cluster without Zookeeper. This article will go over three easy ways to get started with a single node cluster using containers.
Apache Kafka implements independent control and data planes for its clusters. The control plane manages the cluster, keeps track of what brokers are alive, and takes action when the set changes. Meanwhile, the data plane consists of the features required to handle producers and consumers and their records. In the previous iterations, Zookeeper was the cluster component that held most of the implementation of the control plane.
WorkManager is the preferred method of managing background tasks on Android. It also includes convenient extensions for RxJava3 and Kotlin Coroutines.
In this tutorial, we will learn how to use WorkManager as well as how to observe the background task with the debugging tool Background Task Inspector.
At the end of the tutorial, you would have learned:
To follow along with the tutorial, perform the steps below:
Create a new Android project with the default Empty Activity.
Add the WorkManger dependency to your module build.gradle file.
def work_version = "2.7.1"
implementation "androidx.work:work-runtime-ktx:$work_version"Remove the default Hello World! TextView.
Add a new Button inside ConstraintLayout.
Constrain the Button to the center of ConstraintLayout.
Extract the Button android:text value to strings.xml, using download_button as the resource name and Download File as the Resource value.
Your activity_main.xml should look similar to the code below.
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/button_download"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>androidx.workBefore writing any code, we will first need to know about the primary classes of WorkManager. Most of the classes related to WorkManager can be found in the androidx.work package. The most basic classes are Worker, WorkRequest, and WorkManager.
WorkRequest.Builder or use the two existing concrete implementations OneTimeWorkRequest or PeriodicWorkRequest. You can create OneTimeWorkRequest objects by wrapping Worker objects.doWork() function.Work#doWork(). You can create Result objects by calling Results static functions failure(), retry(), and success().For this tutorial, we will have our app start a fake download WorkRequest. When the user taps Download File, the background thread that executes the work request will wait for 1 second before reporting back the ListenableWorker.Result status.
We will also use the Background Task Inspector debugging facility to observe our work progress.
It is finally time to write some code. Our first task is to create a concrete implementation of Worker.
In the same package as the MainActivity class, create a new Kotlin class called DownloadWorker.kt.
class DownloadWorker {
}Add Worker as the parent.
class DownloadWorker(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {
}Implement the doWork() function. This implementation will wait for 1 second and return a SUCCESS status.
override fun doWork(): Result {
Thread.sleep(1_000L)
return Result.success()
}As stated previously, a default WorkManager is automatically initialized by our App on startup. Because our use case is quite simple and does not require a custom WorkManager, we can just use the default WorkManager instance using the convenient static function WorkManger#getInstance().
Inside MainActivity.kt#onCreate(), append the line of code below.
val workManager = WorkManager.getInstance(applicationContext)Create the a OneTimeWorkRequest object by appending the line of code below to onCreate(). You must pass in the Java class object to the from() function.
val oneTimeDownloadWorkRequest = OneTimeWorkRequest.from(DownloadWorker::class.java)Append the line of code below to onCreate() retrieve the Button object.
val button = findViewById<Button>(R.id.button)Bind the Button click to the work request in onCreate().
button.setOnClickListener {
workManager.enqueue(oneTimeDownloadWorkRequest)
}The Background Task Inspector is a special debugging facility available when your WorkManager runs at Android API level 26 or above. To see how it works, follow the steps below:
DownloadWorker.kt
package com.example.daniwebandroidworkmanager
import android.content.Context
import androidx.work.Worker
import androidx.work.WorkerParameters
class DownloadWorker(context: Context, workerParams: WorkerParameters) : Worker(context, workerParams) {
override fun doWork(): Result {
Thread.sleep(1_000L)
return Result.success()
}
}MainActivity.kt
package com.example.daniwebandroidworkmanager
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import androidx.work.OneTimeWorkRequest
import androidx.work.WorkManager
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val workManager = WorkManager.getInstance(applicationContext)
val oneTimeDownloadWorkRequest = OneTimeWorkRequest.from(DownloadWorker::class.java)
val button = findViewById<Button>(R.id.button)
button.setOnClickListener {
val operation = workManager.enqueue(oneTimeDownloadWorkRequest)
}
}
}strings.xml
<resources>
<string name="app_name">Daniweb Android WorkManager</string>
<string name="button_download">Download File</string>
</resources>activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/button_download"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>We have learned how to use WorkManager and the Background Task Inspector. The full project code can be found at https://github.com/dmitrilc/DaniwebAndroidWorkManager
Coil is a popular image loading library for Kotlin-first Android projects. It is lightweight, fast and is super easy to use.
In this tutorial, we will learn how to use Coil to load images into our project.
At the end of the tutorial, you would have learned:
To follow along with the tutorial, perform the steps below:
Create a new Android project with the default Empty Activity.
Remove the Default Hello World! TextView.
Add a new ImageView inside ConstraintLayout.
<ImageView
android:id="@+id/imageView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
tools:srcCompat="@tools:sample/avatars" />Add a new Button below ImageView with the code below.
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/load_image"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/imageView" />Add the <string> elements below to your strings.xml file.
<string name="load_image">Random Image</string>
<string name="circle">https://github.com/dmitrilc/DaniwebAndroidNativeCoil/raw/main/app/src/main/res/drawable/circle.png</string>
<string name="rect">https://github.com/dmitrilc/DaniwebAndroidNativeCoil/raw/main/app/src/main/res/drawable/rect.png</string>
<string name="triangle">https://github.com/dmitrilc/DaniwebAndroidNativeCoil/raw/main/app/src/main/res/drawable/triangle.png</string>The dependency to the Coil library to your module gradle.build file.
implementation 'io.coil-kt:coil:1.4.0'Inside your AndroidManifest.xml, Add the android.permission.INTERNET permission before <application>, but after <manifest>.
<uses-permission android:name="android.permission.INTERNET" />The Coil library includes a handful of artifacts. For the two base artifacts, certain variants contain a singleton ImageLoader instance and (Kotlin) extension functions for ImageView.
Support for Jetpack Compose:
Regarding the versions with the singleton ImageLoader, the library even went as far as to say that you should use the version without the singleton ImageLoader instead if you plan to inject the ImageLoader instance using dependency injection. If you are instantiating a custom ImageLoader instance and having a global singleton instance as well, then you might end up with multiple instances of ImageLoader at runtime.
For our tutorial, we will use the version with the singleton ImageLoader and ImageView extension functions.
Coil also includes artifacts for supporting gif, svg, and video formats.
Coil has two primary classes, ImageLoader and ImageRequest.
data property) or the target ImageView to load the Image to (with its target property).It is good to know about these two classes, but if you are using the io.coil-kt:coil artifact, then you barely have to write any boilerplate code at all. Loading an image is as simple as calling one of the load() extension functions on an ImageView reference.
The simplest way to get an image is to use the ImageView extension functions.
In MainActivity#onCreate(), get the Button reference.
val button = findViewById<Button>(R.id.button)Then, get the ImageView reference.
val imageView = findViewById<ImageView>(R.id.imageView)Finally, bind the Button to a load() action. The code below will randomly load one of three images from this projects github repository.
button.setOnClickListener {
when(Random.nextInt(0, 3)){
0 -> imageView.load(getString(R.string.rect))
1 -> imageView.load(getString(R.string.triangle))
2 -> imageView.load(getString(R.string.circle))
}
}This is the longer route and is unnecessary for our project, but I will still show it as reference. In onCreate(), also add the multi-line comment below.
/** Long way to load an image
val imageLoader = applicationContext.imageLoader
val request = ImageRequest.Builder(applicationContext)
.data(getString(R.string.rect))
.target(imageView)
.build()
imageLoader.enqueue(request)
**/We are now ready to run our App. In the gif below, I have also included the Profiler output to demonstrate how resources were used when loading the image.
MainActivity.kt
package com.example.daniwebandroidnativecoil
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.widget.Button
import android.widget.ImageView
import coil.Coil
import coil.imageLoader
import coil.load
import coil.request.ImageRequest
import coil.util.CoilUtils
import okhttp3.OkHttpClient
import kotlin.random.Random
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val button = findViewById<Button>(R.id.button)
val imageView = findViewById<ImageView>(R.id.imageView)
button.setOnClickListener {
when(Random.nextInt(0, 3)){
0 -> imageView.load(getString(R.string.rect))
1 -> imageView.load(getString(R.string.triangle))
2 -> imageView.load(getString(R.string.circle))
}
}
/** Long way to load an image
val imageLoader = applicationContext.imageLoader
val request = ImageRequest.Builder(applicationContext)
.data(getString(R.string.rect))
.target(imageView)
.build()
imageLoader.enqueue(request)
**/
}
}activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<ImageView
android:id="@+id/imageView"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
tools:srcCompat="@tools:sample/avatars" />
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/load_image"
app:layout_constraintBottom_toBottomOf="parent"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toBottomOf="@+id/imageView" />
</androidx.constraintlayout.widget.ConstraintLayout>strings.xml
<resources>
<string name="app_name">Daniweb Android Native Coil</string>
<string name="load_image">Random Image</string>
<string name="circle">https://github.com/dmitrilc/DaniwebAndroidNativeCoil/raw/main/app/src/main/res/drawable/circle.png</string>
<string name="rect">https://github.com/dmitrilc/DaniwebAndroidNativeCoil/raw/main/app/src/main/res/drawable/rect.png</string>
<string name="triangle">https://github.com/dmitrilc/DaniwebAndroidNativeCoil/raw/main/app/src/main/res/drawable/triangle.png</string>
</resources>build.gradle
plugins {
id 'com.android.application'
id 'kotlin-android'
}
android {
compileSdk 31
defaultConfig {
applicationId "com.example.daniwebandroidnativecoil"
minSdk 21
targetSdk 31
versionCode 1
versionName "1.0"
testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
compileOptions {
sourceCompatibility JavaVersion.VERSION_1_8
targetCompatibility JavaVersion.VERSION_1_8
}
kotlinOptions {
jvmTarget = '1.8'
}
}
dependencies {
implementation 'androidx.core:core-ktx:1.7.0'
implementation 'androidx.appcompat:appcompat:1.4.0'
implementation 'com.google.android.material:material:1.4.0'
implementation 'androidx.constraintlayout:constraintlayout:2.1.2'
implementation 'io.coil-kt:coil:1.4.0'
testImplementation 'junit:junit:4.+'
androidTestImplementation 'androidx.test.ext:junit:1.1.3'
androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
}We have learned how to use Coil to load images. The full project code can be found at https://github.com/dmitrilc/DaniwebAndroidNativeCoil
With the emergence of the fourth industrial revolution, the concept of Industry 4.0 has been introduced. It is actually the digital transformation of the manufacturing industries by the use of advanced technology like robotics, the Internet of Things, cybersecurity, artificial intelligence, augmented reality (AR), and virtual reality (VR). It is also called smart factories.
Out of these advanced techs, AR and VR are forming a bridge between the physical and imaginary world of manufacturing by forming a cyber-physical system. Augmented reality and virtual reality have revolutionized the manufacturing businesses from designing the product to its delivery in the real world. According to IDC, after 2021, worldwide spending on virtual and augmented reality is expected to double each year.
In the video below, we take a closer look at Filter or Criteria Design Pattern in Java with an introduction, example, and key points. Let's get started!
If you are using email marketing for your business and looking to skyrocket your sales with advancements in your marketing campaigns, then this article is for you. Learn how you can benefit by implementing artificial intelligence (AI) in email marketing in 2022 and leverage the sales through it.
In the age of cutting-edge technologies such as voice search, instant SMS, etc., email marketing still is one of the most common and profitable ways of online marketing. A major chunk of marketers considers email marketing as the major part of their marketing success.
Almost all modern applications require storing and accessing data, but choosing the right database to power an application is a difficult task that involves reasoning about a complex set of tradeoffs. Developers typically need to think about the following:
These dimensions are all important, but latency stands apart from the rest because it is the most difficult to reason about and it is often impossible to engineer around. Low latency is also growing in importance as business logic moves to the edge, making the difference between a local and remote API call more jarring and disruptive to users.
Excited to launch my new book: Wizard's SQL Recipes for WordPress. Optimize and manage your WordPress database. Complete chapter on optimizing performance. Over 300 time-saving recipes. Level up your database skills!
As the distinction between data professionals and non-data professionals becomes smaller and smaller, the need for technology that bridges the gap between the two parties is crucial. The benefits of interacting with a data warehouse, especially with large amounts of data, are unquestionable, but as a peripheral member of the core technology team who might not be very technical, it is not always practical to generate SQL queries on the fly.
This poses a problem, especially when departments such as sales, customer success, account management, etc., want the robust insights that could come from the vast amount of data that a company is storing, but they don’t necessarily know how to quickly gather these insights.
Standards are critical to the successful development of emerging technologies, and Polkadot is no exception. It's important because the proper standard set at the right time can help improve interoperability and build trust within the technology ecosystem (opening the doors to mass adoption).
Benchmarks like these are crucial to enable token-based smart contracts that interact with each other. Without a standard, anyone can develop and deploy their own smart contract. The problem with this approach is that they would have to expose the same function signature to enable true interoperability.
Graviton2 processors are a type of server processor released by AWS in 2020. They’re a successor to the first generation of Graviton processors (simply called Graviton).
They’re custom-built by AWS using 64-bit Arm architecture, with the goal of offering better performance across EC2 instances vs competitors.
Since NoSQL Databases are widely used and preferred among developers, because of their close relation to the Agile methodology, we decided to focus on their functionality in this article. At first, we need to define how we see NoSQL abbreviation, considering that there are several different versions for that. In the battle of the meanings, we have literally the database without SQL usage, and "not only SQL." Surely, we’d prefer to cognize the second option, but not anti-definition, given that SQL is running in any backend and traditionally is not eliminated.
The NoSQL databases create more intuitive methods of storing data, allowing to model the structured linkage that will be closer to the application’s form. They require fewer transformations when saving or retrieving with NoSQL APIs. Furthermore, NoSQL databases can fully utilize the Cloud to ensure minimal outage. As you can notice, NoSQL DB seems to be beneficial and more flexible than traditional storing. Let’s discover this difference in further detail.
Supply chain risks continue to be a major concern for manufacturers, and the organizations and customers they serve. According to recent research, software supply chain attacks are up 650 percent in the past year alone and ENISA expects these types of attacks to quadruple by the end of 2021.
But assessing supply chain risks can be a complex task for product teams. And when not done properly, can have devastating impacts. Just look at the SolarWinds attack and the recent blog from Microsoft showing that the group behind that attack, Nobelium, has since targeted 140 additional resellers and service providers.
With many people shifting to digital online broadcasting, the platform has grown exponentially. YouTube data has become a major part of the analysis in machine learning and data analytics. Using SerpApi, we will extract YouTube data and query it for analysis.
The product is easy to use and flexible to tailor across multiple YouTube content depending on the field of interest. However, one will require a mid-level knowledge and understanding of:
Chef InSpec is an open-source testing framework and used to test or validate the configurations, security components as per the client's requirements or organization's requirements. It is mainly used to test infrastructure configurations. Using Chef Inspec, we can even test cloud services such as AWS, Google (GCP), Azure.
In this article, we are going to see how to configure Chef Inspec in our local system to execute Chef Inspec tests.