Forem: Chetan

SOLID Principles

Chetan — Mon, 13 May 2024 05:26:17 +0000

S (Single Responsibility Principle):
A Class should have only one responsibility. Ex: User class should have functions only related to users.

O (Open/Closed Principle):
Open for extension but closed for modification. Means create interface and then extend it to new and old classes but don't change the old class.

L (Liskov Substitution Principle):
If class B is a subtype of class A then we should be able to replace the object of A with B without breaking the behaviour. Means subclass should extend the capabilities of parent class not narrow it down (If base class have 3 capabilities/functions then subclass should have at least 3 capabilities/functions).

I (Interface Segmented Principle):
Interface should have only necessary functions for subclasses.

D (Dependency Inversion Principle):
Class should depend on interfaces rather than concrete classes. Means always create an object of the interface.

CRUD API with Go and PostgreSQL

Chetan — Sat, 29 Oct 2022 13:28:47 +0000

In this tutorial, we're gonna build a CRUD API using GO and PostgreSQL database. We will use GORM to interact with database. You'll know:

How to perform CRUD operations using Go.
How to use Gorilla Mux for creating routes.
How to perform database operation using GORM.
How to marshal and unmarshal the data.

Overview of what we are going to build in this article

GetUsers - This function will list all users.
AddUsers - It will accept user's details as request body and save the user in database.
GetUserById - This function will accept userId as path variable and will list the user by userId.
UpdateUser - It will accepts user's updated details as request body and accept userId as path variable then this will save the updated details in database.
DeleteUser - This function will accept userId as path variable and will delete the user from database.

Steps to create project

Create a empty folder.
Open Command Prompt in that folder and run go mod init modulepath. Modulepath can be the github url of code repository. This command will create a go.mod file to track your code's dependencies. As of now we will see only name of your module and the Go version your code supports.
Run this command go get -u gorm.io/gorm and go get -u gorm.io/driver/postgres to install GORM module for interacting with database.
Again run this command go get -u github.com/gorilla/mux to install Gorilla Mux for creating routes.
Now create the necessary folders. Our project structure should look like this.

Let's start writing the code

Creating Routes:

First we will create the routes for our project. Open users-routes.go. Import gorilla/mux for routes. Import controllers folder from your project. users-routes.go will look like this.

package routes

import (
    "github.com/chetansj27/crud-go/pkg/controllers"
    "github.com/gorilla/mux"
)

var RegisterUserRoutes = func(router *mux.Router) {
    router.HandleFunc("/users", controllers.GetUsers).Methods("GET")
    router.HandleFunc("/users", controllers.AddUsers).Methods("POST")
    router.HandleFunc("/users/{userId}", controllers.GetUserById).Methods("GET")
    router.HandleFunc("/users/{userId}", controllers.UpdateUser).Methods("PUT")
    router.HandleFunc("/users/{userId}", controllers.DeleteUser).Methods("DELETE")
}

When any user hit the GET request on /users path, our route will transfer that request to GetUsers method in controller.
router.HandleFunc("/users", controllers.GetUsers).Methods("GET")
Same will happen for others requests also.

Connecting With Database:

config.go file will be used to connect with database. This file will contains database name, username and password. Below code will be used in config.go

package config

import (
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

var db *gorm.DB

func Connect() {
    dsn := "host=localhost user=username password=password dbname=gorm port=9920 sslmode=disable "
    d, err := gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        panic(err)
    }
    db = d
}
func GetDB() *gorm.DB {
    return db
}

Creating Utility Class:

Now we will open utility.go file. This file will be used for marshalling and unmarshalling the data. Marshalling means encoding Go Objects into JSON and Unmarshalling means converting json(Byte data) into Struct. Below code will handle this.

package utils

import (
    "encoding/json"
    "io/ioutil"
    "net/http"
)

func ParseBody(r *http.Request, x interface{}) {
    if body, err := ioutil.ReadAll(r.Body); err == nil {
        if err := json.Unmarshal([]byte(body), x); err != nil {
            return
        }
    }
}

Models and Database Query:

Our user.go file will contains user model and all database queries.
First we will create User struct

type User struct {
    Id      uint64 `gorm:"primaryKey" json:"id"`
    Name    string `json:"name"`
    Email   string `json:"email"`
    Address string `json:"address"`
}

Id is the primary key.
Now we will create a init function for initializing the database.

var db *gorm.DB
func init() {
    config.Connect()
    db = config.GetDB()
    db.AutoMigrate(&User{})
}

In above code we are initializing the database connection which we defined in config.go file.
db.AutoMigrate(&User{}) will create a user table in database where fields of user struct will be converted into columns.

Add User Query

We will create a AddUser function which will take User struct as request body and will return the saved User.

func AddUser(us *User) *User {
    db.Create(&us)
    return us
}

In the same way we can create all function according to our need.

Creating function in controllers:

Controllers are very important for any api. user-routes.go will transfer requests to controller.
We will create a function in controller for adding the user.
user-controllers.go will contain the code for controllers.

Add User

We will AddUser function for creating new user and saving them to database. AddUser function will have two parameters one for returning the response and other for request body.

func AddUser(writer http.ResponseWriter, request *http.Request) {
    addUser := &models.User{}
    utils.ParseBody(request, addUser)
    user := models.AddUser(addUser)
    res, _ := json.Marshal(user)
    writer.Header().Set("Content-Type", "application/json")
    writer.WriteHeader(http.StatusOK)
    writer.Write(res)
}

In above code first we create a addUser variable of User struct type. Then we get the request body from request and parsed it into addUser variable. After that we saved the user in database. Then we marshaled the response. In end we set content-type and statusOk in header and then we write the response into writer. That's how user will added in database.
Same way we can create function for getting the user, updating the user and deleting the user.

Last Step:

After creating all function, now we will configure our main.go file. In this file we will register our routes and define host and port for running the applicatio.

func main() {
    route := mux.NewRouter()
    routes.RegisterUserRoutes(route)
    http.Handle("/", route)
    log.Fatal(http.ListenAndServe("localhost:8182", route))
}

We are all set for running our application. Now open terminal and cd into cmd\main package and run go run main.go this command. Now our application is live at localhost:8182.
For complete code you can visit Github Link
Below are screenshots of application.

Add User

Get All Users

Happy learning!

Create Database Role in PostgreSQL

Chetan — Thu, 23 Dec 2021 17:44:25 +0000

Database role is the person who have access to perform action on database.
We can create new database role in PostgreSQL by running below query:

For creating new role you must have CREATEROLE privilege or be a database superuser to use this command.

Parameters

name: This will be the name of new role.
SUPERUSER/NOSUPERUSER: This is clause is used to determine whether the new role will can override all access restrictions within the database. SUPERUSER clause will give all access to new role. If not specified, NOSUPERUSER is the default.
CREATEDB/NOCREATEDB: These are used to determine whether the new role can create Database or not. CREATEDB will give permission to create database to new role whereas NOCREATEDB will deny the ability to create database. If not specified NOCREATEDB is the default.
INHERIT/NOINHERIT: These clause define whether the new role can inherit privileges of roles it is a member of. INHERIT will give the all privileges that have been granted to all roles it is directly or indirectly a member of. If not specified NOINHERIT is the default.
LOGIN/NOLOGIN: These clauses determine whether a role is allowed to log in; that is, whether the role can be given as the initial session authorization name during client connection. A role having LOGIN attribute can be thought as user. If not specified NOLOGIN is default.
REPLICATION/NOREPLICATION: These clause define whether the role is a replication(replication means copying data from a PostgreSQL database server to another server) role. REPLICATION clause will give the permission to create replication. If not specified NOREPLICATION is default.
CONNECTION LIMIT: This clause specifies how many concurrent connections role can make. By default it is -1 means no limit and maximum limit is 115 connections.
PASSWORD: This will create a login password for the role. If you don't want to specify password you can omit. If no password is specified the password will be set to null and password authentication will always fail for this role. Password is always stored in encrypted form in system.
VALID UNTIL: This clause set the date and time after which password will be expired. If no value is specified for VALID UNTIL then password will never expire.

For example above query will create role with chetan name with login, inherit, createdb access and don't have superuser, replication and createrole access. The connection limit is -1 means no limit and password is chetan.

For example above query will create role with chetan name with all privilege. The password will expire after 30 Dec 2021 at 02:10. In same way we can create role with different parameters.

Basics of Kotlin - Part 4

Chetan — Mon, 26 Apr 2021 08:44:53 +0000

In the last article, we learnt about some basic concepts of Kotlin like conditional statements, loops and jump statements. Before reading this article make sure you had read the last article Basics of Kotlin- Part 3. Let's learn more about Kotlin.

Functions:

Functions in any programming language is a group of an interrelated block of code that performs a specific task. Functions allow us to break a program into various small sub-module. Functions increase the readability of code, reusability of code, and makes a program easy to manage.

In Kotlin fun keyword is used to declare the function. There are two types of functions in Kotlin depending on whether it is available in the standard library or defined by the user.

Standard library function:
Standard library function is built-in library functions that can be defined implicitly and available for use.

fun main(args: Array<String>){  
var number = 16
var result = Math.sqrt(number.toDouble())  
print("$result")  
}
Output : 4

In the above code snippet :
sqrt() is a function defined in the library which returns the square root of a number.
print() function prints message to a standard output stream.

User-Defined Functions:
User-defined functions are created by the user and can be used for advanced programming. Here functions are declared by using fun keyword.

fun main(){
   functionName()
}
fun functionName(){
     //body of function
}

Here, we call the function into the main function to run codes inside the body functionName().

Template for function in Kotlin:
fun functionName(argument name:argument type):return type{
      //body of function
}

Below is an example of a user-defined function

fun main() {
  val x=6
  val y=8
  println("Sum of $x and $y is "+add(x,y))
}
fun add(x:Int, y:Int):Int{
    return x+y
}

Here we create a function add which is taking two arguments of int type and return type of this function is also int. We had called this function inside our main function.

Tail-recursion:

Kotlin supports a style of functional programming known as tail recursion. When we try to do a large number of recursive function call, we get an error java.lang.StackOverflowError. To handle this Kotlin have tailrec function. When a function is marked with the tailrec modifier and meets the required form, the compiler optimizes out the recursion, leaving behind a fast and efficient loop based version instead. Tail recursion follows one rule for implementation. This rule is as follow:

The recursive call must be the last call of the method. To declare a recursion as tail recursion we need to use tailrec modifier before the recursive function.

For example, to calculate the factorial of any number we can use the below method:

fun main(args: Array<String>) {  
    val number = 10  
    val result: Long  
    result = factorial(number)  
    println("Factorial of $number = $result")  
}  

tailrec fun factorial(n: Int, run: Int = 1): Long {  
    return if (n == 1){  
        run.toLong()  
    } else {  
        factorial(n-1, run*n)  
    }  
}
Output : 
Factorial of 10 = 3628800

Lambda Expressions:

Lambda is a function that has no name. Lambda is defined with curly braces {} which takes variable as a parameter (if any) and body of the function. The body of the function is written after the variable (if any) followed by the -> operator.

Syntax of lambda expression:
{ variable -> body_of_function}

Lambda expression syntax
The full syntactic form of lambda expressions is as follows:

val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }

A lambda expression is always surrounded by curly braces.
Parameter declarations in the full syntactic form go inside curly braces and have optional type annotations.
The body goes after an -> sign.
If the inferred return type of the lambda is not Unit, the last (or possibly single) expression inside the lambda body is treated as the return value.

Program for adding two numbers using lambda
fun main(args: Array<String>) {  
    println(sum(5,6))
}  
val sum = { x: Int, y: Int -> x + y }
Output : 11

Exception Handling in Kotlin:

Exception in programming is defined as a run time problem that occurs in a program and leads to the termination of the program. Exceptions can occur due to less memory space, array out of bound, conditions like division by zero. To solve this type of error in the program exception handling is used.

Exception handling is defined as a process which handles the runtime problems and also maintains the flow of the program during execution.

In Kotlin all exception classes are descendants of class Throwable. Kotlin uses the 'throw' expression to throw an exception object.

There are four types of keywords used in exception handling. These are:

try: try block contains a block of statements which might create the exception. It is always followed by either catch or finally or both.
catch: It is used to catch an exception thrown from the try block.
finally: It is used to checks whether the exception is handled or not.
throw: It is used to throw an exception explicitly.

Example of try-catch
fun main (args: Array<String>){  
    try {   
        val res =  9/ 0  

    } catch (e: ArithmeticException) {  
        println(e)  
    }
}
Output :
java.lang.ArithmeticException: / by zero

We can throw an exception explicitly by using the throw keyword.

Example of try-catch using throw keyword
fun main (args: Array<String>){  
    try {   
       println("Inside throw")
       throw Exception("Exception throwed")
} catch (e: Exception) {  
        println(e)  
    }
}
Output:
Inside throw 
java.lang.Exception: Exception throwed

That's it for this article. We will continue in the next article.

Happy Learning!

Basics of Kotlin - Part 3

Chetan — Sat, 24 Apr 2021 10:36:38 +0000

In the last article, we learnt about some basic concepts of Kotlin like type casting, operators, how to take input and comments. Before reading this article make sure you had read the last article Basics of Kotlin- Part 2. Let's learn more about Kotlin.

if expression:

In Kotlin, if is an expression which returns a value. It is used to control the flow of the program structure.

For example:
var a=7;
if(a%2==0){
    print("even number")
}

In the above code snippet, the reminder of a with 2 is not equal to 0 so it will not execute the code of if block and will not give any output.

if-else:

In if-else, if the condition of if expression is true then it will execute the code of the if block otherwise it will execute the code of else block.

var a=7;
 if(a%2==0){
     print("even number")
 }
 else{
    print("odd number")
 }
Output : odd number

In the above code snippet, the reminder of a with 2 is not equal to 0 so it will not execute the code of if block and will execute the code of else block.

if-else ladder:

In this, we will check multiple conditions.

var num=7;
 if(num>0){
    print("positive number")
 }
 else if(num<0){
    print("negative number")
 }
 else{
    print("zero")
 }
Output : positive number

Nested if:

In this, we have conditions inside the block of a condition.

val num1=10
val num2=20
val num3=15
if(num1>num2){
   if(num1>num3){
        print("num1 is largest")
   }
   else{
      print("num3 is largest")
   }
}
else if(num2 > num3){  
   print("num2 is largest") 
}
else{  
   print("num3 is largest")
}
Output :
num2 is largest

The above code snippet will print the largest number of 3 numbers.

when expression:

when expression in Kotlin is similar to switch statement in Java/C++. It is basically a conditional operator in which multiple conditions can be applied on a particular variable. when operator matches the variable value against the branch conditions. If it is satisfying the branch condition then it will execute the statement inside that scope.

val num=3
    when(num){
        1 -> println("One")  
        2 -> println("Two")  
        3 -> println("Three")  
        4 -> println("Four")  
        5 -> println("Five")  
        else -> println("invalid number")  
    }
Output :
Three

We can have multiple statements enclosed within a block of condition.

val num=1
when(num){
     1->{
       println("first")
       println("day")
    }
    else->print("not first")
}
Output :
first
day

We can use multiple branches of condition separated with a comma. It is used, when we need to run the same logic for multiple choices.

var num=4
when(num){
  0,2,4,6,8->println("even")
  1,3,5,7,9->println("odd")
  else->println("number greater than 9")
}
Output : even

The when expression also checks the ranges of input provided in when condition. A range is created using .. (double dot) operator. The in operator is used to check if a value belongs to a range.

var num=8
when(num){
   in 1..5->print("num is from 1 to 5")
   in 6..10->print("num is from 6 to 10")
   else->print("num is greater than 10")
}
Output : num is from 6 to 10

for loop:

for loop is used to iterate through any kind of data structure. It iterates through arrays, ranges, collections, or anything which is provided for iteration. This is equivalent to the foreach loop in languages like Java, C#.

var array=arrayOf(1,2,3,4,5)
for(item in array)
  println(item)
Output :
1
2
3
4
5

The above code snippet will print each item of the array.

To iterate over a range of numbers, we can use a range expression:

for( i in 1..3)
    println(i)
Output :
1
2
3

We can modify the for loop according to our requirements. For example, if we want to print the first five even number, then we can use the following code:

for(i in 2 .. 10 step 2)
    println(i)
Output :
2
4
6
8
10

Here step is the increment in the counter variable.

while loop:

while loop will continuously execute the body code while their condition is satisfied.

var num=5
 while(num>0){
      println(num)
      num--
 }
Output : 
5
4
3
2
1

do-while loop:

do-while loop will continuously execute the body code while their condition is satisfied.

var num=10
do{
  println(num)
  num--
}while(num>5)
Output :
10
9
8
7
6

The difference between while and do-while is:

while checks the condition and, if it's satisfied, executes the body and then returns to the condition check.

do-while executes the body and then checks the condition. If it's satisfied, the loop repeats. So, the body of do-while executes at least once regardless of the condition.

Return and Jump:

Kotlin has three jump expressions.

return by default returns from the nearest enclosing function or anonymous function.
break terminates the nearest enclosing loop.
continue proceeds to the next step of the nearest enclosing loop.

return:
It is a keyword that returns some value to the calling function from the called function.

fun main() {
    var x=5
    println(square(x))

}
fun square(x:Int):Int{
    return x*x
}
Output : 25

In the above code, the square function will return the square value of the variable.

break:
break is used to terminate the controller flow. In the below example, for loop will terminate its loop when if condition executes break expression.

for(i in 1..5){
      if(i==4){
          break
      }
      println(i)
}
Output :
1
2
3

As we can see in the above code when i==4 become true loop gets terminated and we don't get any output after that.

continue:
continue is used to skip the current iteration of the loop and jumps the control to the end of the loop for the next iteration. It is generally used with if-else to skip the current iteration of the loop for a specific condition.

for(i in 1..5){
        println("$i before continue")
        if(i==4)
         continue
        println("$i after continue") 
}
Output:
1 before continue
1 after continue
2 before continue
2 after continue 
3 before continue 
3 after continue 
4 before continue 
5 before continue 
5 after continue

As we can see for i=4 after continue statement doesn't get printed because continue had escaped the remaining code and the control goes to the end of the loop for the next iteration.

That's it for this article. We will continue in the next article.

Happy Learning!

Basics of Kotlin - Part 2

Chetan — Fri, 23 Apr 2021 18:31:28 +0000

In the last article, we learnt about some basic concepts of Kotlin like what is Kotlin, features of Kotlin, how to declare variables and data types in Kotlin. Before reading this article make sure you had read the last article Basics of Kotlin- Part 1. Let's learn more about Kotlin.

Kotlin Type Conversion:

Type Conversion is a procedure of converting one type of data variable into another data type. It is also known as Type Casting. Unlike Java, Kotlin does not support the implicit conversion of a smaller data type into a larger data type. It means we can not assign Int into Long or Double.

In Java:

int a=10;
long b=a; //no error

In Kotlin:

var a=10;
var b:Long=a //compiler error Type mismatch

However, we can do the explicit conversion with the help of predefined helper functions. The list of helper functions used for numeric conversion in Kotlin is given below:

toInt()
toByte()
toShort()
toChar()
toLong()
toFloat()
toDouble()

For example:
var a=10;
var b:Long=a.toLong() //compiles successfully no error

Operators:

Operators are the special characters or symbols which performs the operation on operand(value or variable). There is various kind of operators in Kotlin:

Arithmetic Operators:

Arithmetic operators are used to perform basic mathematical operations such as addition (+), subtraction (-), multiplication (*), division (/) and modulo(%)

Example:
var a=11
var b=5
print(a+b) // Output : 16
print(a-b) // Output : 6
print(a*b) // Output : 55
print(a/b) // Output : 2
print(a%b) // Output : 1

Relation Operators:

Relation Operator is used to compare two values, two variables or two numbers. It always gives output as true or false.

For example:
 var a=11
 var b=5
 print(a<b) //Output : false
 print(a>b) //Output : true
 print(a<=b) //Output : false
 print(a>=b) //Output : true
 print(a==b) //Output : false
 print(a!=b) //Output : true

Assignment Operators:

Assignment Operators are used to assigning the arithmetic operated values. The assignment of value takes from right to left.

For example:
var x = 10
var y = 2
var x + = y // Output : 12
Var x - = y // Output : 8
Var x * = y // Output : 20

Unary Operators:

Unary operators are used with only a single operand.

In pre increment/decrement the value will be updated before assigning to the variable and in post increment/decrement the value will be updated after assigning to the variable

var a=10
print(a++) //Output : 10
print(a) //Output : 11
print(++a) //Output : 12

Logical Operators:

Logical Operators are used to check conditions between operands.

For example
var a=10
var b=5
var c=16
print((a>b)&&(a>c)) //Outout : false
print((a>b)||(a>c)) //Output : true
var flag=true
print(!flag) //Output : false

Input in Kotlin:

Kotlin uses the standard library function readLine() which read the line of string input from the standard input stream.

var name=readLine() //For string input

If we want the input of other data types, then we can use Scanner object. For that, we need to import Scanner class from Java standard library using:

import java.util.Scanner

Then, we need to create Scannerobject from this class.

val scannerObj= Scanner(System.`in`)

Now we can use this scannerObj for taking the input from the user

var name=scannerObj.next() // For String input
var age = scannerObj.nextInt() // For Integer input
var charInput=scannerObj.next().single() //For char input
var doubleInput=scannerObj.nextDouble() //For double input

Comments in Kotlin:

Comments are used for making the source code easier for humans to understand. They provide explanatory information about the source code. Comments are ignored by the compiler so they will not execute. Kotlin has two types of comments:

Single Line: Single line comment is used for commenting single line of the statement.
Multi-line: Multi-line comment is used for commenting multiple lines of the statement.

//This is single line comment
/* This is
   multiline
   comment */

That's it for this article. We will continue in the next article.
Happy Learning!

Basics of Kotlin - Part 1

Chetan — Thu, 22 Apr 2021 10:31:04 +0000

In the last article, we try to learn about Gradle and App Folder. If you haven't read the previous article, visit this link and read it
Exploring the Android Studio
Before we start working on Android, let's learn about Kotlin first. In the next few articles, we will try to learn the basics of Kotlin like the loop, conditional statements, function, class.

Kotlin:

Kotlin is an open-source, statically typed and general-purpose language that runs on Java Virtual Machine(JVM). It was developed by JetBrains Team, the official designer of the most intelligent Java IDE, named Intellij IDEA. It was officially released in February 2016 and in 2017 Google announced it as the official language for Android Development. It combines the features of Object-Oriented Programming (OOPs) and functional programming into a unique platform.

Features of Kotlin:

Concise: Kotlin is the language where lines of code can be reduced up to 40%. This makes Kotlin an ideal choice for software development.

Null Safety: Kotlin aimed to eliminate the NullPointerException (null reference) from the code. Kotlin system can easily distinguish between null references and not null references. For example:

var name:String="Aman"
name=null //This is will give an error 
To permit null value we can declare it as:
var name:String?="Aman"
name=null

Interoperable: Kotlin is fully compatible with Java Code which means existing Java code can be naturally called from Kotlin, and Kotlin code can be used from Java.
Fast Compilation: It is easy to compile the Kotlin code which results in better performance and fast compilation time.
Smart cast: The Kotlin compiler automatically converts the variable to a particular class reference once it's passed through any conditional operator.
Extension function: Kotlin supports a variety of extension function which means it helps to extend the functionality of classes without touching their code.

Variables:

Variables are the name we give to computer memory location. These are used to store and manipulate the data. We can declare a variable by using var and val keyword.

var name="aman" //string
val age=10 //integer

We can also explicitly specify the datatype of the variable:

var name:String="aman" //string
val age:Int=10 //integer

var: We can change the value of the variable declared using var keyword. Therefore it is known as a mutable variable. For example:

var age:Int=8
age=10
print(age)

This will give 10 as output

val: We can not change the value of the variable declared using val keyword. Therefore it is known as an immutable variable. For example:

val age:Int=8
age=10
print(age)
This will give an error(Val cannot be reassigned)

Data Types in Kotlin:

Data types are set of relatable values and describe the operations that can be operated on them. It refers to the type and size of data associated with variables and functions. In Kotlin every data type is considered as an object.
Kotlin has the following categories of data type:
Number:
This data type holds only number type data variable. It is further sub-categorised as Integers and Floating-Point Numbers.

Integers: It contains numeric value without decimal. It has four types:

var byteVar:Byte=29 //byte data type
var shortVar:Short=323 // short data type
var intVar:Int=40000 //int data type
var longVar:Long=8673463 // long data type

Floating point: It contains non Integer numbers that carry some decimal values. It has two types- Float which has a 32-bit single-precision floating-point value and Double which has a 64-bit single-precision floating-point value.

var floatVar:Float=29.0f // float data type
var doubleVar:Double=8450.445 //double data type

Boolean:
It represents the logical value. It contains either true or false.

var boolVar:Boolean=true //boolean data type

Char:
Character in Kotlin is represented with the help of char keyword. Character can be declared using a single quote 'c'.

var charVar:Char='c' //char data type

String:
Strings are the arrays of character means a string will contain one or more than one characters. Strings in Kotlin are immutable, which means we cannot change the elements in String. Kotlin has two kinds of string raw string and escaped string. Escaped String allows providing extra line space after the first print statement.

var escapedString:String="first name \n" //escapedString
var rawString:String="last name" //rawString

Arrays:
Arrays are used to store homogenous data. We can create arrays of different data types like an array to store int value and another array to store string value. Arrays are represented by Array class. We can create array using library function arrayOf() and Array() constructor.

Differents approach to declare array
val stringArray=arrayOf("name","age")
val stringArray=arrayOf<String>("name","age")
val stringArray=Array(2){"name";"age"}
val stringArray=Array<String>(2){"name";"age"}

We can access elements of an array using the index. For example, if we want to access the first element then we can access it with 0 index.

val stringArray=Array<String>(3){"first";"second";"third";}
print(stringArray[1])
This will third as output

Array index starts from 0. So if we are accessing the first element then we have to use the index 0.

That's it for this article. We will continue in the next article.
Happy Learning!!

Basic concepts of Android-Part 1

Chetan — Wed, 21 Apr 2021 11:23:40 +0000

In this article, we are going to discuss some concepts of Android that you might face in your interview or during the project.

Package Name:

The package name is used for unique identification for your application.
Android uses the package name to determine if the application has been installed or not. Generally, the package name of an app is in the format

domian.company.appname

Here domain portion is the domain extension like .com, .org, or .eu. The company portion is generally the name of the developer's company and appname describe the app itself. Appname could be of a single word or multiple words separated by a dot. For example

com.google.android.apps.photos

In the above code snippet:

com is the domain
google is the developer's company name
android.app.photos is the app name

Minimum SDK:

It is an integer that defines the minimum API level(version of the Android operating system) required to run your application. If the system's API Level is lower than the value specified in this attribute, then the Android system will prevent the user from installing the application.

In the above image, we had selected the Minimum SDK as 27 and Android Studio shows us that it will run on 53.5% of devices.

Activity:

Activity class is one of the most important parts of Android. No matter how small an app is, it will have at least an Activity. An Android activity is one screen of the Android app's user interface. An app can have multiple activities means multiple screens. Android activity is the subclass of ContextThemeWrapper class.
Every activity contains a layout, which has a user interface to interact with the user. In this layout, we define what a user will see when (s)he open this activity and in Java/Kotlin we define the functionality of the activity.

In the above image, we had setContentView method and in this, we had set R.layout.activity_main as the layout for this activity.

Activity Life Cycle:

Unlike other programming languages where main() method is the entry point of the program, the android operating system initiates the code in an Activity instance by invoking specific callback methods that correspond to specific stages of its lifecycle. In the below diagram we can see the life cycle of an Activity.

onCreate()- This is the first callback and called when the activity is first created.
onStart()- This is called when the activity becomes visible to the user.
onResume()- This is called when the user starts interacting with the application.
onPause()- The paused activity does not receive user input and cannot execute any code and called when the current activity is being paused and the previous activity is being resumed.
onStop()- This callback is called when the activity is no longer visible.
onDestroy()- This callback is called before the activity is destroyed by the system.
onRestart()- This callback is called when the activity restarts after stopping it.

Service:

A service is a component that runs in the background to perform long-running operations such as playing music, handle network transactions, interacting with content providers without needing to interact with the user and it works even if the application is destroyed. It doesn't have any UI (user interface). The android.app.Service is a subclass of ContextWrapper class.

A service can essentially take two states:

Started: A service is started when a component (like activity) calls the startService() method, now it runs in the background indefinitely. It is stopped by the stopService() method. The service can stop itself by calling the stopSelf() method.
Bound: A service is bound when another component (e.g. client) calls the bindService() method. A bound service offers a client-server interface that allows components to interact with the service, send requests, get results, and even do so across processes with interprocess communication (IPC). The client can unbind the service by calling the unbindService() method.

While creating a service following are the most important callback methods that you should override:

onStartCommand()- The system calls this method when another component, such as an activity, requests that the service be started, by invoking startService(). When this method executes, the service is started and can run in the background indefinitely. If you implement make sure to stop the service when its work is done, by calling stopSelf() or stopService() methods.
onBind()- The system calls this method when another component wants to bind with the service by calling bindService(). If you implement this method, you must provide an interface that clients use to communicate with the service, by returning an IBinder object. You must always implement this method, but if you don't want to allow binding, then you should return null.
onUnbind()- The system calls this method when all clients have disconnected from a particular interface published by the service.
onRebind()- The system calls this method when new clients have connected to the service after it had previously been notified that all had disconnected in its onUnbind(Intent).
onCreate()- The system calls this method when the service is first created using onStartCommand() or onBind(). This call is required to perform a one-time set-up.
onDestroy()- The system calls this method when the service is no longer used and is being destroyed. Your service should implement this to clean up any resources such as threads, registered listeners, receivers, etc.

We will continue this in the next article.
Happy Learning!

Exploring the Android Studio

Chetan — Tue, 20 Apr 2021 06:43:08 +0000

In the last article, we learn How to create a project in Android Studio and in this article we are going to explore the Android Studio.

After creating the project this screen will appear in Android Studio

In this article, we will try to learn about the App folder and Gradle Scripts

As we can see in the above image there is manifests folder, inside this folder there is a file AndroidManifests.xml. When we click on this file, we will see something like this on our screen

AndroidManifests.xml:

This file describes essential information about our app to Operating System and Gooogle Play.
Manifest file is required to declare the app's package name
It is required to declare the component of the app like:
- activity
- service
- receiver
- provider
This is the file where we have to add all uses-permission that we are using in our app. For example, if we want to read the external storage of use, then we have to add the following line in our AndroidManifests.xml file, If we want to access other things, we have to follow the same process.
We can change the launcher icon of our app from this file.

android:roundIcon will be used on a device that uses roundIcon otherwise android:icon will be used
In this file we declare what types of Hardware or Software feature our app requires. For example, if our app requires Bluetooth and without it, our app will not work, then we can declare this in the below way:
We can define the intent-filter in this file.

App activities, services, and broadcast receivers are activated by intents.

For example, we can change what activity will open when our app will open means we can change the launcher activity.

In the above image, we had chosen SecondActivity as our launcher activity.

Java Folder :
In this folder, we will write the code for our apps like what will happen when we click on the button and all.

For example, in the above image, we have the file MainActivity. This file will handle the functionality of the MainActivity Screen.

res folder:
This folder is used to store the value of resources that we are using in our project like colors, strings, layout, styles and drawable.

drawable: This folder contains the different types of images used for the development of the application. It also contains the XML drawable which are used to describe shapes (color, border, gradient), state, transitions and more.
layout: It contains the XML code of all layouts of our project.
mipmap: It contains our app/launcher icons (which are shown on the home screen). >It’s best practice to place our app icons in mipmap- folders (not the drawable- folders) because they are used at resolutions different from the device’s current density.
values: This folder contains the value of color, strings and style.
- colors.xml: The colors.xml is an XML file that is used to store the colors for the resources. We can use these colors throughout our app.
- strings.xml: It is used todefine the strings in one file so that it is easy to use same string in different positions in the android project
- styles.xml: In this file all the themes of android project are defined.

Gradle Script

build.gradle(Project:applicationName) This file is in the root folder of the project and its configuration settings apply to every module in the project. A module is an isolated piece of the bigger project. In a multi-module project, these modules have their jobs but work together to form the whole project. Most Android projects only have one module, the app module.

build.gradle(Module:applicationName.app):: The file here is in the app folder. Its build settings apply only to the app module. If there were another module, then that module would have its build.gradle file, too.

In this file we can define:

applicationId: This is the package name of our app
minSdkVersion: It specifies the minimum API Level on which the application is able to run.
targetSdkVersion: It specifies the API Level on which the application is designed to run
versionCode: It's a positive integer that's used for comparison with other version codes. It's not shown to the user, it's just for record-keeping in a way.
versionName: This is the version string seen by the user. It isn't used for internal comparisons or anything, it's just for users to see.
dependencies: Dependencies refer to the things that supports in building your project, such as required JAR file from other projects and external JARs like JDBC JAR or Eh-cache JAR in the class path

Happy Learning!

How to create a project in Android Studio

Chetan — Sat, 17 Apr 2021 18:34:17 +0000

In this article, you are going to learn How to create a project in Android Studio.
I assume that you have Android Studio installed on your device.
In the first step, you have to open Android Studio and click on Create New Project

After doing this, you have to select a project template for our app. There are many project templates in Android Studio like:

No Activity- It will create empty projects means you have to add the MainActivity by yourself.

Basic Activity- It will create a new basic activity with Navigation Component.

Bottom Navigation Activity- It will create a new activity with bottom navigation.

Empty Activity- It will create a new empty activity. Most of the time you will use this activity.

Navigation Drawer Activity- This will create a new activity with navigation activity.

Apart from the above templates, there are also other templates available in Android Studio.
You can know the use of each template by just clicking on them.

After selecting the required template click on the Next button, then a Configure Your Project screen will open.

From this You can change:

Project Name- This will the name that you want to give your project

Package Name- It will uniquely identify the app on the device. Make sure to change your package name. Your package name shouldn't be like com.example.appname because Google will not allow you to publish the app with such package names.

Save location- This is the location where you want to save your project.

Language- The language in which you want to write the code for the app. Java and Kotlin are the two available options.

Minimum SDK- This the minimum version of Android that your app can run on. It will show for the specific version, your app will run on what % of devices like
for Android 8.1 it will run on 53.5% of devices
and for Android 4.1 it will run on 99.8% of devices.

After filling all the fields click on the finish and your project will be created.

Happy Learning!

Forem: Chetan

SOLID Principles

CRUD API with Go and PostgreSQL

Steps to create project

Let's start writing the code

Creating Routes:

Connecting With Database:

Creating Utility Class:

Models and Database Query:

Add User Query

Creating function in controllers:

Add User

Last Step:

Add User

Get All Users

Create Database Role in PostgreSQL

Parameters

Basics of Kotlin - Part 4

Functions:

Standard library function:

User-Defined Functions:

Tail-recursion:

Lambda Expressions:

Exception Handling in Kotlin:

Basics of Kotlin - Part 3

if expression:

if-else:

if-else ladder:

Nested if:

when expression:

for loop:

while loop:

do-while loop:

Return and Jump:

Basics of Kotlin - Part 2

Kotlin Type Conversion:

Operators:

Arithmetic Operators:

Relation Operators:

Assignment Operators:

Unary Operators:

Logical Operators:

Input in Kotlin:

Comments in Kotlin:

Basics of Kotlin - Part 1

Kotlin:

Features of Kotlin:

Variables:

Data Types in Kotlin:

Basic concepts of Android-Part 1

Package Name:

Minimum SDK:

Activity:

Activity Life Cycle:

Service:

Exploring the Android Studio

AndroidManifests.xml:

Gradle Script

How to create a project in Android Studio