Kotlin has been one of the most talked about languages since its birth in 2011. Since then it has come a long way to ease out the development in Android. Kotlin almost replaced Java in Android Development, most of the apps nowadays are built in Kotlin. Since, in Kotlin you don’t need to write boilerplate code like you do in Java. Java is not going anywhere, but its not best fit for Android Apps, since Java was created when there was no idea of Smart Phones. As you know smart phones come up with limited resources. For more details like why Kotlin replacing Java, you can read here.

What is Kotlin Multiplatform Mobile (KMM)?

Kotlin Multiplatform Mobile is an SDK to build iOS And Android Apps.

It offers all the combined benefits of creating cross-platform and native apps.

Like Flutter and React Native, you can also use Kotlin to build your Android and iOS Applications. And also you can build your backend with the same language. There’s no need to introduce any new programming languages to your codebase to make your app cross-platform.

OKAY, Wait wait….. wait… Don’t directly jump into the development, since KMM is in BETA NOW, so you’ve to wait till we get the stable version.

So, Why Use Kotlin?

Kotlin is one of the most newly developed languages which helps you to write less code and do more. It saves your development time and also reduce the code review time. And its easy to find bugs in clean and smaller codebase.

Kotlin for server side

Unlike just Cross Platform Apps, you can also build your backend with Kotlin. Kotlin applications can be deployed into any host that supports Java Web applications, including Amazon Web Services, Google Cloud Platform, and more.

• Expressiveness: Kotlin’s innovative language features, such as its support for type-safe builders and delegated properties, help build powerful and easy-to-use abstractions.
• Scalability: Kotlin’s support for coroutines helps build server-side applications that scale to massive numbers of clients with modest hardware requirements.
• Interoperability: Kotlin is fully compatible with all Java-based frameworks, so you can use your familiar technology stack while reaping the benefits of a more modern language.
• Migration: Kotlin supports gradual migration of large codebases from Java to Kotlin. You can start writing new code in Kotlin while keeping older parts of your system in Java.
• Tooling: In addition to great IDE support in general, Kotlin offers framework-specific tooling (for example, for Spring) in the plugin for IntelliJ IDEA Ultimate.
• Learning Curve: For a Java developer, getting started with Kotlin is very easy. The automated Java-to-Kotlin converter included in the Kotlin plugin helps with the first steps. Kotlin Koans can guide you through the key features of the language with a series of interactive exercises.

Case Studies

There are some really big companies like NETFLIX, VMWARE, PHILIPS and many more, which are already started using Kotlin for Mobile App Development to simplify their app development efforts.

If you want, you can read more case studies here and learn how Kotlin helped them to build successful products which is being used by millions.

First Cross Platform App With Kotlin: Android Studio

If you’re already an Android Developer then you don’t have to worry about how to set up environment to create your project and run an Android App. To run the iOS App, you have to install the XCode on your MAC Machine.

If you completely new to Kotlin and you don’t know to install Android Studio on your machine, then you can download the Android Studio from official website here and in order to create your cross platform project in Android Studio, you can follow this.

You can also watch this video for KMM quick start guide.

I hope you liked reading this article, you can also visit my website where I keep posting article regularly. keep learning and keep growing.

Android & iOS + Backend Apps With Kotlin Only was originally published in The Code Monster on Medium, where people are continuing the conversation by highlighting and responding to this story.

Whether you are a newbie in ML space or have years of experience, you must have observed that whenever you search for Overfitting on the web you’ll see either of the following one-liners:

Overfitting refers to a model that models the training data too well.

or

Overfitting models have high variance and low bias.

These definitions suffice if one’s goal is just to prepare for the exam or clear the interview. But if you are like me, who wants to understand things from basics, these surface-level explanations will not be enough.

Why High Variance Low Bias Model is Overfitting and where does model complexity come into the picture? How does “Model Paying Too much attention to training data” translates to high variance and thus into overfitting?

I needed more explanation. Hence, I dug deep so now you don’t have to! Here’s my take on the relation between Overfitting-Underfitting & Bias-Variance.

Bias & Variance:

In any ML Model, when we make predictions the model will always have some amount of error. We call it Prediction Error.

Note: While the first two errors i.e. Bias & Variance are controllable, we have no control over the Error due to noise.

Let’s say you have a ML model and you run it on the training dataset. Now if you take the average of the residuals (difference of prediction & true value) & subtract it from the average of true values, you’ll get Bias. Thus Bias is an indicator of how far off the model predictions as a whole are from the true values.

Now let’s say you took 5 datasets that are different from each other & trained a single ML model on each of them. For each dataset, you took the difference between the randomly selected prediction & the average of all the predictions. Observe how this difference changes for different datasets. This is the Variance.

Thus, we can see from these 2 definitions that, Bias tells on average, how accurate our model is in terms of making correct predictions while Variance tells how consistent our model is.

For any ML model, our goal is to create a model that is consistent & has high accuracy i.e. low Bias & low Variance.

Bias-Variance & Model Complexity:

The high Bias Model has high inaccuracy in terms of predictions. This means that the model fails to capture patterns & relationships in data. This happens because the model cannot learn from data well. Thus the model is not complex enough.

High Variance Model has low consistency in terms of its predictions. This means that its predictions vary drastically with a change in the dataset which in turn is an indicator that the model fails to generalize well. This happens when the model captures the underlying pattern as well as noise in data. This is the sign of the model being high in complexity.

Underfitting-Overfitting:

Because High Bias models are not complex enough, they fail to capture the underlying patterns in data and thus result in high training & test error which is a sign of Underfitting. Thus it is evident that Underfitting is the result of a Model that is not complex enough i.e. High in Bias.

Conversely, a model with High Variance is high in complexity. Thus while learning the underlying patterns in data, it also learns outliers & noise. Therefore, it gives high accuracy on the familiar dataset i.e. training data. But when a slightly different dataset i.e. test data is presented to this model, its prediction varies considerably which results in poor accuracy. This is a sign of Overfitting. So, it’s observed that Overfitting is the result of a Model that is high in complexity i.e. High in Variance.

Bias-Variance Tradeoff:

As mentioned before, our goal is to have a model that is low in Bias & low in Variance. To avoid High Bias, we will need to increase the complexity of our model & similarly, to avoid High Variance, we will need to decrease the complexity of our model.

To achieve a low bias-low variance model, we need to create a model that will have low complexity & high complexity simultaneously which is impossible! This is known as Bias-Variance Tradeoff. Hence, you will observe that a Model that is Underfitting i.e. High in Bias is always low in Variance & vice versa.

There you have it! This is my understanding of how Bias-Variance, Model Complexity & Underfitting-Overfitting are interconnected. I hope you guys found it helpful.

If you have any queries or find any mistakes in concepts please feel free to write in the comments. Thank you!

“How Bias-Variance, Model Complexity & Underfitting-Overfitting are related?” was originally published in The Code Monster on Medium, where people are continuing the conversation by highlighting and responding to this story.

Prologue

What should be the right way of Using Third-party API Keys in Android?

Since you have been developing android applications for some time, you might have realized the benefits of Source Code Management System like Git. When you work solely it helps, when you work within a team it helps.

So you may have thought about this question in the past.

To start our topic of discussion in detail, I would first like to add a quote by an eminent personality bill gates

It’s fine to celebrate success but it is more important to heed the lessons of failure

Good developers even good human beings keep on improving them, their ways of working, most important their perception and outlook. Our failures in life teach us more than our success in life. Experienced developers know this.

Let’s come back to our initial discussion.

Why we are emphasizing, on third-party APIs. Its because most of third party APIs like Google Maps are easy to integrate and seem free when their usage is quite low. Whenever usage of APIs increases above a particular threshold, the company which has developed APIs starts charging. (And someday my very popular idea/application will kill me if I am not careful about APIs operational cost)

Imagination

Imagine a scenario, that you have developed an open-source application or library, which can add cool functionality in the application and other developers can use it for free in their code. But since you didn’t take steps to secure your API key properly and checked in it into the public source code repository like GitHub.

The Havoc

And nightmare comes up, a lot of other developers those are using your public library, making calls to Third-party API using your API Key. and soon the third party will start charging your credit card since you have added that credit card to the third-party billing account.

The rescue

I am taking an example of the Android App here. See the below kotlin file

/*
 * Copyright (c) 2019. Relsell Global
 */

package `in`.relsellglobal.firebasedatabasedemo

import `in`.relsellglobal.firebasedatabasedemo.pojo.CityContent
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import java.util.*

/**
 * A fragment representing a list of Items.
 * Activities containing this fragment MUST implement the
 * [FrontListFragment.OnListFragmentInteractionListener] interface.
 */
class FrontListFragment : Fragment() {

    // TODO: Customize parameters
    private var columnCount = 1

    private var recyclerView:RecyclerView? = null

    private var myItemRecyclerViewAdapter : MyItemRecyclerViewAdapter? = null

    val cityContentList: MutableList<CityContent> = ArrayList()

    val APPID = "<OPEN WEATHER API KEY>"

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        arguments?.let {
            columnCount = it.getInt(ARG_COLUMN_COUNT)
        }
    }

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        val view = inflater.inflate(R.layout.fragment_item_list, container, false)
        recyclerView = view.findViewById(R.id.list);
        // Set the adapter

        return view
    }

    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)

        var city = CityContent()
        city.cityName = "dehradun"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID

        cityContentList.add(city);

        city = CityContent()
        city.cityName = "new delhi"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "hyderabad"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "chennai"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "mumbai"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "mangalore"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "dispur"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "indore"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);
        recyclerView!!.layoutManager = LinearLayoutManager(activity);
        myItemRecyclerViewAdapter = MyItemRecyclerViewAdapter(cityContentList,activity)
        recyclerView!!.adapter = myItemRecyclerViewAdapter

    }

    override fun onDetach() {
        super.onDetach()
    }

    companion object {

        // TODO: Customize parameter argument names
        const val ARG_COLUMN_COUNT = "column-count"

        // TODO: Customize parameter initialization
        @JvmStatic
        fun newInstance(columnCount: Int) =
            FrontListFragment().apply {
                arguments = Bundle().apply {
                    putInt(ARG_COLUMN_COUNT, columnCount)
                }
            }
    }
}

More specifically see the line

val APPID = <Open weather api key>

now open local.properties file and add your third party API key there. This file is already added into .gitignore file and doesn’t go to remote git repository whenever a commit/push is made.

openweather_data_api_key=<key value>

Besides above you want to access your API inside your kotlin files. But before doing that you need to create buildConfigField in your app level build.gradle file.

defaultConfig {
        .....
        buildConfigField "String", "OPENWEATHERDATA_API_KEY", "\""+localProperties['openweather_data_api_key']+"\""
       ....
    }

To access buildConfigField inside your kotlin file, you use property from the autogenerated BuildConfig.java file.

So your kotlin file snippet will become

val APPID = BuildConfig.OPENWEATHERDATA_API_KEY

Now, you can safely commit /push your file changes into a remote git repository without worry about API keys being published.

Conclusion

Congrats you have come up to this and investing time in growing yourself.

Remember friend nothing in this world is free. 🙂 Now you know the right way of Using Third-Party API Keys in Android

Thanks for reading. Feel free to check out my other blogs my team, on Android development topics.

Happy coding.

As a sidenote: Article was originally published at Relsell Global at Link

The right way of Using Third-Party API Keys in Android was originally published in The Code Monster on Medium, where people are continuing the conversation by highlighting and responding to this story.

Prologue

This is first tutorial in EASY Android Programming: MVVM series.

Eminent Mr. Woody Guthrie has said it right

Any fool can make something complicated. It takes a genius to make it simple.

So how all this is connected?

Most of the experienced or intermediate software developers know that its the quality of the application that makes it saleable. Users like that app which doesn’t crash and do the desired work in lesser no of steps.

UI Experience designers put a lot of midnight oil to come up with eye-catching UI, yet, easy to navigate. The UI may allow a user to perform a task with a lesser no of steps.

Hardworking developers put a lot of effort to develop an application that confirms UX design by using required design patterns in coding.

Process

In this article, I will make an android application as a metaphor but the rules are similar for any type of software development. To make things clearer, I would start with MVVM in Android development.

Before proceeding further, I would expect you know Git (SCM), if not please study one of the earlier articles this and this.

Checkout the weatherdata branch for the repository link . if you see code structure

In continuation of the above, there are a bunch of kotlin files in firebasedatabasedemo package. Lets open FrontListFragment.kt file you will find below code.

/*
 * Copyright (c) 2019. Relsell Global
 */

package `in`.relsellglobal.firebasedatabasedemo

import `in`.relsellglobal.firebasedatabasedemo.pojo.CityContent
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import java.util.*

/**
 * A fragment representing a list of Items.
 * Activities containing this fragment MUST implement the
 * [FrontListFragment.OnListFragmentInteractionListener] interface.
 */
class FrontListFragment : Fragment() {

    // TODO: Customize parameters
    private var columnCount = 1

    private var recyclerView:RecyclerView? = null

    private var myItemRecyclerViewAdapter : MyItemRecyclerViewAdapter? = null

    val cityContentList: MutableList<CityContent> = ArrayList()

    val APPID = BuildConfig.OPENWEATHERDATA_API_KEY

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        arguments?.let {
            columnCount = it.getInt(ARG_COLUMN_COUNT)
        }
    }

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        val view = inflater.inflate(R.layout.fragment_item_list, container, false)
        recyclerView = view.findViewById(R.id.list);
        // Set the adapter

        return view
    }

    override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)

        var city = CityContent()
        city.cityName = "dehradun"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID

        cityContentList.add(city);

        city = CityContent()
        city.cityName = "new delhi"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "hyderabad"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "chennai"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "mumbai"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "mangalore"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "dispur"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);

        city = CityContent()
        city.cityName = "indore"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        cityContentList.add(city);
        recyclerView!!.layoutManager = LinearLayoutManager(activity);
        myItemRecyclerViewAdapter = MyItemRecyclerViewAdapter(cityContentList,activity)
        recyclerView!!.adapter = myItemRecyclerViewAdapter

    }

    override fun onDetach() {
        super.onDetach()
    }

    /**
     * This interface must be implemented by activities that contain this
     * fragment to allow an interaction in this fragment to be communicated
     * to the activity and potentially other fragments contained in that
     * activity.
     *
     *
     * See the Android Training lesson
     * [Communicating with Other Fragments](http://developer.android.com/training/basics/fragments/communicating.html)
     * for more information.
     */

    companion object {

        // TODO: Customize parameter argument names
        const val ARG_COLUMN_COUNT = "column-count"

        // TODO: Customize parameter initialization
        @JvmStatic
        fun newInstance(columnCount: Int) =
            FrontListFragment().apply {
                arguments = Bundle().apply {
                    putInt(ARG_COLUMN_COUNT, columnCount)
                }
            }
    }
}

app level build.gradle file

apply plugin: 'com.android.application'

apply plugin: 'kotlin-android'

apply plugin: 'kotlin-android-extensions'

def localProperitiesFile = rootProject.file("local.properties")
def localProperties = new Properties()
localProperties.load(new FileInputStream(localProperitiesFile))

android {
    compileSdkVersion 28
    defaultConfig {
        applicationId "in.relsellglobal.firebasedatabasedemo"
        minSdkVersion 19
        targetSdkVersion 28
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        buildConfigField "String", "OPENWEATHERDATA_API_KEY", "\""+localProperties['openweather_data_api_key']+"\""
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
    implementation 'androidx.appcompat:appcompat:1.1.0'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    implementation 'com.google.firebase:firebase-core:17.2.2'
    implementation 'com.google.firebase:firebase-database:19.2.0'
    implementation 'com.android.volley:volley:1.1.1'

    implementation 'androidx.legacy:legacy-support-v4:1.0.0'
    implementation 'androidx.recyclerview:recyclerview:1.1.0'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test:runner:1.2.0'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
}

apply plugin: 'com.google.gms.google-services'

When you run the application you see below screen

Right now we are having the list of cities as in-memory ArrayList. So it’s faster to load. Even rotation changes will not crash the application. But what if we load our list from a remote database like firebase realtime db.

Problem

So the above process to download the list from firebase might take few milliseconds and by that time user may choose to rotate the screen of the device.

Consequently, in android, the corresponding activity would restart on rotation now if we have designed the architecture of our application as MVP (Model view presenter ), so our view and the model classes would be interacting on the bases of interfaces or callbacks.

Basically, this means that Model classes have reference to view in direct or wrapped form. so that, whenever data arrives after a network call, the model may update the view.

On rotation, the activity would restart all the view become null and the corresponding earlier view’s reference in model class becomes null, and once this happens if model classes try to update a null view app crashes. As a side note, customers don’t like those apps which crash. It hardly matters for them, how much pain the developer has taken to develop the application.

The Rescue

Rescue is introducing MVVM Pattern to your code.

MVVM Pattern involves Model View ViewModel. Now in simple terms Model updates ViewModel. The view has put observer on ViewModel so when view requires only then it can retrieve updated values from ViewModel.

Therefore the crash that may result when the device is rotated won’t appear. Moreover, a ViewModel has no information regarding activity or Fragments.

So in our application, the code for FrontListFragment.kt onActivityCreated method would become

override fun onActivityCreated(savedInstanceState: Bundle?) {
        super.onActivityCreated(savedInstanceState)

        recyclerView!!.layoutManager = LinearLayoutManager(activity);

        val model = ViewModelProviders.of(this).get(CitiesViewModel::class.java)
        model.getCitiesList().observe(this, androidx.lifecycle.Observer { cityContentList ->
            myItemRecyclerViewAdapter = MyItemRecyclerViewAdapter(cityContentList,activity)
            recyclerView!!.adapter = myItemRecyclerViewAdapter

        })

    }

In the above code snippet, you will see fragment is observing on data from ViewModel. Now since we have introduced ViewModel our code structure will be like below

We have added a new package called ViewModel which will keep our ViewModel classes.

We have added CitiesViewModel class.

package `in`.relsellglobal.firebasedatabasedemo.viewmodels

import `in`.relsellglobal.firebasedatabasedemo.BuildConfig
import `in`.relsellglobal.firebasedatabasedemo.pojo.CityContent
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel

class CitiesViewModel : ViewModel() {
    val APPID =
        BuildConfig.OPENWEATHERDATA_API_KEY

    private lateinit var citiesContent: MutableLiveData<List<CityContent>>

    fun getCitiesList(): LiveData<List<CityContent>> {
        if (!::citiesContent.isInitialized) {
            citiesContent = MutableLiveData()
            loadCities()
        }
        return citiesContent
    }

    private fun loadCities() {
        val listOfCities = mutableListOf<CityContent>()
        var city = CityContent()
        city.cityName = "dehradun"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        listOfCities.add(city)

        city = CityContent()
        city.cityName = "new delhi"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        listOfCities.add(city)

        city = CityContent()
        city.cityName = "hyderabad"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        listOfCities.add(city)

        city = CityContent()
        city.cityName = "chennai"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        listOfCities.add(city)

        city = CityContent()
        city.cityName = "mumbai"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        listOfCities.add(city)

        city = CityContent()
        city.cityName = "mangalore"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        listOfCities.add(city)

        city = CityContent()
        city.cityName = "dispur"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        listOfCities.add(city)

        city = CityContent()
        city.cityName = "indore"
        city.apiUrl =  "http://api.openweathermap.org/data/2.5/weather?q="+city.cityName+"&appid="+APPID
        listOfCities.add(city)

        citiesContent.value = listOfCities

    }
}

To keep code simple we will stop here , we are not exploring other components in MVVM and fetching data from other sources.

By introducing MVVM to the code, we have touched two main advantages of MVVM

1. Clean Separation of Concerns
2. ViewModels are Lifecycle aware.

Conclusion

This brings us to the end of the blog. Share your feedback.

Thanks for reading

Happy Coding

Article originally published at the blog

Easy Android Programming: MVVM was originally published in The Code Monster on Medium, where people are continuing the conversation by highlighting and responding to this story.

In this article, we’re going to learn how we can split up our dataset into two parts — e.g., training and testing datasets.

When we have training and testing datasets, then we’ll apply a machine-learning linear-regression algorithm to predict the price of a car on the basis of its mileage and age (how old the car is).

Step #1

We’re going to use a couple of libraries in this article: pandas to read the file that contains the dataset, sklearn.model_selection to split the training and testing dataset, and matplotlib to draw the regression line.

First of all, import the following packages:

import pandas as pd
from sklearn.model_selection import train_test_split
from matplotlib import pyplot as plt

If you don’t have the above packages installed, then please install them before moving ahead.

Step #2

In this step, we’ll load our CSV file to explore the dataset by using pd as a pandas reference variable and call the read_csv() function along with the file name to read the file.

And now display the top five rows by using the head() function.

df = pd.read_csv('carprices.csv')
df.head()

Note: Either move your CSV file inside your working directory or pass the full pathname along with file name.

Step #3

Before splitting up the dataset into training and testing datasets, our focus must be finding the dependent and independent variables. Once these variables are prepared, then we’re ready to go to split up the dataset.

We’ll see the relationship between the mileage and sell price by drawing the data points, and after that, we’ll prepare the dependent and independent variables. Finally, we’ll split the dataset.

So let’s draw the data points using the following line of code:

plt.scatter(df['Mileage'],df['Sell Price($)'])

Now prepare the x and y variables, and display the data of the x variable.

X = df[['Mileage','Age(yrs)']]
Y = df['Sell Price($)']
X.head(10)

I assigned Mileage and Age(yrs) in X, so it's showing both of them.

Since we’ve split our data into x and y, now we can pass them into the train_test_split() function as a parameter along with test_size, and this function will return us four variables. They’re x_train, y_train, x_test, and y_test.

x_train, x_test,y_train,y_test = train_test_split(X,Y,test_size =0.2)
# print the data
x_train

As many times as you rerun the above code, you’ll get a different result every time. This is because thetrain_test_split() function picks up the random rows every time, and it’s good for our machine-learning model. If you don’t want thetrain_test_split() function to pick up the random rows, then you can do so by setting random_state = 10.

The test_size parameter in the train_test_split() function defines the size of the testing data in a percentage. Let’s say we have 100 rows, and if we pass test_size=0.2, then it means we want to keep 20% of the data of the entire dataset for the testing purposes. So in this, only 80 rows will be used for training the model.

So in case of my dataset, there are 20 rows in total, and I have given 80% data for the training the model. I’m left with 20% data. If I print the length of the x_train variable, then it’ll print 16 — and if you print the length of the x_test, then it will print 4.

Step #4

Now we’re going to fit our x and y into a machine-learning model to predict the output, but before that, we have to import the LinearRegression from the sklearn.linear_model and create an object of the LinearRegression class.

from sklearn.linear_model import LinearRegression
clf = LinearRegression()

Now fit the x_train and y_train variables.

clf.fit(x_train,y_train)

Now predict the output by passing the x_test variable.

clf.predict(x_test)

Predictions: array([38014.72666327, 16170.60704425, 17307.00704693, 34927.2349164 ])

Now let’s test the accuracy of our model.

clf.score(x_test,y_test)

Accuracy: 0.904677273463023

It means our model is accurate up to 90% of the time.

Conclusion

We have seen how we can split up the dataset into training and testing parts to pass it to the fit function. Also, we have used the linear-regression algorithm to predict the price of the car on the basis of its mileage and age.

Download my Jupyter Notebook from my GitHub account.

I hope you liked reading this article, you can also visit my website where I keep posting article regularly.

Subscribe my mailing list to get the early access of my articles directly in your inbox or follow my own publication on Medium The Code Monster to polish your technical knowledge.

Know your author

Himanshu Verma has graduated from the Dr. APJ Abdul Kalam University, Lucknow (India). He is an Android & IOS Developer and Machine Learning & Data Science Learner, a Financial Advisor, and a Blogger.

Linear Regressions and Split Datasets Using Sklearn was originally published in The Code Monster on Medium, where people are continuing the conversation by highlighting and responding to this story.

Microservice is a software development technique which aims to break down the components of the applications into smaller parts which are independent from each other and can work together. Breaking down the application components provide ease in development, increase code readability and also codebase becomes easy to maintain and test.

Why Microservices

To proceed further with Microservices, firstly understand what is the monolithic architectures.

Monolithic means composed all in one place. Monolithic is a traditional way of writing code which incorporates components of the software in a single container and these components are interconnected ,dependent and tightly coupled. In a tightly coupled architecture, each component and its associated components must be present in order to execute and compile successfully.

As you can see from the given image below, user interface, business logic and data interface all in a single codebase and this indicates that to maintain and test this codebase will not be easier.

Let’s understand this with an example

You are creating an E-commerce web application (like Amazon) which accepts orders from customers, verifies inventory and avail credits, and ships them. The application consists of several components including the user interface along with some backend services for checking credit, maintaining inventory and shipping orders.

The application is deployed as a single monolithic application. You can run multiple instances of the application behind a load balancer in order to scale and improve availability.

The image shown below is an example of E-commerce web application

This solution works perfectly until your E-commerce site not to be become large, once the application becomes large and the team grows in size, this approach has a number of drawbacks that become increasingly significant:

• Unreliable — Even if one feature of the system fails, then the entire system fails
• Unscalable — Applications cannot be scaled easily since each time the application needs to be updated, the complete system has to be rebuilt
• Blocks Continuous Development — Many features of the applications cannot be built and deployed at the same time
• Slow Development — Development in monolithic applications take a lot of time to be built since each and every feature has to be built one after the other
• Not Fit For Complex Applications — Features of complex applications have tightly coupled dependencies
• Overloaded IDE — the larger the codebase the slower the IDE and the less productive developers are.

Solution to the problem

Define an architecture that structures the application as a set of loosely coupled, collaborating services. This approach corresponds to the Y-axis of the Scale Cube.

Benefits of the microservice

• Highly maintainable and testable — enables rapid and frequent development and deployment.
• Loosely coupled with other services — enables a team to work independently the majority of time on their service(s) without being impacted by changes to other services and without affecting other services.
• Independently deployable — enables a team to deploy their service without having to coordinate with other teams
• Capable of being developed by a small team — essential for high productivity by avoiding the high communication head of large teams

Microservice vs Monolithic Architecture

Let’s take an use case of e-commerce site to better understand the difference

The main difference we observe from the above image is that all the features initially were under a single instance sharing a single database. But then, with microservices, each feature was allotted a different microservice, handling their own data, and performing different functionalities.

Conclusion

So it is clear from the above discussion that microservice technique of writing software solves the problem of code maintenance, code testing and also adding new features doesn’t affect the entire system. We can also minimise the system failures.

I hope you liked reading this article, you can also visit my website where I keep posting article regularly.

Subscribe my mailing list to get the early access of my articles directly in your inbox and Don’t forget to follow my own publication on Medium The Code Monster to polish your technical knowledge.

Know your author

Himanshu Verma has graduated from the Dr. APJ Abdul Kalam University, Lucknow (India). He is an Android & IOS Developer and Machine Learning & Data Science Learner, a Financial Advisor, and a Blogger.

Everything you need to know about Microservices was originally published in The Code Monster on Medium, where people are continuing the conversation by highlighting and responding to this story.

We all use Google in our daily life to search our queries and we get the response accordingly. But you might have come across a situation where you searched your query but didn’t get the exact links what you’ve been searching for and waste a lot of time to find the exact piece of information you needed. It happens due to Unoptimized queries, so in this guide we’ll learn those tricks which will help save your time as well as give you the exact information you needed.

Table of content

• Site Search
• Related Words
• The wildcard
• Time Range
• File Types
• The OR operator
• Word Definition
• Calculator
• Search Exact Phrase
• Hyphen
• inTitle
• Flight Running Status

Site Search

The site keyword allows you to search on a specific site, for example if you want google to show results only for Amazon for iPhone 7, so you could type in your query as follows.

Example

Related Words

This keyword helps you to find the links which is related to the word you typed in your search query.

Example

The wildcard

The asterisk (*) is a wildcard which could fit in any query of which few words are missing. For example if you want search the lyrics of any song but you forgot few words, then this keyword will help you find your favourite songs.

Example

Time Range

The operator allows you to search your queries on the basic of time range. Let’s say you want to search movies which were released from 2000 to 2019, then you can use this operator.

Example

File Types

This operator allows you to search any specific file on the basis of its type.

The OR operator

This operator lets you find the results which contains any one word out of two.

Word Definition

By using word definition you can get the full description of the word.

Example

Calculator

For using this operator you don’t have type it, you just put your mathematical expressions on the search box and hit enter, you’ll get the result.

Example

Search Exact Phrase

Quotation mark lets you perform exact phrase search that will only include results with those exact words in that exact order.

Example

Exclude a word from the search

If you don’t want any word to appear in your search, then you can use the following way of searching.

inTitle

This operator shows you those results in which your query’s words match.

Flight Running Status

If you want to know the status of the running flight in which your loved ones are flying and you have to catch them on the Airport, then you can do this by using the following smart trick.

Conclusion

These 12 tricks will help you save a lot of time and makes you feel confident and enable you to be more productive.

I hope you liked reading this article, you can also visit my website where I keep posting article regularly.

I hope you liked reading this article, you can also visit my website where I keep posting article regularly.

Subscribe my mailing list to get the early access of my articles directly in your inbox and Don’t forget to follow my own publication on Medium The Code Monster to polish your technical knowledge.

Know your author

Himanshu Verma has graduated from the Dr. APJ Abdul Kalam University, Lucknow (India). He is an Android & IOS Developer and Machine Learning & Data Science Learner, a Financial Advisor, and a Blogger.

12 Smart Ways to Search on Google Like a pro was originally published in The Code Monster on Medium, where people are continuing the conversation by highlighting and responding to this story.

As you all know Android is quite volatile operating system which means that every weeks bring some changes and changes might be regrading the bugs fixing, flaws in security, new features and list goes on. So in this guide, we’ll learn some major changes made in Android 8 which is Oreo (Codebase name).

Introduction

As everyone knows, a lot of changes made after API level 26 for optimizing Android system’s performance, the battery uses and other system-level problems which I am writing below:

• Changes in Service
• Changes in Broadcast Receiver
• Changes in Push Notification

Changes in Broadcast Receiver

So before understanding the changes in broadcast receiver let’s first understand two types of broadcast receivers in Android.

Implicit BroadCast Receiver #1

BroadCast Receiver that is provided by Android system like CONNECTIVITY_CHANGE, ACTION_BATTERY_LOW.

Explicit BroadCast Receiver #2

BroadCast Receiver which is created by the user by extending Broadcast Receiver class is Explicit BroadCast Receiver.

Now next thing is that you can register Broadcast Receiver in Android using two ways first using java code and second is in manifest.xml file. The difference is when you declare Broadcast Receiver using java code then this will not be triggered when your app is closed but if you declare in manifest.xml then this will be triggered even if your app is not running.

So after Oreo, you can not declare every implicit broadcast receiver in manifest.xml (Note: Not every Broadcast Receiver but few of them you can declare) and Android gives you a list of the implicit broadcast receiver which you can declare in manifest.xml even after Oreo. Besides that list, you can not declare any implicit broadcast receiver in manifest.xml file.

Ex- ACTION_LOCKED_BOOT_COMPLETED, ACTION_BOOT_COMPLETED

Android allows these broadcast because they are sent only once when system boot and too many apps need to receive this broadcast to schedule alarm, jobs and so forth.

List of implicit Broadcast Reciever allowed after oreo.

Reasons before Oreo

There are couple of reasons listed below we were facing Android 8, so let’s have a look at below.

• If you register an app to receive broadcast then the app’s receiver consumes resources every time the broadcast is sent. If too many apps are registered to receive broadcast then this can cause problems because every apps receiver consumes resources and it also impacts the user experience.
• The main changes after Oreo are that Background Service is not allowed, only foreground service is allowed. First, let’s understand when services are considered as background service :

Case #1

When you start a service and put the app in the background and the user is not aware of your service.

Case #2

Your app is in the background and you are starting a service, eg an alarm manager which gives you a callback and you start a service.

In the above-mentioned cases, these services will be considered as background services. So if you run a background service then Android will kill your service after a certain amount of time, but remember if you are using your app means your app is in foreground then service will not be killed.

• After Oreo background service is not allowed because the developer’s start their services and the work done by the service gets completed, but the service still keeps running. This leads to degradation in device performance and drains the battery. As I have mentioned above, there is no more background service after Oreo so you might think about the alternatives for it. Below I have stated the alternatives:

(a)-Foreground Service: Foreground service is if the user is aware that the service is running like displaying a notification attached to service for example in Ganna music application you will always see a notification while a song is playing.

(b)-Job Service: Another alternative for the background service is to use Job service which is similar to service but the difference is that it is not in your hands to start it. You will just create your JobService object and give this to Job Scheduler and Job scheduler will start this service when it will see that the resources are free. You can not force JobShedular to start your Job Service immediately, but you can just request the Job Scheduler to start in some specific time which is shown in the example below. JobShedular is similar to ThreadShedular and JobService is similar to Thread. You can also define different event for starting your job service. For example, the service will start when the device is connected to the internet or it is charging. You can also call Job Service as a combination of BroadCast Reciever and Service.

Events that you can attach with your Job Service.

And now this will run even if your app is in the background.

Let’s understand some important things related to Service with the following points:

(I)- You start a Service with start service () method when your app is running means app is in foreground then Service will not be killed in any case.

(II)- When you are starting your Service with startService() method then in onStartCommand method of Service class, call startForground() method and give a notification object and now a notification will show as long your Service will be running. As I have told you above after Oreo for displaying a notification please create a channel for notification. I will suggest you create the channel in the Application file of the project. The use of this notification channel is explained below.

Now, this is your foreground Service but If you will not call startForeground() method from onStartCommand() method and put your app in the background then after some Android will kill your Service.

(III)-You can use not StartService() method when your app is in the background after Oreo if you call this then Android will through IllegalStateException.

(IV)-If you are starting a Service when your app is in the background then use startForegroundService() method, and one more thing after calling startService() Method Android will give you 5 seconds to call startForeground() method from onStartCommand().If within 5 seconds you call this method then Android will continue your Service otherwise after 5 seconds it will be killed.

Note: Always use ContextCompat class and it will handle conditions related to Android version.

ContextCompat.startForegroundService(this, serviceIntent);

• After Oreo, you can divide your app’s notifications into channels. You can set different behavior on different channels. All notifications that are posted to the same channel have the same behavior. For example, I can create a channel for the most urgent notifications. By using the channel, every notification will have a different sound, vibration or a notification light. You can create more channels like this and can customize according to your requirements. So after Oreo, you have more control over your notifications.

We have one more chance after Oreo which are notification dots. Now after Oreo if your notifications appear then you will see dots or badges on app launcher icons. So for now if you want to know for a particular application if you have gotten a new notification then you can check the dots displayed along with the application’s icon. I will suggest you create notification channel in Application class of project like given in the code below-

Now your notification channel is created with channel id “exampleServiceChannel” , you will use this channel id when you create you notification builder object like below:

Conclusion: I have tried to cover each and every point related to changes in Push Notification, Service and BroadCast Reciever after Oreo. I hope the concepts are easy to grasp and in case of any mistakes please feel free to comment below.

Android 8.0 Behavior Changes was originally published in The Code Monster on Medium, where people are continuing the conversation by highlighting and responding to this story.

The term Blockchain might sound like its too much complicated at first but to be honest its not, if i break this term down into two new words, then they are block and chain. And now block means the container or box which can contain the information such as transactions date, amount of money transferred or deposited and the name of a person whom money was sent. So in simplest term, blockchain is the chain of blocks which are interconnected by a link or node.

What we will learn from this guide

• Introduction to Blockchain Technology
• How it works?
• How blockchain going is to disrupt various industries?
• Applications

Introduction

A blockchain is a list of records called blocks that are linked using cryptography. Each block contains a cryptographic hash of the previous block, a timestamp, and transaction data. — Wikipedia

The blockchain technology uses the Distributed Ledger Technology (DLT) which never allows anyone to alter the data in the chain. Blockchain technology ensures that the data is highly secured by higher level of encryption because cryptographic algorithms and hashing keep the blockchain secure.

How it works?

First of all let’s have a look at the following image.

Let’s create the scenario of online banking and understand how money is sent to another account.

Step #1

Let’s say a user wants to send the X amount of money to another bank account, so he initiates the transaction.

Step #2

When the transaction is initiated by the user in the step 1, then a fresh new block is created if we understand this in terms of blockchain technology.

Step #3

When the new block is created, now the block is broadcasted to all the nodes in the network or chain.

Step #4

Since this newly created block is visible to every node of the network, now its time to validate this block. Every node in the network validates every newly created block to validate it, when every node returns the same response which means that the block is valid.

Step #5

When the validation process is successful, now the block is added to the chain.

Step #6

In the last step of this process, transaction is verified and gets executed. In the last step X amount of money would be transferred to the respective account.

How blockchain is going to disrupt various industries?

The blockchain technology is going to disrupt various industries such as Banking, Healthcare, Real Estate and many more. Since everything is being online rapidly, so the use of online applications increased drastically from the last few years and as long as the security is concerned, then nobody wants to take any kind of risk when it comes to keeping the data secured. And as you now know blockchain technology is so powerful and secured which doesn’t allow anyone to tamper or damage the data.

Applications

The blockchain technology is being used in various fields such as health, online payment transfer and many more. Some of the most prominent applications are given follows.

• Payments and money transfer
• Assets management
• Insurance
• Healthcare
• Internet of Things (IoT)
• Passport
• Personal Identification
• Real Estate
• Travel
• Food and supply chain etc.

Conclusion

Blockchain technology is the most secured and prominent way of keeping online things safe. Since it goes through the long process to validate even a single block and when every node in the network nod its head in yes, then it verifies and executes it due to which hacking is close to impossible.

I hope you liked reading this article, you can also visit my website where I keep posting article regularly.

Subscribe my mailing list to get the early access of my articles directly in your inbox or follow my own publication on Medium The Code Monster to polish your technical knowledge.

Know your author

Himanshu Verma has graduated from the Dr. APJ Abdul Kalam University, Lucknow (India). He is an Android & IOS Developer and Machine Learning & Data Science Learner, a Financial Advisor, and a Blogger.

Blockchain Technology in a single view was originally published in The Code Monster on Medium, where people are continuing the conversation by highlighting and responding to this story.