In 2005 we asked Velvet Revolver to guest edit the June issue of Classic Rock. The late Scott Weiland let us know what David Bowie meant to him, while Slash commissioned a feature on the early days of

Slash reminisces about the band who inspired his journey through rock'n'roll

MARTIN Lewis has revealed an “easy win” when it comes to slashing energy bills with a simple swap. The MoneySavingExpert has tonight told how much of a “no brainer&amp;…

'It's a no brainer', says Martin Lewis as he reveals 'easy win' way to slash energy bills with swap | The Sun

Barcelona&#x27;s annual spending limit has been cut by a further €66 million ($71m), reduced from €270m to €204m, LaLiga announced on Tuesday.

More money woes for Barcelona as LaLiga slashes spending limit - ESPN

iSlash

islash

If you bumped into this page thinking you’re gonna get rich with some get-rich-quick scheme, I’m sorry to disappoint you. This article will rather talk about how to decrease your cloud cost bills by $1 million. By doing that, you will have essentially generated an extra million dollars in revenue — which you can spend buying my online course on how to get rich with AWS (link to course here). Cloud cost is often overlooked and unaccounted for at the beginning of Companies’ projects. The 2021 HashiCorp survey found that almost 40% of companies overspent on cloud costs in 2021 [1]. In 2023, almost all companies (94%) admitted that they were wasting money on the cloud [1] and at least 30% of cloud cost was wasted [2]. Cloud spending was almost $500 billion in 2022 — therefore we’re talking about $150 billion wasted a year!! Not only this is a concern of missed revenues but also poor sustainability practices. $150 billion of wasted energy! These findings involve large enterprises as well as smaller ones, from high-cloud maturity to low-cloud maturity. It refers to AWS, but the same principles can be applied to any other cloud provider. So, if any part of your job is in the cloud, then this article is for you. I’m speaking from a data engineer perspective, but the same learnings can be applied to other software engineering practices. Let’s dive in. What does it take to spend $1 million in cloud costs in a year? This kind of cloud bill is usually restricted to very large enterprises that operate globally with millions of customers. To give you an idea, a $1 million cloud bill can result from a Spark ETL job processing ~1.5Tb per hour 24x7 for 365 days a year. Another example might be an application that receives billions of requests a day from multiple locations in the world. In a large enterprise, there are hundreds of applications at this size — resulting in billion-dollar contracts with cloud-providers. For example, Airbnb had a commitment to spend $1.2 billion on cloud resources over five years at the end of 2019 [3]. At Expedia we slashed costs for a data processing ETL costing $1.1 million dollar a year to a mere $100,000 a year by implementing optimisation practices. That’s a 91% cost reduction!! Not all companies have applications of such a huge size but imagine cutting your cloud cost by 90% just for a single application or for your entire company. How do we start saving? STEP 1: Challenge your design assumptions Go and get a list of your most expensive applications and challenge your design assumptions. Are you building an application that has a 99.999% availability and sub-millisecond latency but realistically users would be good enough with a 99% availability and hundreds of millisecond latency?
Are you creating datasets with billions of rows but users would only be using aggregations of some of the measures?
Are you landing data real-time but data is only analysed once a day?
Are you refreshing the cache every 10 seconds but it’s only really changing across days? All these questions go back to the most important question: how is the application going to be used? What’s the business value for it to exist? How is the application helping us to achieve a given goal? Of course, all these answers are very often unclear at the beginning of a project; but that’s why design should always be an iterative process — allowing changes to happen as seamlessly as possible. Engineers should embrace evolution and change, aligning application development with impact. STEP 2: Fine-tune your infrastructure resources to your needs The second step consists of providing the application with the right resources and tuning it to the right infrastructure. As an engineer, be aware of how cloud costs are calculated. For example, AWS provides spot instances, where you can bid for the cluster price — this is particularly useful if you have fault-tolerant and flexible applications. Use them if you can — AWS claims up to 90% reduction in costs [4]. Some other considerations you might want to address are: Are you serving customers globally or only in one geographical area? Do you really need your infrastructure to live across the globe or can you set it up closer to your customer base?
Are you over-provisioning your cluster instances? Try to ensure there is enough capacity to handle peak loads without unnecessary costs. Utilise auto-scaling to dynamically adjust resources based on actual demand, preventing overpayment for idle resources.
If you’re working with data and Spark, make sure you understand Spark concepts and tuning! If you don’t, take a look at the following resources [5] [6] [7] [8] [9]. STEP 3: Use AWS Graviton instances There are little to no drawbacks in utilising AWS Graviton instances. AWS has invested heavily in creating the most cost-effective processors. You can get up to 40% reduction in cloud spending just by switching from an intel-based processor to an ARM-based processor [10]. The only caveat to this is that your application needs to be compatible with the ARM-based processors that Graviton runs on. If you’re dealing with a managed service such as RDS or OpenSearch then there’s no complication at all in switching — AWS deals with the underlying OS and application compatibility. If you’re building your own application, then you might need to recompile the package depending on which language you’re using — Java and other languages require no change whereas Python requires some attention. STEP 4: Monitor your cost spending and educate on cost awareness Lastly, don’t forget to keep monitoring your costs for unexpected peaks and surprises. The cost on day 0 of your application will be different from the cost on day 170. Make sure you keep track of the changes, and you understand why the change is happening: is it stacking s3 storage costs or is it just a one-off spike? Set up the necessary alerts and operational guidebooks! Importantly, implement cost allocation tags to track spending by department, project, or environment. Avoid the risk of creating a data swamp where cost is untraceable or requires a long journey across different log systems. It should be quick and simple to go back to any given application cost. Final thoughts Wherever you are working, balancing the delivery of new features with the optimisation of current ones is hard. Who hasn’t been pressured to deliver new quirky features at the speed of light. However, it is essential for both engineers and managers to make deliberate and proactive decisions about their current projects, managing risks and opportunities effectively. If you bumped into this page thinking you’re gonna get rich with some get-rich-quick scheme, I’m sorry to disappoint you. This article will rather talk about how to decrease your cloud cost bills by $1 million. By doing that, you will have essentially generated an extra million dollars in revenue — which you can spend buying my online course on how to get rich with AWS (link to course here). If you bumped into this page thinking you’re gonna get rich with some get-rich-quick scheme, I’m sorry to disappoint you. This article will rather talk about how to decrease your cloud cost bills by $1 million. By doing that, you will have essentially generated an extra million dollars in revenue — which you can spend buying my online course on how to get rich with AWS ( link to course here ). link to course here Cloud cost is often overlooked and unaccounted for at the beginning of Companies’ projects. The 2021 HashiCorp survey found that almost 40% of companies overspent on cloud costs in 2021 [ 1 ]. In 2023, almost all companies (94%) admitted that they were wasting money on the cloud [ 1 ] and at least 30% of cloud cost was wasted [ 2 ]. Cloud spending was almost $500 billion in 2022 — therefore we’re talking about $150 billion wasted a year!! 1 1 2 Not only this is a concern of missed revenues but also poor sustainability practices. $150 billion of wasted energy! These findings involve large enterprises as well as smaller ones, from high-cloud maturity to low-cloud maturity. It refers to AWS, but the same principles can be applied to any other cloud provider. So, if any part of your job is in the cloud, then this article is for you. I’m speaking from a data engineer perspective, but the same learnings can be applied to other software engineering practices. Let’s dive in. What does it take to spend $1 million in cloud costs in a year? What does it take to spend $1 million in cloud costs in a year? This kind of cloud bill is usually restricted to very large enterprises that operate globally with millions of customers. To give you an idea, a $1 million cloud bill can result from a Spark ETL job processing ~1.5Tb per hour 24x7 for 365 days a year. Another example might be an application that receives billions of requests a day from multiple locations in the world. In a large enterprise, there are hundreds of applications at this size — resulting in billion-dollar contracts with cloud-providers. For example, Airbnb had a commitment to spend $1.2 billion on cloud resources over five years at the end of 2019 [ 3 ]. 3 At Expedia we slashed costs for a data processing ETL costing $1.1 million dollar a year to a mere $100,000 a year by implementing optimisation practices. That’s a 91% cost reduction!! Not all companies have applications of such a huge size but imagine cutting your cloud cost by 90% just for a single application or for your entire company. How do we start saving? STEP 1: Challenge your design assumptions Go and get a list of your most expensive applications and challenge your design assumptions . challenge your design assumptions Are you building an application that has a 99.999% availability and sub-millisecond latency but realistically users would be good enough with a 99% availability and hundreds of millisecond latency? Are you creating datasets with billions of rows but users would only be using aggregations of some of the measures? Are you landing data real-time but data is only analysed once a day? Are you refreshing the cache every 10 seconds but it’s only really changing across days? Are you building an application that has a 99.999% availability and sub-millisecond latency but realistically users would be good enough with a 99% availability and hundreds of millisecond latency? Are you creating datasets with billions of rows but users would only be using aggregations of some of the measures? Are you landing data real-time but data is only analysed once a day? Are you refreshing the cache every 10 seconds but it’s only really changing across days? All these questions go back to the most important question: how is the application going to be used? What’s the business value for it to exist? How is the application helping us to achieve a given goal? how is the application going to be used? What’s the business value for it to exist? How is the application helping us to achieve a given goal? Of course, all these answers are very often unclear at the beginning of a project; but that’s why design should always be an iterative process — allowing changes to happen as seamlessly as possible. Engineers should embrace evolution and change, aligning application development with impact. very often unclear at the beginning of a project; STEP 2: Fine-tune your infrastructure resources to your needs STEP 2: Fine-tune your infrastructure resources to your needs The second step consists of providing the application with the right resources and tuning it to the right infrastructure. As an engineer, be aware of how cloud costs are calculated. For example, AWS provides spot instances, where you can bid for the cluster price — this is particularly useful if you have fault-tolerant and flexible applications. Use them if you can — AWS claims up to 90% reduction in costs [ 4 ]. 4 Some other considerations you might want to address are: Are you serving customers globally or only in one geographical area? Do you really need your infrastructure to live across the globe or can you set it up closer to your customer base? Are you over-provisioning your cluster instances? Try to ensure there is enough capacity to handle peak loads without unnecessary costs. Utilise auto-scaling to dynamically adjust resources based on actual demand, preventing overpayment for idle resources. If you’re working with data and Spark, make sure you understand Spark concepts and tuning! If you don’t, take a look at the following resources [5] [6] [7] [8] [9]. Are you serving customers globally or only in one geographical area? Do you really need your infrastructure to live across the globe or can you set it up closer to your customer base? Are you over-provisioning your cluster instances? Try to ensure there is enough capacity to handle peak loads without unnecessary costs. Utilise auto-scaling to dynamically adjust resources based on actual demand, preventing overpayment for idle resources. If you’re working with data and Spark, make sure you understand Spark concepts and tuning! If you don’t, take a look at the following resources [ 5 ] [ 6 ] [ 7 ] [ 8 ] [ 9 ]. make sure you understand Spark concepts and tuning! 5 6 7 8 9 STEP 3: Use AWS Graviton instances STEP 3: Use AWS Graviton instances There are little to no drawbacks in utilising AWS Graviton instances. AWS has invested heavily in creating the most cost-effective processors. You can get up to 40% reduction in cloud spending just by switching from an intel-based processor to an ARM-based processor [ 10 ]. 10 The only caveat to this is that your application needs to be compatible with the ARM-based processors that Graviton runs on. If you’re dealing with a managed service such as RDS or OpenSearch then there’s no complication at all in switching — AWS deals with the underlying OS and application compatibility. If you’re building your own application, then you might need to recompile the package depending on which language you’re using — Java and other languages require no change whereas Python requires some attention. STEP 4: Monitor your cost spending and educate on cost awareness STEP 4: Monitor your cost spending and educate on cost awareness Lastly, don’t forget to keep monitoring your costs for unexpected peaks and surprises. The cost on day 0 of your application will be different from the cost on day 170. Make sure you keep track of the changes, and you understand why the change is happening: is it stacking s3 storage costs or is it just a one-off spike? Set up the necessary alerts and operational guidebooks ! Set up the necessary alerts and operational guidebooks Importantly, implement cost allocation tags to track spending by department, project, or environment. Avoid the risk of creating a data swamp where cost is untraceable or requires a long journey across different log systems. It should be quick and simple to go back to any given application cost. Final thoughts Wherever you are working, balancing the delivery of new features with the optimisation of current ones is hard. Who hasn’t been pressured to deliver new quirky features at the speed of light. However, it is essential for both engineers and managers to make deliberate and proactive decisions about their current projects, managing risks and opportunities effectively.

How to Earn $1 Million With AWS in One Year

Hoe om $1 miljoen met AWS in een jaar te verdien

በአንድ ዓመት ውስጥ 1 ሚሊዮን ዶላር በAWS እንዴት ማግኘት እንደሚቻል

كيفية كسب مليون دولار مع AWS في عام واحد

Kunjamas Mä Maran AWS ukampix 1 Millón dólares qullqix jikxatasi

Bir ildə AWS ilə necə 1 milyon dollar qazanmaq olar

Як зарабіць 1 мільён долараў з AWS за год

Как да спечелите $1 милион с AWS за една година

কিভাবে এক বছরে AWS দিয়ে $1 মিলিয়ন উপার্জন করবেন

Kako zaraditi 1 milion dolara sa AWS-om u jednoj godini

Com guanyar 1 milió de dòlars amb AWS en un any

Jak vydělat 1 milion $ s AWS za jeden rok

Sådan tjener du $1 million med AWS på ét år

So verdienen Sie mit AWS in einem Jahr 1 Million US-Dollar

Πώς να κερδίσετε 1 εκατομμύριο $ με το AWS σε ένα έτος

Cómo ganar 1 millón de dólares con AWS en un año

Nola irabazi milioi dolar 1 urte batean AWSrekin

چگونه یک میلیون دلار با AWS در یک سال به دست آوریم

Kuinka ansaita miljoona dollaria AWS:llä yhdessä vuodessa

Comment gagner 1 million de dollars avec AWS en un an

Como gañar 1 millón de dólares con AWS nun ano

איך להרוויח מיליון דולר עם AWS בשנה אחת

AWS से एक साल में $1 मिलियन कैसे कमाएँ

Kako zaraditi 1 milijun dolara s AWS-om u jednoj godini

Kijan pou w touche $1 milyon ak AWS nan yon ane

Hogyan kereshet 1 millió dollárt az AWS segítségével egy év alatt

Ինչպե՞ս վաստակել 1 միլիոն դոլար AWS-ով մեկ տարում

Cara Menghasilkan $1 Juta Dengan AWS dalam Satu Tahun

Come guadagnare 1 milione di dollari con AWS in un anno

AWS で 1 年で 100 万ドルを稼ぐ方法

როგორ გამოიმუშავოთ $1 მილიონი AWS-ით ერთ წელიწადში

Бір жылда AWS көмегімен 1 миллион долларды қалай табуға болады

របៀបរកប្រាក់ 1 លានដុល្លារជាមួយ AWS ក្នុងមួយឆ្នាំ

AWS를 통해 1년 안에 100만 달러를 버는 방법

Кантип бир жылда AWS менен 1 миллион доллар тапса болот

Ndenge Nini Ko Gagner $1 Million Na AWS na Année Moko

ວິທີການຫາເງິນ 1 ລ້ານໂດລາດ້ວຍ AWS ໃນໜຶ່ງປີ

Kaip uždirbti 1 milijoną USD naudojant AWS per vienerius metus

Kā nopelnīt USD 1 miljonu, izmantojot AWS vienā gadā

Ahoana ny fomba hahazoana $1 tapitrisa amin'ny AWS ao anatin'ny Taona

Како да заработите 1 милион долари со AWS за една година

AWS ашиглан нэг жилийн дотор хэрхэн 1 сая доллар олох вэ

Cara Mendapat $1 Juta Dengan AWS dalam Satu Tahun

कसरी एक वर्षमा AWS मार्फत $1 मिलियन कमाउने

Hoe u in één jaar $ 1 miljoen verdient met AWS

Tsela ya go Hwetša $ 1 Million Ka AWS ka Ngwaga o tee

Jak zarobić 1 milion dolarów dzięki AWS w ciągu jednego roku

څنګه کولای شو په یو کال کې د AWS سره $1 ملیون ډالر وګټو

Como ganhar US$ 1 milhão com a AWS em um ano

Imaynatataq AWSwan Huk Watapi 1 Millón dolarkunata Ganana

Cum să câștigi 1 milion USD cu AWS într-un an

Как заработать 1 миллион долларов с помощью AWS за год

Nigute Winjiza Miliyoni 1 $ hamwe na AWS mumwaka umwe

වසරක් තුළ AWS සමඟින් ඩොලර් මිලියනයක් උපයන්නේ කෙසේද

Ako zarobiť 1 milión $ s AWS za jeden rok

Maitiro eKuwana $1 Miriyoni NeAWS muGore Rimwechete

Sida loogu kasbado $1 Milyan AWS hal sano gudaheed

Si të fitoni 1 milion dollarë me AWS në një vit

Како зарадити милион долара са АВС-ом за једну годину

Så här tjänar du 1 miljon dollar med AWS på ett år

Jinsi ya Kupata $1 Milioni Ukitumia AWS ndani ya Mwaka Mmoja

AWS மூலம் ஒரு வருடத்தில் $1 மில்லியன் சம்பாதிப்பது எப்படி

Чӣ тавр бо AWS дар як сол 1 миллион доллар ба даст овардан мумкин аст

วิธีสร้างรายได้ 1 ล้านเหรียญสหรัฐด้วย AWS ภายใน 1 ปี

ከመይ ጌርና ብ AWS ኣብ ሓደ ዓመት $1 Million ንረክብ

Bir ýylda AWS bilen 1 million dollar nädip gazanmaly

Paano Kumita ng $1 Milyon Gamit ang AWS sa Isang Taon

AWS ile Bir Yılda Nasıl 1 Milyon Dolar Kazanılır?

Ndlela Yo Hola $1 Million Hi AWS hi Lembe Rin'we

Як заробити 1 мільйон доларів за допомогою AWS за рік

ایک سال میں AWS کے ساتھ $1 ملین کیسے کمائیں۔

AWS yordamida bir yilda qanday qilib 1 million dollar ishlash mumkin

Cách kiếm 1 triệu USD với AWS sau một năm

Uzifumana njani i-$1 yezigidi nge-AWS kuNyaka omnye

如何在一年内利用 AWS 赚取 100 万美元

Ungayithola kanjani i-$1 Million Nge-AWS Onyakeni Owodwa

What Is the Future of Remote Work?

How I Got a Job at Google (as a Software Engineer)

In this article, we will explore how to get a SHA from the last successful Jenkins build for further use in the upstream builds on different agents. Git commit Prerequisites: Jenkins (Freestyle project) with at least one or more Jenkins agents. GIT. Groovy. In Jenkins, we need to install the . For that step you need to go Manage Jenkins → Manage Plugins → Available Plugin Groovy plugin We need to restart Jenkins to finish the plugin installation process. After plugin installation, In Jenkins job configuration, in the field “ “ choose “ ”. Build Steps Execute system groovy script The difference between the and the is that system groovy script runs inside master JVM’s (you need to have root permission for your Jenkins user). Groovy scripts run in a forked JVM, on the slave where the build is run. System groovy script Groovy script Script section: In this section, we can choose between the Groovy command and the Groovy script file(you can put Groovy file wherever you want on the slave node or git repository). Add the following groovy script: import hudson.EnvVars
import hudson.model.*

// Get current name of running job. Example: "Test-Job"

def jobName = build.project.name;

// Get instance of the current job for specified name

def job = hudson.model.Hudson.instance.getItem(jobName);

// Get list of the builds (objects) for current job. Example: [Test-Job #1, Test-Job #N] 

def builds = job.getBuilds();

// Find the first build with environment variables equals 'YES'. Descending numbering. It means [99, 98, , 1]. The first is 99

def successfulBuild = builds.find { build -> (build.envVars['IS_BUILD_SUCCESSFUL'] == 'YES') };

if (successfulBuild == null) {
  return;
}

// Get git commit for successful build

def gitCommitForSuccessfulBuild =  successfulBuild.envVars['GIT_COMMIT'];
def isLastSuccessFullBuild = successfulBuildToSF.envVars['IS_BUILD_SUCCESSFUL'];

println('Successful build number');
println(successfulBuild.envVars['BUILD_NUMBER']);
println(isLastSuccessFullBuild);

// Prepare a variable for export to environment in order to be accessible from next jobs

if (gitCommitForSuccessfulBuild) {
  def varForExport = [
    GIT_COMMIT_FOR_LAST_SUCCESSFUL_BUILD:  gitCommitForSuccessfulBuild,
    IS_LAST_SUCCESSFUL: isLastSuccessFullBuild
  ];
  build.environments.add(0, Environment.create(new EnvVars(varForExport)));
}; Now we need to add our new variable “IS_BUILD_SUCCESSFUL“ to the build process and Inject environment variables. For this, we need to add “Execute Shell” and “Inject environment variables“  in the last steps of our build. Inside “Execute Shell” we are writing our variable and put it inside the env.properties file: echo IS_BUILD_SUCCESSFUL="YES" > env.properties Inside “Inject environment variables“ we are writing the name of the file with the variable: This example will work after one successful build (Jenkins must write at least one successful variable to the file). Summary In this scenario, we explored the step-by-step instructions for how can we get the GIT commit SHA from a successful downstream build to an upstream build.  Also, in a similar example, we can get any variable used in the downstream build.

How to Get the Last Successful Git Commit SHA in Jenkins

Creating and Releasing an App with Flutter: Part II

Introduction As with networking, working with a database is an equally frequent need when developing android applications. In part, the two areas are intertwined because the database usually stores data that is retrieved from the network and now needs to be cached to reduce the number of requests to the network. When working with a simple table with a few dozen rows, you won't have any problems. However, in my practice, there was a case where you had to load dozens of databases with hundreds of tables, some of which contained about a million rows. I've also had cases where tables were linked via nested with nesting levels as high as 5-10. To solve all these problems, I had to use all the libraries and tools listed below to get the desired result or to fix bugs. Because one tool sometimes didn't allow me to do what the other one allowed me to do. SELECT Observations and Assumptions First, I want to draw your attention to some comments and assumptions: This article will look at specific examples whose code can be inserted into , run and see what happens; Android Studio This article will focus on working with relational databases. We will not consider non-relational ( ) databases; NoSQL We will consider the database ; sqlite We will go from simple things, gradually increasing in complexity; The code will not be broken into layers according to and patterns. This is done to simplify the examples and the article as a whole; MVP MVVM The article is designed for developers with medium level and above, so we won't dwell on very simple things, for the same reason we won't go deep into each individual example or library. Only an overview of the tools to broaden your horizons is provided. Selecting an Example To review the libraries and tools below, let's choose an example. Let's say we have this table with two columns: id and color. Let's try to write this table to the database in different ways and get this result: Tools and Libraries for Working With the SQLite Database SQLiteOpenHelper Let's take a look at the first native tool for working with a database on . Our task is to write data to the database on the device. SQLiteOpenHelper Android You don't need to pull in any libraries. Create an , insert the following code and run it. Activity Don't forget to set it to the background thread as shown : here package com.leonidivankin.draftsandroid.articles.db

import android.content.ContentValues
import android.database.sqlite.SQLiteDatabase
import android.database.sqlite.SQLiteOpenHelper
import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity

class SQLiteOpenHelperActivity : AppCompatActivity() {

    private val db by lazy {
        object : SQLiteOpenHelper(this, "colors_db", null, 1) {
            override fun onCreate(db: SQLiteDatabase) {
                db.execSQL("CREATE TABLE $TABLE_NAME (_id INTEGER PRIMARY KEY AUTOINCREMENT, color TEXT)")
            }
            override fun onUpgrade(db: SQLiteDatabase?, oldVersion: Int, newVersion: Int) {}
        }.readableDatabase
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Thread{
            insert( "green")
            insert( "red")
            insert( "blue")
            get()
        }.start()
    }

    private fun insert(color: String) {
        val contentValues = ContentValues()
        contentValues.put(COLUMN_NAME, color)
        db.insert(TABLE_NAME, null, contentValues)
    }

    private fun get() {
        val cursor = db.query(TABLE_NAME, arrayOf("_id", COLUMN_NAME), null, null, null, null, null)
        var i = 0
        while (!cursor.isLast) {
            cursor.moveToPosition(i)
            val id = cursor.getInt(0)
            val color = cursor.getString(1)
            Log.d("DbExample", "$id $color")
            i++
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        db.close()
    }

    companion object {
        const val TABLE_NAME = "colors"
        const val COLUMN_NAME = "color"
    }
} We created a database. colors_db The output log shows that we achieved our goal: D: 1 green
D: 2 red
D: 3 blue As you can see, creating the table, filling it with data, and outputting it took no more than 50 lines of code. Pros and cons +no additional libraries are needed -it is hard to work with complex queries and selections -it is necessary to map to , and back each time ContentValues Cursor, Useful Links: https://developer.android.com/reference/android/database/sqlite/SQLiteOpenHelper https://www.sqlite.org/index.html It doesn't handle errors, methods to change the database version, etc. in order to reduce the code. We will need an example with this table next. Room Now make the same table with the help of from Google, which is part of . In fact, is an , i.e. a shell with a more user-friendly interface. Room Android Jetpack Room ORM Adding a dependency on libraries: implementation 'androidx.room:room-runtime:2.1.0'
kapt 'androidx.room:room-compiler:2.1.0' Add a dependency to the module level file: kapt build.gradle apply plugin: 'kotlin-kapt' Create an , insert the code and run it as shown : Activity here package com.leonidivankin.draftsandroid.articles.db

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import androidx.room.*
import androidx.room.OnConflictStrategy.REPLACE

class RoomActivity : AppCompatActivity() {

    private val colorDao by lazy {
        Room
            .databaseBuilder(applicationContext, AppDatabase::class.java, "colors_room")
            .build()
            .colorDao()
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        Thread {
            val list = listOf(Color(1, "green"), Color(2, "red"), Color(3, "blue"))
            colorDao.insert(list)
            Log.d("DbExample", "${colorDao.get()}")
        }.start()
    }
}

@Database(entities = [Color::class], version = 1, exportSchema = false)
abstract class AppDatabase : RoomDatabase() {
    abstract fun colorDao(): ColorDao
}

@Entity(tableName = "colors")
data class Color(@PrimaryKey val id: Int, val color: String)

@Dao
interface ColorDao {
    @Query("SELECT * FROM colors") fun get(): List<Color>
    @Insert(onConflict = REPLACE) fun insert(color: List<Color>)
} We created the base. colors_room Here we also reached our goal rather quickly, as confirmed by the log: D: [Color(id=1, color=green), Color(id=2, color=red), Color(id=3, color=blue)] Pros and cons +simplifies the creation of complex queries +can give objects to , , RxJava LiveData Flow +works with objects, not strings +can give a list of objects at once +it has automigrations -like any library it makes the project heavier Useful Links: https://developer.android.com/jetpack/androidx/releases/room We achieved the initially set task in 30-40 lines. As you know, is currently the most popular library for working with databases on Android due to its simplicity and speed. Room Other ORMs In fact, the library is an . Its main task is to simplify the work with the database. On , there were previously popular other ORMs for working with databases, such as , , , and others. Room ORM SQLite Android ORMLite SugarORM Freezer There are more than a dozen of them. They lost their popularity after the release of , especially considering the fact that Room is faster than other , as evidenced by benchmarks like . Room ORMs this one This concludes our discussion of database libraries. Next we'll take a look at the inspection tools. Database Inspection Device File Explorer + SQLite Studio The entire database is stored on Android in , in one or more files. There is no need to raise additional servers or connections to work with it. Therefore, the easiest way to see what is in the resulting file is to download it to your computer (it's free) and open it in editor. That's what we'll do. SQLite Internal Storage SQLite Studio Go to the following path: and find the previously created databases and : Device File Explorer > Data > Data > your_package_name > databases colors_db colors_room Select these files and save them to your computer: Next, download and install it. SQLite Studio https://sqlitestudio.pl/ Open and find our file, as shown in the figure below: SQLite Studio As a result, the databases should appear in the window on the left. Double-click to open the desired database and table, and it should appear in the window on the right: In addition to viewing the database, you can also change the data and upload it back to your mobile device. That's what we'll do. Let's change the color to and save it as an example: green purple Then go back to and upload the new file by clicking the button: Device File Explorer Upload Sometimes you need to restart the application in order for the data to be updated. Go to , comment out some of the code to write and restart the application: RoomActivity //val list = listOf(Color(1, "green"), Color(2, "red"), Color(3, "blue"))
//colorDao.insert(list) See : LogCat D: [Color(id=1, color=purple), Color(id=2, color=red), Color(id=3, color=blue)] We see that the color value of the first object has changed to . This gives you a great toolkit for managing the base during development, debugging and error correction. Color purple Pros and cons +you can record data -you have to download and upload the database every time Useful Links: https://www.sqlite.org/index.html We have analyzed one of the easiest and most reliable ways to inspect the database. Let's look at a few more. Android Studio Database Inspector The method shown in the example above has long been the main way to view the database using the GUI. However, introduced the . Android Studio 4.1 Database Inspector To use it, you need to: go to the tab; App Inspection select the process of your application (in my case it is ); com.leonidivankin.draftandroid find your database (in my case it is ); colors_room find the necessary table (in my case it is ). colors As you can see, the data is the same. In this tool it is also possible to edit the value. Click twice on the line and enter the desired value, for example, I will enter : rose Restart the application and look at : LogCat D: [Color(id=1, color=rose), Color(id=2, color=red), Color(id=3, color=blue)] As you can see, the value in the logs changed to . rose I want to note that in the tool worked rather crookedly: it was not always possible to connect to the necessary process, sometimes the connection to the database was unexpectedly lost, but the quality and functions are constantly improving. Android Studio 4.1 In works much better, although some of the problems remain. Android Studio Chipmunk 2021.2.1 Database Inspector Pros and cons +no need to copy the base and fill it back in -raw tool We saw how to view the database without leaving . Next, let's see how to do it via . SQLite Android Studio ADB Adb+sqlite Sometimes the GUI functions are not enough, for example, if you want to create a new empty database. Or if you want to write a script with a sequence of actions for testing. tools will help. Adb+sqlite To use it, run the application on an emulator (!) and enter the following lines: adb shell
su
cd data/data/com.leonidivankin.draftsandroid/databases
sqlite3 colors_room
SELECT * FROM colors; Where, - the name of my package, , - the name of the base and table from the examples above. com.leonidivankin.draftsandroid colors_room colors We see in the console that the contents of the table are displayed, as in the previous examples: A few observations: It is necessary to run the application on an emulator, otherwise, there will be an error or , because you need to root the phone; Permission denied su: not found It is obligatory to put a semicolon ";" after otherwise, it may cause an error or the query will not be executed. SELECT * FROM colors; You can also view a list of all databases. To do this, you must enter: ls -R /data/data/com.leonidivankin.draftsandroid/databases As a result, we have all the files contained in the folder: databases Pros and cons +A very wide range of commands are available compared to graphical commands +it is possible to write a script for automation or self-testing -You have to enter commands via the console -Need a rooted phone or emulator Useful Links: https://developer.android.com/studio/command-line/adb Despite the fact that tools do not have a graphical interface, it deserves attention, because it is more flexible and provides more and more opportunities for automation of development or testing, for example, to correctly handle migrations. Adb+sqlite Conclusion Working with SQLite databases that contain dozens of tables with thousands of rows is a non-trivial task. Very often, finding an error requires all the possible arsenal that is only available on . The tools presented above will help you solve these problems. Android has been using the database since its inception. And even though some other tools change every year, has remained one of the main repositories for the second decade. And, by all accounts, it will stay that way. Android SQLite SQLite That's why the advice we offer here will never lose its relevance. If you use any tools not mentioned in this article, please do share them in the comments. Also, read about networking tools for android development . here

Best Android Tools to Work With Databases

16 Most Influential Women in The NFT Movement

The Dirty Code Problem: Improve Your Game with Good Naming Practices

This tutorial is the fifth part of our React Native Travel Article App UI clone series. In the , we successfully implemented the Recommendation Section on our List Screen. This tutorial is the continuation of the same tutorial from where we left off in the last part. So, it is recommended to go through the previous parts in order to get the knowledge and insight into the overall project. previous part The motivation for this tutorial series came from the React Native App Templates that consists of a wide variety of beautiful templates written in React Native and powered by universal features and design. The templates enable us to implement our own apps and even help us get started with our own startups. And, this fifth part is also the continuation of the same coding implementations and designs from the Youtube video tutorial by for the Travel Article App UI clone. The video tutorial delivers the overall tutorial using fast coding which may be difficult to grasp for any developer especially the beginners. Hence, this article tutorial provides a step by step implementation which will be easier to understand and implement. So, the learners can relax and take their time to implement the UI. React UI Kit Overview In this fifth part of this tutorial series, we are going to implement the Animated Delimeter dots of the Destinations section. The idea is to make the delimiter dots active in the animated fashion while scrolling the Destination section cards.  After we complete this, we are going to store our color and size style properties in a different file. Then, we are going to use the style properties from that file to style the components in our List Screen. This will make our code clean and organized for better understanding. So, let us begin!! Making Some Configuration in FlatList of Destinations section Here, we are going to add an additional prop to the FlatList component of the Destinations section. The prop we are going to add is decelerationRate. This decelerationRate prop is a floating-point number that determines how quickly the scroll view decelerates after the user lifts their finger. Now, we are going to add this prop to our FlatList component as shown in the code snippet below: <View style={[ styles.flex, styles.column, styles.destinations]}> `${item.id}`}
                renderItem = {({item}) => this.renderDestination(item)}
              />
              {this.renderDots()} < = = = = // = ' ' }} // = = )=> FlatList horizontal pagingEnabled scrollEnabled showsHorizontalScrollIndicator {false} scrollEventThrottle {16} snapToAlignment "center" decelerationRate {0} style {{ overflow : visible In IOS platform data {destinations} keyExtractor {(item, index </ > View Adding Animation to Delimiter Dots In this step, we are going to add the Animation to our Delimiter Dots in our Destinations section. For that, we need to import the Animated component from the react-native package as shown in the code snippet below: { 
  StyleSheet, 
  Platform, 
  Text, 
  View, 
  ScrollView,
  Dimensions, 
  ImageBackground, 
  Image, 
  FlatList, 
  TouchableOpacity, 
  Animated
} ; import from 'react-native' Now, we need to define a variable called that is initialized to Animated value. This variable will store our animation value for horizontal animation. In order to do this, we need to use the code from the following code snippet: scrollX {

    scrollX = Animated.Value( ); export default . class List extends React Component new 0 Here, the Animated.Value configuration enables us to bind to style properties or other props and can be interpolated as well. Now, we need to configure this value into the event of the component of function as shown in the code snippet below: scrollX onScroll FlatList renderDestinations() <FlatList 
                horizontal
                pagingEnabled
                scrollEnabled
                showsHorizontalScrollIndicator = { }
                scrollEventThrottle = { }
                snapToAlignment = decelerationRate={ } onScroll={Animated.event([{ : { : { : .scrollX }} }])}
                data = {destinations}
                keyExtractor = {(item, index)=> }
                renderItem = {({item}) => .renderDestination(item)}
              /> false 16 "center" 0 // style={{ overflow : 'visible' }} //In IOS platform nativeEvent contentOffset x this ` ` ${item.id} this Here, we have used the event function of the Animated component which takes the as a parameter. Then, we have defined the value according to the variable inside the nativeEvent config. nativeEvent contentOffset scrollX Configuring Animation in Delimiter dots in accordance with the scrolling FlatList Here, we are going to add animation to the Delimiter dots which will depend on the event of the . For that, we need to first initialize the dot position using the divide function of the component. The divide function creates a new Animated value composed by dividing the first Animated value by the second Animated value. And, its use is shown in the code snippet below: onScroll FlatList Animated dotPosition = Animated.divide( .scrollX, width); const this Now, we are going to make some configuration in the function in order to animation properties to the dots. For that, we need to use the code from the code snippet below: renderDots() Delimiter renderDots() { dotPosition = Animated.divide( .scrollX, width); ( <Animated.View
              key={`step-${item.id}`}
              style={[styles.dots, styles.activeDot, { borderWidth: borderWidth } ]}
            />
          )
        })}

      </View> const this return {destinations.map((item, index) => {
          const borderWidth = dotPosition.interpolate({
            inputRange: [index -1, index, index + 1],
            outputRange: [0, 2.5, 0],
            extrapolate: 'clamp'
          });
          return ( < = , ,
        { ' ', ' ', }
      ]}> View style {[ styles.flex styles.row justifyContent: center alignItems: center marginTop: 10 )
  } Here, we have defined a constant called which is initialized to the function of the constant initlized to Animated.divide. The function takes , and extrapolate as parameter values. borderWidth interpolate() dotPosition interpolate() inputRange outputRange The function permits input ranges to map to different output ranges. Then, we have also added component to our component with style property. interpolate() Animated View borderWidth Hence, we will get the following result in our emulator screen: As we can see, we have successfully added beautiful animation to the Delimiter dots as we scroll the Destination section card in the Destination section. The animation is very smooth and works well with the scrolling transition. Configuring Style properties Here, we are going to configure the style properties from a separate file. Then, we will style our List Screen components according to the style properties in that file. Storing Style Properties in Different File In this step, we are going to store our size and color properties used very commonly on the List screen to a different file called . This will make things easier for us to assign styles to different components. Now, we need to create a file called in our main project folder as shown in the code snippet below: ‘theme.js’ ‘theme.js’ As we can see, we have got the file. Now, in the theme.js file we need to define our colors and sizes properties as shown in the code snippet below: ‘theme.js’ colors = { : , : , : , : , : ,
  }; sizes = { : , : , : , : , : , : ,
  }; {
    colors,
    sizes,
  }; const black '#000' white '#FFF' gray '#DCE0E9' caption '#BCCCD4' active '#007BFA' const base 16 font 14 padding 36 margin 36 title 24 radius 12 export Here, we have defined the color and size style properties in the colors and sizes constant variables that are then exported. Integrating Color and Size style properties based on theme.js file Since we have defined some common style properties in the theme.js file, here we are going to import the styles from file and integrate them into our component inline styles as well as the styles in the component. But first, we need to import the file into our file as shown in the code snippet below: theme.js StyleSheet theme.js List.js * theme ; import as from '../theme' Now, we are going to change the color and size style properties in accordance with the pre-defined styles from the theme.js file. Changing color style properties in accordance with theme.js Here, we are going to change the color style properties in the file with the colors variable from the theme.js file. All the changes made to the style properties in the component is provided in the code snippet below: List.js StyleSheet header: { : theme.colors.white, : , : , : , : , : ,
    }, : { : , : , : , : , : , left : , : , : theme.colors.white,
    }, : { : (width - ( * )) / , : , : theme.colors.white, : , : , : * ,
    }, : { : * , : theme.colors.white
    }, : { : , : theme.colors.white, : }, : { : theme.colors.black, : { : , : ,
      }, : , : , : ,
    }, : { : , : , : , : , : , : theme.colors.gray, : ,
    }, : { : , : , : , : theme.colors.active,
    } backgroundColor paddingHorizontal 36 paddingTop 48 paddingBottom 24 justifyContent 'space-between' alignItems 'center' destinationInfo position 'absolute' borderRadius 12 paddingHorizontal 36 paddingVertical 16 bottom 20 //In iOS platform, bottom : -36 36 right 36 backgroundColor recommendation width 36 2 2 marginHorizontal 8 backgroundColor overflow 'hidden' borderRadius 12 marginVertical 36 0.5 recommendationTemp fontSize 14 1.25 color rating fontSize 28 color fontWeight 'bold' shadow shadowColor shadowOffset width 0 height 6 shadowOpacity 0.05 shadowRadius 10 elevation 5 dots width 10 height 10 borderWidth 2.5 borderRadius 5 marginHorizontal 6 backgroundColor borderColor 'transparent' activeDot width 12.5 height 12.5 borderRadius 6.25 borderColor Now, we have some inline styles as well bound to the components in the different templating methods. We need to change them in accordance with colors variable as well. All overall code with changes is provided in the code snippets below: In the header config of the object: navigationOptions <Text style={{ : theme.colors.caption}}>Search place< color for /Text> For the function: renderDestination() renderDestination(item){ ( <View style={[styles.row, {justifyContent: 'space-between'}]}>
            <View style={{flex : 0}}>
              <Image source={{uri: item.user.avatar}} style={styles.avatar}/>
            </View>
            <View style={[styles.column, {flex : 2, paddingHorizontal : 18}]}>
              <Text style={{color : theme.colors.white, fontWeight : 'bold'}}>{item.user.name}</Text>
              <Text style={{color : theme.colors.white}}>{item.location}</Text>
            </View>
            <View style={{flex : 0, justifyContent : 'center', alignItems : 'flex-end'}}>
              <Text style={styles.rating}>{item.rating}</Text>
            </View>
          </View>
          <View style={[styles.column, styles.destinationInfo, styles.shadow]}>
            <Text style={{ fontSize: 24, fontWeight: '500', paddingBottom: 8, }}>
              {item.title}
            </Text>
            <View style={[ styles.row, { justifyContent: 'space-between', alignItems: 'flex-end'}]}>
              <Text style={{ color : theme.colors.caption}}>
                {item.description.split('').slice(0, 50)}...
              </Text>
            </View>
          </View>

        </ImageBackground> return < = , ]} = }} = }}
        > ImageBackground style {[styles.flex, styles.destination styles.shadow imageStyle {{borderRadius : 12 source {{uri : item.preview )
    } In the function renderRecommended() <TouchableOpacity activeOpacity={ }> < 0.5 More < = }}> Text style {{ color: theme.colors.caption </ > Text /TouchableOpacity> For the function: renderRecommendations() <View style={[styles.flex, styles.column, styles.shadow, { : , : / }]}> <Text style={{ : theme.colors.caption}}>{item.location}< Text> < justifyContent 'space-evenly' padding 36 2 {item.title} < = * , ' ', / , }}> Text style {{ fontSize: 16 1.25 fontWeight: 500 paddingBottom: 36 4.5 </ > Text color /Text>
              <View style={[
                styles.row,
                { alignItems: 'center', justifyContent: 'space-between', marginTop: 36 }
              ]}>
                <Text style={{ color: theme.colors.active }}>{item.rating}</ </ > View /View> Changing size properties in accordance with theme.js Here, we are going to change the size style properties in the file with the sizes variable from the theme.js file. All the changes made to the style properties in the component is provided in the code snippet below: List.js StyleSheet header: { : theme.colors.white, : theme.sizes.padding, : theme.sizes.padding * , : theme.sizes.padding * , : , : ,
    }, : { : , : , : ,
    }, : { : width - (theme.sizes.padding * ), : width * , : theme.sizes.margin, : theme.sizes.padding, : , : theme.sizes.radius
    }, : { : , : theme.sizes.radius, : theme.sizes.padding, : , : , left : theme.sizes.padding, : theme.sizes.padding, : theme.colors.white,
    }, : { : , : , : theme.sizes.padding,
    }, : { : (width - (theme.sizes.padding * )) / , : , : theme.colors.white, : , : theme.sizes.radius, : theme.sizes.margin * ,
    }, : { : , : theme.sizes.radius, : theme.sizes.radius,
    }, : { : , : , : theme.sizes.padding / , : , : , : , : ,
    }, : { : * , : theme.colors.white
    }, : { : (width - (theme.sizes.padding* )) / , : (width - (theme.sizes.padding * )) / ,
    }, :{ : theme.sizes.padding, : theme.sizes.padding, : theme.sizes.padding / }, : { : theme.sizes.font * , : theme.colors.white, : }, backgroundColor paddingHorizontal paddingTop 1.33 paddingBottom 0.66 justifyContent 'space-between' alignItems 'center' destinations flex 2 justifyContent 'space-between' paddingBottom 30 destination width 2 height 0.66 marginHorizontal paddingHorizontal paddingVertical 20 borderRadius destinationInfo position 'absolute' borderRadius paddingHorizontal paddingVertical 16 bottom 20 //In iOS platform, bottom : -36 right backgroundColor recommendedHeader justifyContent 'space-between' alignItems 'flex-end' paddingHorizontal recommendation width 2 2 marginHorizontal 8 backgroundColor overflow 'hidden' borderRadius marginVertical 0.5 recommendationHeader overflow 'hidden' borderTopRightRadius borderTopLeftRadius recommendationOptions alignItems 'center' justifyContent 'space-between' padding 2 position 'absolute' top 0 left 0 right 0 recommendationTemp fontSize 14 1.25 color recommendationImage width 2 2 height 2 2 avatar width height borderRadius 2 rating fontSize 2 color fontWeight 'bold' Now, we have some inline styles as well bound to the components in the different templating methods. We need to change them in accordance with sizes variable as well. All overall code with changes is provided in the code snippets below: In the header config of the object: navigationOptions <Text style={{ : theme.sizes.font * }}>Destination< fontSize 2 /Text> For the function: renderDots() <View 
          style={[ 
                  styles.flex, 
                  styles.row, 
                  { : , : , : Platform.OS === ? theme.sizes.padding * : }
                ]}
         > 
          ................. justifyContent 'center' alignItems 'center' marginTop 'ios' 2 48 In the function: renderDestinations() <ImageBackground
          style={[styles.flex, styles.destination, styles.shadow]}
          imageStyle = {{ : theme.sizes.radius}}
          source= {{ : item.preview}}
        > <View style={{flex : 0}}>
              <Image source={{uri: item.user.avatar}} style={styles.avatar}/>
            </View>
            <View style={[styles.column, {flex : 2, paddingHorizontal : theme.sizes.padding / 2}]}>
              <Text style={{color : theme.colors.white, fontWeight : 'bold'}}>{item.user.name}</Text>
              <Text style={{color : theme.colors.white}}>{item.location}</Text>
            </View>
            <View style={{flex : 0, justifyContent : 'center', alignItems : 'flex-end'}}>
              <Text style={styles.rating}>{item.rating}</Text>
            </View>
          </View> <View style={[styles.column, styles.destinationInfo, styles.shadow]}>
            <Text style={{ fontSize: theme.sizes.title, fontWeight: '500', paddingBottom: 8, }}>
              {item.title}
            </Text>
            <View style={[ styles.row, { justifyContent: 'space-between', alignItems: 'flex-end'}]}>
              <Text style={{ color : theme.colors.caption}}>
                {item.description.split('').slice(0, 50)}...
              </Text>
            </View>
          </View> borderRadius uri < = { ' '}]}> View style {[styles.row, justifyContent: space-between </ > ImageBackground For function: renderRecommended() <Text style={{ : theme.sizes.font * }}>Recommended< fontSize 1.4 /Text> In function renderRecommendation() <View 
            style={[styles.flex, styles.column, styles.recommendation, styles.shadow,
                    index === ? { : theme.sizes.margin } : ,
                    isLastItem ? { : theme.sizes.margin / } : ,
                   ]}
           > <Image style={[styles.recommendationImage]} source={{ uri: item.preview }} />
              <View style={[ styles.flex, styles.row, styles.recommendationOptions ]}>
                <Text style={styles.recommendationTemp}>
                  {item.temperature}℃
                </Text>
              </View>
            </View> <View style={[styles.flex, styles.column, styles.shadow, { justifyContent: 'space-evenly', padding: theme.sizes.padding / 2 }]}>
              <Text style={{ fontSize: theme.sizes.font * 1.25, fontWeight: '500', paddingBottom: theme.sizes.padding / 4.5, }}>{item.title}</Text>
              <Text style={{ color: theme.colors.caption}}>{item.location}</Text>
              <View style={[
                styles.row,
                { alignItems: 'center', justifyContent: 'space-between', marginTop: theme.sizes.margin }
              ]}>
                <Text style={{ color: theme.colors.active }}>{item.rating}</Text>
              </View>
            </View> 0 marginLeft null marginRight 2 null < = ]}> View style {[styles.flex, styles.recommendationHeader </ > View Hence, after everything is organized, we will get the same result as before which is shown in the following emulator simulation: As we can see, the result is the same as before with all the codes organized. Now, we will be able to configure style properties easily in the upcoming parts of this tutorial series. With this, we have come to the end of this part of the tutorial series. Finally, we have successfully implemented the Animated Delimiter dots in the section of our screen. Destinations List Conclusion This tutorial is the fifth part of the React Native Travel Article App UI clone tutorial series. In this part, we continued from where we left off in the fourth part of this tutorial series. In this part of the tutorial, we got stepwise guidance on how to add beautiful active style animation to the of the section. Hence, we made the active animation of in accordance with the scrolling of the section cards. Then, we also organized our inline styles and styles in the component to make code standard and clear. Hence, we can now style our components more easily in the upcoming parts of this tutorial series. Delimiter dots Destinations Delimeter dots Destination StyleSheet In the next part of this tutorial series, we are going to add the icons to our List screen as well as the rating stars to our Recommendation Info cards.

React Native Travel Article App UI Clone #5 : Animated Delimiter Dots

When it comes to performance these days, it’s not uncommon to hear the term “JAMstack”. JAMstack stands for JavaScript, APIs, and Markup. The idea being to create static markup with JavaScript that is powered by communicating with APIs. The reason this stack has become so popular is because it allows websites or apps to be bundled up and served at “the edge” via a CDN. Couple this with what is ideally a performant app that is talking to performant APIs and you get a speedy user experience. is a great solution for creating markup with JavaScript, but what about the APIs part and serving your site to the world? Well really, that’s up to you, but in this post I’ll walk through how you can: GatsbyJS Use and to set up authentication AWS Amplify AWS Cognito Use to create powerful APIs that will let you do all sorts of amazing things with your apps AWS AppSync How to use to build and deploy your app, making it available to the world using AWS’s global CDN, . AWS Amplify Console Amazon CloudFront A quick primer on Amplify and AppSync lets you create sophisticated serverless backends fast. The CLI includes support for authentication, analytics, functions, REST/GraphQL APIs, and . It uses AWS CloudFormation and enables you to add, modify, and share configurations. Amplify much more is a continuous deployment and hosting service for mobile web applications. The AWS Amplify Console makes it easier for you to rapidly release new features, helps you avoid downtime during application deployment, and handles the complexity of simultaneously updating the frontend and backend of your applications. Amplify Console makes it easy to build data driven mobile and web applications by handling securely all the application data management tasks like online and offline data access, data synchronization, and data manipulation across multiple data sources. AWS AppSync uses GraphQL, an API query language designed to build client applications by providing an intuitive and flexible syntax for describing their data requirement. AppSync Gatsby for dynamic apps Because Gatsby generates static files when possible, it’s often categorized as a static site generation tool, but it’s really so much more than that. Because it’s built on top of React, once your app renders it behaves just like any other React app. That means it’s possible to do things like infinite lists, real-time updates, and create auth walls. It’s not uncommon to add completely client side rendered sections of a site, things like dashboards or admin portals are all possible. This means you can statically generate anything that doesn’t depend on any dynamic content like user information or private data, but still provide an entire app experience. This post will walk you through creating a blog that allows people to “like” a post. Users not signed in won’t be able to like posts, but will still be able to see them. The blog posts will still be statically generated, allowing for faster delivery and proper SEO support, but users will still be able to dynamically “like” posts. We’ll use AppSync to store the likes and Amplify to set up authentication and create the AppSync API. Example of dynamic blog Setting up the Gatsby blog The first thing that needs to be done is making sure you have the package installed so that you can create a new Gatsby project. gatsby-cli npm i -g gatsby-cli # OR yarn global add gatsby-cli Now you can create a project. This example will use the . “starter blog” starter npx gatsby new blog gatsbyjs/gatsby-starter-blog You can view all available starters . here Next you need to set up the client-side app where users can sign in and see what posts they have liked. To create client-side only routes you first need to update with the following snippet (for more on client-side only routes, head ): gatsby-node.js here This tells Gatsby that these routes should only be rendered on the client. While you don’t necessarily need this functionality in this example, if your dashboard had many routes this would prevent Gatsby from trying to render those pages, which would error since they don’t exist in the directory where Gatsby looks for pages to render. pages Next you need to add a page for the dashboard. In create a new file called and add the following: src/pages dashboard.js If you run and visit you should see something that looks like this: yarn start [http://localhost:8000/dashboard](http://localhost:8000/dasboard) Setting up Amplify Now that you have your blog set up to support a dashboard, you need to set up Amplify so that you can do things like adding authentication and creating an API. To do this you need to first install the Amplify CLI. npm i -g @aws-amplify/cli # OR yarn global add @aws-amplify/cli Once the CLI is installed you need to initialize Amplify in your Gatsby blog project. From the root of the project run . amplify init One of two things will happen when you run this command. If you have some AWS user profiles on your computer it will ask if you want to use a profile. (If you have a profile with administrative and programmatic privileges feel free to choose that.) If you don’t have any user profiles created already, or you’re unsure if a current profile will work, then the CLI will actually walk you through how to create one, even going so far as to open the AWS console for you and pre-populating any fields. (You basically just have to click a few buttons, easy peasy.) For a more in-depth walkthrough of creating a new user profile, check out this informative video from . Nader Dabit Now that Amplify is properly configured you can start setting up AWS services in your blog! Setting up authentication Amplify makes adding services like Cognito for authentication very simple and straight-forward. To set up authentication run the following: amplify add auth Once you run the command you will be asked if you want to use the default configuration to set up authentication for your app. This is the recommended auth settings for AWS. (Choose this option if you aren’t familiar with how to configure your own user pools and Cognito configuration.) Next you need to run so that the resources can be created and configured in AWS. amplify push After Amplify creates the remote resources for your authentication service, you need to set up Amplify in your blog. To do that you need to: Install the necessary dependences: npm i aws-amplify aws-amplify-react # OR

yarn add aws-amplify aws-amplify-react Next you need to import the configuration created by Amplify in and pass it to the Amplify client. In add the following: src/aws-exports.js gatsby-browser.js Then you can update the dashboard with the “ ” HOC. This component takes care of the entire sign up flow for you! It’s a really great component, but if you need something more specific you can always create your own sign in flow and use the module available in package. withAuthenticator [Auth](https://aws-amplify.github.io/docs/js/authentication) aws-amplify For an example of using the Auth module go . here Update with the following: src/pages/dashboard.js Once you restart Gatsby you should see the following when you visit : [http://localhost:8000/dashboard](http://localhost:8000/dashboard) withAuthenticator rendered by Gatsby The last thing we want to do is add a link to the dashboard from all other pages. We can add that to the component. Notice in the updated component we are now passing in a prop. We can use this in the component to determine if we should render the dashboard link or not. Update the return statement in with the following: Layout Dashboard isDashboard Layout src/components/Layout.js Now we have a link to the dashboard where users can sign in. Go ahead and go through the auth flow to ensure everything works. If you’re curious about what is happening behind the scenes you can view your new user pool . here Congratulations! Anyone visiting your blog can now sign in! 🎉 While this is exciting, they really can’t do much yet, so now let’s make it possible to like posts! Creating a GraphQL API via AppSync Before you can allow users to like posts, you need somewhere to store that information. The next step is to set up an API so you can use GraphQL to fetch and store data. If you’re unfamiliar… AppSync GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing data. GraphQL provides a complete and understandable description of the data in your API, gives clients the power to ask for exactly what they need and nothing more, makes it easier to evolve APIs over time, and enables powerful developer tools. — graphql.org To add an service to your blog run . You will be prompted with a few options: API amplify add api Use GraphQL Provide an API name (I used ) amplifygatsbyexample Choose “Cognito User Pool” for authentication (this will be automatically connected to the user pool we created in the auth steps). Choose no for having an annotated schema Choose yes to guided schema creation Choose “Single object with fields” for template type Choose yes to editing the schema now Now replace the type with the following: TODO If you look at the type, you will notice there are two directives being used on the type. The first one is , this tells AWS that this is a data type and as such, will create a table for this entity. The second one is , this directive allows us to set up granular authentication or access on our GraphQL API. Here we are specifying that only an owner can access their own PostLikes and the owner is determined by the value for that entity. Go for more about GraphQL transforms. PostLike model auth userId here Once that is done, hit enter in the terminal and then run again. You will have the option to have the necessary code generated to make queries and mutations, as well as subscriptions. I recommend letting Amplify create the code for you. amplify push You know have an API you can use it to store your likes! If you want to check out your API, you can do so ! here Putting it all together Now that you have your API set up, it’s time to add support for liking to your Gatsby blog. The first step is to add the ability to like a post. In order to be able to like a post you first need to add an field to the of each blog post. To do so, open the folder and add an property to each blog post (I used incrementing numbers like 1, 2, 3, etc). It should look something like this: id frontmatter content/blog id --- title: Hello World date: '2015-05-01T22:12:03.284Z' id: 1 --- The next step is to check for a logged in user and if one is found, then check to see if the logged in user has “liked” the post. With this information you can properly set up your mutations for either creating or deleting the like. State is used so that optimistic updates can be made to the UI while you wait for the mutation to process. Replace with the following: src/templates/blog-post.js Here we are using the module provided by , but there is a component that comes in as well. We’ll make use of that in the next section. API aws-amplify Connect aws-amplify-react One thing to note is that we don’t have to specify the property in our mutation input. The reason is because AppSync will use the user that is found on the associated identity making the request. You can learn more about that . userId here So now that visitors can like your posts it would be nice for them to see all the posts they have liked. Let’s update with the following: src/pages/dashboard.js Here you can see that the blog posts are now being pulled in via Gatsby and we use our AppSync data combined with the blog posts to render a list of liked posts! Go ahead and like a few posts and then visit the dashboard, you should see something like this: A list of liked posts rendered by Gatsby Sweet! Now that all the functionality is set up, the only thing left is to deploy this awesome likable blog! Deploying to Amplify Console The first step to getting this blog deployed via Amplify Console is to get it in source control. Create a new repository in your source control provider of choice (I use GitHub, but you can also use GitLab, BitBucket, or AWS Code Commit.) Once you have your blog pushed to your source control provider, the next step is to connect that repository to Amplify Console. This process is unbelievably simple. Go to the of AWS console and click the “Deploy” button. Amplify Console section Next choose your source control provider: Picking a source control provider in Amplify Console Then you can choose the repository and branch you wish to deploy: Selecting a repository and branch in Amplify Console Amplify Console will auto-detect that this is a Gatsby project so for the next step about build configuration, just press “Next”! Lastly, review your settings and hit “Save and Deploy”: Reviewing settings for the deployment in Amplify Console Amplify Console will build the backend infrastructure needed that you have specified in your Amplify config and then it will build and deploy your static site across CloudFront. Amplify Console supports branch deployments, which means you can create an environment for any branch. This makes things like testing, or creating staging environments very easy. It also allows you to set up basic auth for any deployment, making it possible to keep things private and only give access to those who need it. Your blog is now live and ready for the whole world to enjoy! Congratulations! 🎊 🎉 The code for this example can be found here , and the deployed blog can be found here . You can play with the code in CodeSandbox here: _A starter for a blog powered by Gatsby and Markdown_codesandbox.io gatsby-starter-blog - CodeSandbox If you enjoyed this post I highly recommend checking out some more of the amazing stuff you can do with Amplify and AppSync! You can find a bunch more awesome resources and . here here Also, if you want to stay up on the latest things I’m writing about or working on, give me a follow on ! Twitter

Building JAMstack Applications with Gatsby and AWS Amplify Framework

Stories, News & Mentions about ISLASH

Islash’s Stories on HackerNoon

Islash's News & Mentions