Gentle Kotlin

Web Services with Kotlin using Ktor (Installation)

2020-12-31T00:00:00+00:00

JetBrains provides users with an option to install ktor using their IntelliJ Idea Plugin. However, if you don’t use IntelliJ Idea IDE or you would simply like to install it by yourself using Gradle, then this guide can be useful to you!

Installation using Gradle from Scratch

To setup ktor using Gradle, first ensure that you have Gradle installed on your machine. Then, make a new directory for your project and run the gradle init command inside it. After this, you will be prompted to enter the project options. For this, you should select Application for project type, Kotlin for implementation language, and Kotlin again for script DSL. If you are prompted to split the application into multiple sub-projects, then feel free to choose whichever option you prefer. For the purpose of this guide, I opted to go with the ‘no’ option. The project and package name can be set as desired (or left as default). Once the gradle init command has finished running with all the provided options, you can use the gradle run to run the generated ‘Hello, World’ program. The source code for this project can be found under /app/src/main/kotlin/<project-name>/ and you can edit this as desired to test things out.

Next, ktor will need to be installed in the generated gradle kotlin project. For this, you will first need to visit the Official Ktor Website and navigate to the gradle section on the docs in order to obtain the latest version number of ktor that you wish to install. Then, you will need to add the following lines under dependencies in the app/build.gradle.kts file of your project:

implementation("io.ktor:ktor-server-core:<ktor-version-goes-here>")
implementation("io.ktor:ktor-server-netty:<ktor-version-goes-here>")

Note: Please ensure that you add the desired ktor version in the lines given above. To use the latest version, simply refer to the docs as mentioned above. The final build.gradle.kts file should look something like this (likely with different versions and mainClass name under application):

plugins {
    id("org.jetbrains.kotlin.jvm") version "1.3.72"
    application
}

repositories {
    jcenter()
}

dependencies {
    implementation(platform("org.jetbrains.kotlin:kotlin-bom"))
    implementation("org.jetbrains.kotlin:kotlin-stdlib-jdk8")
    implementation("com.google.guava:guava:29.0-jre")
    implementation("io.ktor:ktor-server-core:1.5.0")
    implementation("io.ktor:ktor-server-netty:1.5.0")
    testImplementation("org.jetbrains.kotlin:kotlin-test")
    testImplementation("org.jetbrains.kotlin:kotlin-test-junit")
}

application {
    mainClass.set("gradle.test.AppKt")
}

Now, when you run gradle run, gradle should automatically resolve all the dependencies. If you’re using IntelliJ Idea IDE to work with this project, then you may have to reload the IDE or click on the option that lets you reload and index changes made by gradle run into IntelliJ.

To verify that everything is working as intended, you can add the following code to the App.kt file in your project (be sure to change the package name as neccessary!) and use the command gradle run to start the web server. If everything went smoothly, then visiting the URL http://localhost:8080 should show you a web page with the text Hello, World!.

package KtorTestProject // This package name should be different for you

import io.ktor.application.*
import io.ktor.response.*
import io.ktor.routing.*
import io.ktor.server.netty.Netty
import io.ktor.server.engine.embeddedServer

fun main(args: Array<String>) {
    embeddedServer(Netty, 8080) {
        routing {
            get("/") {
                call.respondText("Hello, World!")
            }
        }
    }.start(wait = true)
}

You can find the code generated and shown in this guide over at this repository.

Installation using Gradle from Ktor Starter (Recommended)

If you don’t want to setup everything from scratch using Gradle as shown in the section above, then you can use Ktor’s Project Generator that comes with everything that you would need to get started on a ktor project. The project generator even lets you select from many of the useful dependencies that you may want on your project (such as JSON serialization, CORS, and Session support).

To get started with the project generator, visit Ktor’s Project Generator and choose Gradle project and check the with Wrapper option. Then, choose the Netty server engine and latest ktor version available to you. The remaining text fields can be filled out as desired but for this guide I filled out com.gentlekotlin.helloworldktor for group and hello-world-ktor for project name. For the scope of this guide, we will not reuiqre any additional dependencies so you can leave all of the server-side and client-side features unchecked.

Lastly, simply click on Build and you should have a zipped version of your starter project ready to go. Now, simply unzip the project files, open the extracted directory, and use the gradle run command. This should resolve all dependencies for you and start the ktor server on http://0.0.0.0:8080/ for you. However, when you visit this, don’t be surprised if get a Page not found error. To fix this, we will need to define what our application actually does. Head on over to the src/Application.kt file of your project and the following lines of code to your Application.module function:

    routing {
        get("/") {
            call.respondText("Hello, World!")
        }
    }

Make sure to add any imports that are needed. Your final Application.kt file should look something like this (apart from the package name):

package com.gentlekotlin.helloworldktor // This package name should be different for you!

import io.ktor.application.*
import io.ktor.response.*
import io.ktor.routing.*

fun main(args: Array<String>): Unit = io.ktor.server.netty.EngineMain.main(args)

@Suppress("unused") // Referenced in application.conf
@kotlin.jvm.JvmOverloads
fun Application.module(testing: Boolean = false) {
    routing {
        get("/") {
            call.respondText("Hello, World!")
        }
    }
}

Now, when you restart your application and visit the same http://0.0.0.0:8080 url, you should see a text saying “Hello, World!” You can find the code generated and shown in this guide over at this repository.

Launch, Join, And Hundreds of Thousands of Jobs

2020-04-01T00:00:00+00:00

In the previous post I mentioned that coroutines were like lightweight threads, but lets get an idea of how many different concurrent jobs can coroutines handle.

`launch`

We start a coroutine with the launch lambda function. Here’s a simple example:

println("Start")

// Start a coroutine
GlobalScope.launch {
    delay(1000)
    val x = 2*6
    println(x)
}

Thread.sleep(2000) // wait for 2 seconds
println("Stop")

`join`

Intro to Coroutines

2020-03-31T00:00:00+00:00

One of Kotlin’s biggest strengths is a very easy and neat way to write programs that can make use of concurrency using coroutines. This allows for a way of running different pieces of code at once and avoid wasting time waiting during programs.

If you’ve heard of threads before coroutines are a much more lightweight version of that where hundreds of thousands of coroutines can run for each thread. Similar to the programming language Go with it’s goroutines this is also based off the CSP model.

This is often quite intimidating, and other programming languages often have very weird and complex syntax to perform this kind of programming. Lots of it feels quite out of reach for beginners. Luckily for us Kotlin actually makes things quite nice for us and this is one of the strongest strengths of the language.

Many languages require you to change quite a few things in your code to make it work asynchronously, but Kotlin tries to keep the code as unchanged as possible except a few word changes here or there.

Let’s take a normal looking program and see how to quickly convert to an asynchronous coroutine based program. Load two users and print out their details.

fun main() {
  val first =  getUser(1)
  val second = getUser(2)
  println("Hello $first")   // Hello Amirtha
  println("Hello $second")  // Hello Astha
}

fun getUser(id: Int): String? {
  val users = listOf("Harsh", "Amirtha", "Astha")
  Thread.sleep(200) // simulated load time
  return users.elementAtOrNull(id);
}

The issue here is that while loading and showing both the users are independent, we have to wait one after another to finish. But the time awaiting is just waiting for the response while the system sits idle. And this problem gets worse if it’s not just two tasks like this, but hundreds or thousands.

The idea is that we can make use of this idle time using suspendable functions. The idea is that functions can be suspended and then resumed, so while it’s waiting another function can take over and do it’s thing. Then we just have to indicate by when we really need the result. Here is a coroutine version of the same.

import kotlinx.coroutines.*

fun main() = runBlocking {
  val deferredFirst =  async { getUser(1) }
  val deferredSecond = async { getUser(2) }
  println("Hello ${deferredFirst.await()}")   // Hello Amirtha
  println("Hello ${deferredSecond.await()}")  // Hello Astha
}

suspend fun getUser(id: Int): String? {
  val users = listOf("Harsh", "Amirtha", "Astha")
  delay(200) // simulated load time
  return users.elementAtOrNull(id);
}

Import kotlin coroutines

Much like using the math package, we have to import coroutines since they aren’t always used by most common programs. All we have to add to the top of the script

import kotlinx.coroutines.*

which imports everything coroutine related. In practice you may want to be more precise with imports but for learning coroutines it’s good enough.

The suspend keyword

To make a function work with coroutines all we need to do is add the suspend keyword right in front of it. So suspend before getUser() now made it a suspendable function.

Sleep vs delay

Thread.sleep() is blocking, that means it doesn’t allow anything else to happen while running, this is not what we want and we won’t be able to make use of the suspending function logic. Instead we replace it with delay() which is non blocking so suspendable functions can take advantage of this and do tasks concurrently.

Async and await

async basically lets us say, hey start this code given as a coroutine and keep track of the value it will be eventaully return. And when we use await() we can get that value when we need it.

If you try checking out what you get from the result of async itself you get DeferredCoroutine which is basically a represenation of the differed result of the coroutine.

runBlocking

Functions that use suspendable functions must also be suspendable, but this poses a problem where we have to make every single function of our program suspendable and in most cases that’s simply not feasible.

What runBlocking allows us to do is run coroutines in ‘normal’ blocking contexts. So like in a main function or anywhere in the code. This way we can program just as normal and then use coroutine based code where we need it. Of course, the more and more coroutine based code we write can give us performance but sometimes it does add complexity.

See More

Your first Coroutine with Kotlin
Composing suspendable functions
A gentle introduction to Kotlin Coroutines video and slides
Why I stopped using Coroutines in Kotlin
Forget RxJava: Kotlin Coroutines are all you need. Part 1 and Part2 - Channels
kotlinx.coroutines guide - This one is very long but comprehensive

Generics

2020-01-25T00:00:00+00:00

What are Generics?

Up until now, we’ve described functions and classes to hold specific types; for example, we can create a list of Ints or an

Functions

Classes

Why We Use Generics

Real-World Examples

Inheritance

2020-01-16T00:00:00+00:00

After a while you start to notice how a lot of classes start having really similar boilerplate and standard code. What Inheritance does is it lets us extend classes from a Base and then add on only the stuff we need. That way we can put the common stuff in the base class itself.

Consider making a simple setup for a teacher and their group of a students.

class Student(val name: String,
              var age: Int,
              var mathScore: Double,
              var scienceScore: Double) {
    fun display() {
        println("Name: $name")
        println("Age: $age")
        println("Math score: $mathScore")
        println("Science score: $scienceScore")
    }
}

class Teacher(val name: String,
              var age: Int,
              var students: Collection<Student>) {
    fun display() {
        println("Name: $name")
        println("Age: $age")
        println("Number of students: ${students.size}")
    }
}

fun main() {
    val me = Student("Harsh", 20, 98.5, 95.3)
    me.display()
    val geoff = Teacher("Geoffery Challen", 4000, listOf(me)) 
    geoff.display()
}

If we look above both classes have a lot of common data and functionality. One very important principle of programming is DRY (Don’t Repeat Yourself) so we can use inheritance. How it works is creating a base class that other classes can use as a starting point for adding more data and functionality. This leads to nicer design, fewer bugs and shorter programs when used well.

Identify common data and functionality

name, age are common for both classes so we can extract that.

In terms of functionality the first two lines of dispay() are the same so we can extract that as well.

New Base Class

open class Person(val name: String,
                  var age: Int,) {
    open fun display() {
        println("Name: $name")
        println("Age: $age")
    }
}

By default, Kotlin classes are set up that no classes can be derived from it so we have to add the open keyword. Adding open in front of the class makes it clear that the class can have other classes inherit from it. Making our open class Person sets up the base class we’re going to have as a starting point for Student and Teacher.

Adding open before a function lets derived classes create a new function with the same name. Otherwise you will have to create new functions in your derived classes. Our open fun display() will be overriden by both Student and Teacher since they do display slightly differently.

Derived Classes

class Student(name: String,
              age: Int,
              val mathScore: Double,
              val scienceScore: Double): Person(name, age) {
    override fun display() {
        super.display()
        println("Math Score: $mathScore")
        println("Science Score: $scienceScore")
    }
}

class Teacher(name: String,
              age: Int,
              var students: Collection<Student>): Person(name, age) {
    override fun display() {
        super.display()
        println("Number of students: ${students.size}")
    }
}

To indicate a class is derived we have to indicate in the class header itself and if there is a constructor we have to pass the right variables along as well. This is what : Person(name, age) does in our example by indicating that these class derives from Person and (name, age) are passed to the base class constructor.

override indicates that we are overriding a function from the base class and using super.functionName() lets us call the existing display function from the base class. In general the super keyword lets us access things specific to the base class that isn’t always there in derived classes.

Output

If you did everything right, the output and behavior of the program should be the same.

fun main() {
    val me = Student("Harsh", 20, 98.5, 95.3)
    me.display()
    val geoff = Teacher("Geoffery Challen", 4000, listOf(me)) 
    geoff.display()
}

which gives

Name: Harsh
Age: 20
Math Score: 98.5
Science Score: 95.3
Name: Geoffery Challen
Age: 4000
Number of students: 1

See More

Classes and Inheritance - Official Docs
Kotlin Delegation Pattern - Baeldung - An interesting alternative to look into
Kotlin Sealed Classes - Baeldung - When you want to restrict inheritance to only a few subtypes

Data classes

2020-01-15T00:00:00+00:00

A new thing Kotlin introduces over many other languages like Java is the data class. In Java (and many other languages) we often make a class with

getters - read data
setters - change the value of data
toString() - convert the object to a string
toHashCode() - get a numeric unique value representing the object
equals() - check if two objects are equal
copy() - copy objects

This is often 20-30 lines of template code added to the start of almost every class and often copy pasted or generated by an IDE. Long and similar looking repetitive code can often lead to bugs so Kotlin offers a way of avoiding the problem entirely by just adding one word data before the start of a class.

data class Hero(val name: String, val type: String, var healthPoints: Int) {
    [...]
}

Just adding that lets us do a lot.

Creating Objects

Creating objects is the same as normally dealing with classes in Kotlin.

The generated toString() gives a pretty good default print that is useful for debugging.

val hero1 = Hero("Harsh", "Mage", 100)
println(hero1) // get a nice print
// => Hero(name=Harsh, type=Mage, healthPoints=100)

Getters and Setters

You can access variables via the dot .variableName notation. To set things you use the .variableName = syntax.

println(hero1.healthPoints) // get values
// => 100
hero1.healthPoints = 80 // set values (var only)
println(hero1) 
// => Hero(name=Harsh, type=Mage, healthPoints=80)

Equality

Kotlin sets up things nicely that == works for comparing object’s values.

val hero2 = Hero("Amirtha", "Warrior", 100)
println(hero1 == hero2) // => false
val hero3 = Hero("Harsh", "Mage", 80)
println(hero1 == hero3) // => true

In a lot of other languages == will only compare the reference of the object, that is if they’re the same in memory but not by values. Often that’s not what we really want because that just means checking two variables are the same, so in Java you’d have to create an equals() function to actually compare the object’s values.

Destructure

Using comma seperated multiple declaration we can extract variables out of an object very easily.

val (name, type, hp) = hero2
println(name) // => Amirtha

Copy

Kotlin also makes it really nice to copy over variables and even change a few values.

val mageVarshini = hero2.copy(type = "Mage")
println(mageVarshini)
// => Hero(name=Varshini, type=Mage, healthPoints=100)

See More

Classes and Objects

2020-01-14T00:00:00+00:00

Classes are perhaps the most defining feature of Kotlin, allowing us to create custom data types with specific data and behaviour. This feature of languages is what sets up the category of programming languages called Object-Oriented Programming languages which include some of the most popular languages today like Java, Ruby, Python, C++, Swift, C#, Rust etc.

Quite simply, with classes you create a container where you can define specific variables that stores information and create specfic functions that can create custom behavior.

Data Container

The first thing we can understand about classes as a grouping of data under a common name.

In this case we have made an RPG like class called Hero which has three properties

name of the Hero which is a String since players can use any number of characters to define their name
type of the Hero that is game specific roles that could have different custom behaviour like Mage or Warrior
healthPoints of the Hero which is an Int which represents how alive the character is and having it go too low can end the game.

In each case you have to consider how to use classes based on your specific code design and what can be composed of what. There are often many different ways to do it so don’t worry if you see lots of the same approaches to different problems.

Basic class syntax

So all we’re doing is creating a more complex data type out of existing data types we know. For this we use the class keyword and curly {} brackets all the variables it holds. Here I give some default values for each of the three variables.

class Hero {
    var name: String = "Harsh"
    var type: String = "Mage"
    var healthPoints: Int = 120
}

Here I setup the Hero class with the three variables and sample values. Now when I want to use this new data type in my code is declare it like any other variable. Every time you make a variable that is of a particular type, we call it an object of that class. Below is an object of the type Hero that we refer to as harsh in the code.

val harsh: Hero = Hero()

// Getting
println(harsh.type)
// => Mage
println(harsh.healthPoints)
// => 120

// Setting
harsh.healthPoints = 70
println(harsh.healthPoints)
// => 70

Using variable_name.property can let me access the inner variables that make up the class. You can print it, use it in some computation and use the = as if you’d change any other variable.

Constructor

Let’s make another object and then set the fields we want.

val varshini = Hero()
varshini.type = "Warrior" 
varshini.name = "Varshini"

Now you start to see how this can quickly get annoying. Every time you make a new object you have to setup each field with .variableName =. For large classes this can take a lot of space and this adds clutter. This also results in making everything var that we want custom but it will be better if we can set some properties to be assignable once.

For this we can use constructors. Constructors are like special functions that are run when an object is first created. All you have to do is add a list of parameters in () round brackets and then use it to set up your variables. Make sure they’re called something different than the variables in your class. Thanks to constructors we were able to make name and type into val which we were not able to do earlier.

class Hero(setName: String, setType: String) {
    val name: String = setName
    val type = setType
    var healthPoints = 120
}

And declaring a new object becomes nicer too

val varshini = Hero("Varshini", "Warrior")

Creating an object with name "Varshini", type "Warrior" and healthpoints 120 a default value.

Constructor short hand

Even that sytnax can get quite repetitive. That’s why kotlin has made a simple shorthand for the most common case with constructors. If you add var or val before the variables it’ll create the same constructor for you automatically. Using = we can set default values as well which is most common reason we often have many constructors too.

class Hero(val name: String, val type: String, var healthPoints: Int = 120) 

And the earlier declaration code works unchanged.

val varshini = Hero("Varshini", "Warrior")

Adding functions

Inside the class body {} you can add functions that are only avaible to objects that belong to the class. This is how we create specialized behavior for classes. Functions inside a class can access that object’s variables just by mentioning it by name.

class Hero(val name: String, val type: String, var healthPoints: Int = 120) {
    fun attacked(damage: Int) {
        healthPoints -= damage
        println("Oh no! $name got attacked with $damage with $healthPoints hp left")
    }

    fun healed(hp: Int) {
        healthPoints += hp
        println("Yay! $name got healed with $hp with $healthPoints hp now")
    }
}

As you can see above that the syntax for functions is the same but we can access properties of the object as well. To use these functions we use the same . dot notation like object.functionName(...)

val varshini = Hero("Varshini", "Warrior")
varshini.attacked(50) // Oh no
// => Oh no! Varshini got attacked with 50 with 70 hp left
varshini.healed(70)   // yay
// => Yay! Varshini got healed with 70 with 140 hp now

Calling functions on other objects

Our functions can also work on other objects of the same kind. This is useful because we want objects to interact with each other. Here we can set up functions that take Hero objects and call actions on them.

class Hero(val name: String, val type: String, var healthPoints: Int = 120) {
    fun attacked(damage: Int) {
        healthPoints -= damage
        println("Oh no! $name got attacked with $damage with $healthPoints hp left")
    }

    fun healed(hp: Int) {
        healthPoints += hp
        println("Yay! $name got healed with $hp with $healthPoints hp now")
    }
    
    fun attack(anotherPlayer: Hero) {
        println("$name attacks ${anotherPlayer.name}")
        val damage = if (type == "Warrior") 50 else 30
        anotherPlayer.attacked(damage)
    }

    fun heal(anotherPlayer: Hero) {
        println("$name casts heal on ${anotherPlayer.name}")
        val hp = if (type == "Mage") 40 else 10
        anotherPlayer.healed(hp)
    }
}

Look at the two new functions, attack and heal, they both act differently based on the type of the Hero and use the . dot notation to call things from other classes.

fun main() {
    val harsh: Hero = Hero("Harsh", "Mage", 100)
    val varshini = Hero("Varshini", "Warrior")
    varshini.attack(harsh)
    println()

    println("Ooops, let me heal you")
    varshini.heal(harsh)
    println()

    println("You aren't a mage so it wasn't that useful")
    println("I'll do it myself")
    harsh.heal(harsh)
}

which outputs

Varshini attacks Harsh
Oh no! Harsh got attacked with 50 with 50 hp left

Ooops, let me heal you
Varshini casts heal on Harsh
Yay! Harsh got healed with 10 with 60 hp now

You aren't a mage so it wasn't that useful
I'll do it myself
Harsh casts heal on Harsh
Yay! Harsh got healed with 40 with 100 hp now

See More

Lambdas and Higher Order Functions

2020-01-13T00:00:00+00:00

Lambda Functions

What are Lambda Functions?

Lambdas are an interesting way to write and declare functions; we’ve seen functions written formally up to this point, involving the fun keyword and explicit types. Lambda functions are functions that aren’t declared but passed immediately as an expression.

Syntax

fun main() {
  val firstLambda = { println("This is a lambda expression!") }
  firstLambda() // prints out "This is a lambda expression!"
}

Let’s look at firstLambda. It doesn’t take any arguments or return anything, and runs a single print statement. What happens when we want to write something that takes arguments or returns them? Here’s how:

fun main() {
  val andOperator: (Boolean, Boolean) -> Boolean = { a, b -> a && b }
  val first = true
  val second = false
  println(andOperator(first, second)) // prints false
}

So lambda functions typically have this format: val lambda_name: (Arg Types) -> Return Type = { Args -> code_body }.

We don’t always need to list out types. The Kotlin compiler assumes types when it’s not given any explicit ones, so we can omit them if they’re not necessary.

fun main() {
  val basicSum = { a: Int, b: Int -> a + b }
  println(basicSum(6, 9)) // prints 15
} 

However, it’s always good practice to write out argument and return types for lambdas so that your code is more readable!

The `it` keyword

In Kotlin, we can use it as the implicit name of a single parameter in a lambda function. Let’s think about the notion in this way: if we pass something to a function, what do we want the function to do with it? The it keyword also allows us to omit the -> operator, but this is all better explained with an example:

fun main() {
  val v1: (Int) -> Boolean = { x -> x > 0 }
  val v2: (Int) -> Boolean  = { it > 0 }
  println(v1(5)) // prints true
  println(v2(5)) // prints true
}

As you can see, we didn’t explicitly state how many arguments are passed into the lambda v2; instead, using it allows the Kotlin compiler to assume that only one argument is passed into the function.

Why Lambas

Lambdas are really convenient because they allow you to write essential code logic without formally declaring them and adding unnecessary lines of code to your project. They can act as sort of “throw-away functions,” meaning that once you’re outside of its scope, you never have to look back.

While the syntax is a bit different from typical first-class functions as you’ve seen up until now, a little bit of practice can lead to feeling more comfortable writing and using them. They are especially handy in functional programming!

Higher-Order Functions

What are Higher-Order Functions?

A higher-order function is one that can take a function as an argument and/or return a function. We can pass in and/or return lambdas, as well as other Kotlin first-class functions by explicitly stating the type. Let’s look at an example.

Built-In Functions

Kotlin provides some really useful higher-order functions, like map and filter. These functions allow us to evaluate collections in one single line of code without writing an entire foreach loop!

`filter`

fun main() {
  var numList = listOf(1, 2, 3, 4, 5)
  println(numList.filter { it > 3 } ) // prints [4, 5]

The filter function returns every value in the list that satisfies the boolean condition passed in. In this case, filter only considers values greater than 3, so it returns a list containing 4 and 5. filter is really useful because it allows us to access every element in a list without any modification, and does so in one line of code.

`map`

fun main() {
  var numList = listOf(1, 2, 3, 4, 5)
  println(numList.map { it * 3 } ) // prints [3, 6, 9, 12, 15]

map returns a list of the output values from the original list based on the code body passed into the lambda. In our case, we multiplied every value in the list by 3 and built a new list from these new values. map, like filter, is really useful in that it doesn’t modify the original list and does what a for loop would do in one line of code.

`fold`

fun main() {
  val numList = listOf(1, 2, 3, 4, 5)
  println(numList.fold(10) { max, item -> if (item > max) item else max }) // prints 10
}

The syntax for fold requires a bit more explanation. It takes a single argument, and in this situation, we use it as a default value. Typically, fold is used as an accumulator; for example, we can take fold, iterate it through a list, and have it accumulate every value into a sum. In this bit of code, however, we store a current maximum value in it as we iterate through the list. fold compares 10 to the current max in the list and stores whichever value is bigger at every comparison. Since 10 beats every element in our list, it will return 10 as the default value. If we want to find the maximum value without using a default, we can call reduce.

fun main() {
  val numList = listOf(1, 2, 3, 4, 5)
  println(numList.reduce() { max, item -> if (item > max) item else max }) // prints 10
}

Writing Our Own Functions

var lambdaFunc: () -> Unit = { println("Hello Kotlin") }
fun highOrdFunc( lambda: () -> Unit ) {
  lambda()
}

fun main() {
  highOrdFunc(lambdaFunc)
} 

Let’s review this code. The first line defines a lambda function, which we call in the main method. The second function we declared is a higher-order function, and we know this not just because of the obvious naming, but we can see that the function takes in a lambda. Remember, first-order functions take in only variables.

In the higher-order function we run the lambda. Then, in the main method, we call highOrdFunc, which calls lambdaFunc, which prints out “Hello Kotlin!” to the console.

Here’s an example of a more useful higher-order function that functions as a sort of map mimicker.

fun mapper(size: Int, fn: (Int) -> Int):List<Int> {
  var x = 1
  var list = mutableListOf<Int>()
  while (x <= size) {
  	list.add(fn(x))
    x++
  }
  
  return list
}

fun main() {
  println(mapper(3) {it * it}) // prints [1, 4, 9]
  println(mapper(6) {it + 2}) // prints [3, 4, 5, 6, 7, 8]
} 

It takes in a size for a list and builds a list based on a function that performs a computation for every value from 1 to size.

Why Higher-Order Functions

Higher-order functions are most popular with functional programming. They allow for cleaner, crisper code and provide a succint way to utilize functions and work with really big data structures! With these functions we can abstract our logic even further to be more widely applicable; this is especially important for building large models and structures with the code we write.

See More

Collections and Arrays

2020-01-05T00:00:00+00:00

Arrays

An array is a container that stores multiple items of the same type; for this reason, Kotlin has primitive type arrays such as IntArray, BooleanArray, etc. Here’s an example of an IntArray:

var array: IntArray = intArrayOf(1, 2, 3, 4, 5)
println(array[3]) // prints 4
array[0] = array[1] + array[2]
println(array[0]) // prints 5
println(array.size) // prints 5

We access the items in an array with indexing, a sort of numbering system. In real life, we use 1-based indexing, meaning that the first item is at index 1. In programming, however, we use 0-based indexing, so the first element is actually at index 0; similarly, the last element is at index array.size - 1. To access an item in the array, we use the [] operator, which takes an Int as the index we want to look at. In line 2, we printed out the value in the array at index 3, which is actually the 4th value listed in the array in 1-based indexing.

Since this array is a var, we can also modify the items at any index, as we did in line 3! We took the sum of values at array[1] and array[2], which is 5, and passed it into array[0]. So, before that line, we had 1 at the 0th index of the array, but now we’ve replaced 1 with 5. The array actually now reads as [5, 2, 3, 4, 5].

We can also initialize an array by giving it a size without assigning values; when we do so, the Kotlin compiler will create an array of the size you gave and fill every spot in that array with the default value of the array’s type. This is better explained with an example:

val array = IntArray(5)
// this is an array with values: [0, 0, 0, 0, 0]

Creating a String array is a bit different; even though we use Strings like they’re a primitive type, Strings are, in fact, NOT a primitive type. In the above example we used the intArrayOf function to initialize an array of Ints; with Strings, we can use the arrayOf<String> function:

var stringArray = arrayOf<String>("hello", "world", "Kotlin")
println(stringArray[2]) // prints "Kotlin"

var emptyStrArr = arrayOf<String>(3)
// array of empty Strings: ["", "", ""]

One key thing to note about arrays is that their size is fixed at initialization; we can modify the items and access them at any given valid index (0 to size - 1), but we can’t change the size itself, i.e. add or remove items. With collections, if we’ve specified that we can modify them, we can add and remove elements as we please.

A Real-World Example of Collections

Say we’re building an application that takes a picture of food and gives you recipes that use those ingredients. While this sounds very complex, the first step would be to figure out how to store these food items in our program. We can do so with something called collections.

A collection is just a container that stores a number of objects. Collections are similar to arrays, in that the objects they store have to share the same type, so we can’t have a collection of Ints, Doubles, and Booleans. With collections, however, we can change the size of the collection to store more objects (conventionally called elements or items)..

How we use this collection depends on what type of collection we construct. Kotlin provides different kinds of collections that are friendlier to use for different reasons; as such, depending on how you want to store and use objects, you might use a certain type of collection.

Mutable and Immutable Collections

Immutable

Before we go into the different types, we need to talk about the difference between immutable and mutable collections. We mentioned the concept of immutability when we introduced Kotlin values; in that context, we talked about how values are just variables that can’t be changed over time. The same applies with collections! Once we construct a collection, meaning we add objects to it at the same time we declare it, we can’t modify it anymore. We call immutable collections as read-only collections, which just means that we can read through, or access, its items, without modifying the collection itself.

Mutable

Mutable collections are just the opposite. We can remove and add things anytime. Both mutable and immutable collections are useful for different applications, and we’ll give some examples we talk about the different types of collections.

Types of Collections

Lists

Lists are a type of collection that stores items in a specified order and uses indexing to access those item. Remember, indexing is just a way to access an element in a container using numbering; we use 0-based indexing, which means that the 1st element is in the 0th index, the 2nd element is in the 1st index, etc. At first glance, they might seem really similar to arrays; they use similar operators to access and modify within it, but lists and arrays start to differ when we make a list mutable.

Here’s an example of an immutable list:

val immutableList = listOf(2, 4, 6, 8, 10)
println(immutableList[0]) // prints 2
immutableList[0] = 12 // compile error!

Since we used the keyword ‘val,’ this list is immutable. Remember, vals are immutable variables; as such, we can’t delete or add anything to the list. We also can’t modify any of the list’s elements, which is why the third line will not compile.

Here’s an example of a mutable list:

var mutableList = listOf(2, 4, 6, 8, 10)
mutableList[0] = 0 // now the list is 0, 4, 6, 8, 10
mutableList.removeAt(0) // now the list is 4, 6, 8, 10

Adding and Removing Elements

From the examples above, you can see that lists have built-in add and remove functions! removeAt takes only one argument: the index of the element to be removed. In line 3 of the immutable example, we remove at the 0th index, or the 1st element in the list. The add function takes an element and adds that element to the end of the list by default. Here’s an example:

var mutableList = listOf(2, 4, 6, 8, 10)
mutableList.add(12)
println(mutableList) // prints [2, 4, 6, 8, 10, 12]

To see more documentation on lists in Kotlin, check out the official Kotlin site. It goes more in detail with the add and remove functions, as well as similar built-in functions that come in handy with lists.

Iterating through the Elments

Lists are really useful for storing objects and accessing them through something known as a foreach loop. It’s called a loop because the code block we write for it repeats itself for EVERY item in the list. Let’s start with a basic example:

var numbers = listOf(1, 2, 3, 4, 5)
for (item in numbers) {
  print("$item ")
}

The console prints out the following:

1 2 3 4 5

Since our for loop only has line of code run for each item in the list, we can actually write the for loop as a single line of code, as opposed to a curly bracket-enclosed block:

for (item in numbers) print("$item ")

We can’t modify the items in a foreach loop, we can access them and read their attributes. In this case, we access every item and just print them, but we can make foreach loops to do a variety of things with just a bit of conditional logic. We can also access the index of every element by looping through the indices. The syntax looks like the following:

var chars = listOf('a', 'b', 'c', 'd')
for (i in chars.indices) {
  print(chars[i] + " ")
}

When run, the code above prints out the following on the console:

0 1 2 3

Maps

A map is a collection of keys that point to values, stored as key-value entries. A key can be of any type, as can a value. For example, let’s say we’re storing companies in our program and need a way to easily look up their annual revenues; we can create a map that stores Strings as keys that point to Int values. Each key is the name of the company and points to an Int that represents that company’s value. With this set up, all it takes is the company’s name and the computer will automatically return to us the revenue we’re looking for!

var studentGrades = mapOf("Alice" to 96.7, "Greg" to 90.1, "Jessica" to 89.7)
studentGrades.put("Max", 94.3)
studentGrades["Alice"] = 97.0

Map<K,V> has a built-in put function that allows us to add key-value pairs to mutable maps. It takes a key and a value, in that order. If a map is mutable, we can also modify a key’s value by using the [] operator.

While lists allow us to keep track of objects by numerical indexing, maps give us a more convenient way to model real-life data into our Kotlin programs.

How We Use Collections

Lists

Unlike maps, lists can contain duplicate entries. A list functions like a list; we can read from top to bottom using numerical indexing, and add and remove things. The order doesn’t matter unless the list is sorted, so finding a value without knowing its index can mean looking through the entire list.

Maps

Maps can’t have duplicate keys, which makes values less complicated to find. With a list, we have to start from either the top or the bottom from the list and work our way through the entire list to find our value. With maps, if we know the key, we can find the value in one line of code!

See More

Loops

2020-01-05T00:00:00+00:00

Why Loops?

Loops are an essential and beginner-friendly aspect of iteration in programming. To iterate means to repeat a process until an outcome is produced. So when do we use iteration in programming, besides in foreach loops for collections?

While Loops

While loops have 2 fundamental pieces: a statement with a Boolean value and a block of code to be executed. We give a while loop to evaluate this conditional statement, and while the statement is FALSE, the loop will run everything we wrote in the block of code underneath. The set up looks like this:

var condition: Boolean = true
while (condition == true) {
  // do stuff
  // eventually condition should change to false
}

Once the statement we’ve given the while loop is false in value, the loop stops itself. In this case, condition == true will evaluate to FALSE when the condition we created earlier isn’t true. Keep in mind that a loop can run infinitely if we write it poorly, so make sure that your condition is manipulated in some way in your for loop to ensure that it will end eventually.

Here’s a good example of a while loop to start with:

var incrementer: Int = 0
while (incrementer < 10) {
  print("$incrementer ")
  incrementer++ // same as incrementer = incrementer + 1
}

We create a variable called incrementer and initialize it to 0. Next, we run a while loop that checks if the incrementer is less than 10 repetitively. While it is less than 10, the block underneath increments incrementer until it equals 10. The following prints out to the console as a result:

0 1 2 3 4 5 6 7 8 9

do...while loops work in the same way, except the block of code is run before the statement is evaluated.

var incrementer: Int = 0
do {
  print("$incrementer ")
  incrementer++
} while (incrementer < 10)

The console will print the same output in this case.

For with Range

To iterate over a range of values, we can use a for loop using the in function. Here’s an example:

for (i in 0..5) println(i)

This prints out the following:

The range is INCLUSIVE, which means that i starts at 0 and ends at 5.

To iterate backwards, we add on the downTo keyword:

for (i in 3 downTo 1 step 1) print("$i ")

The console prints out 3 2 1 as a result. The step keyword indicates the amount incremented or decremented every time. We can modify the step value as well:

for (i in 10 downTo 1 step 2) print("$i ")

This will print 10 8 6 4 2 to the console.

See More

Control Flow - Official Docs
Loops - CS 199 IKP
Loops - Baeldung
Nested for Each in Kotlin - Baeldung - This one covers some really good best practices and how we can use flatMap to deal with many situations with nested loops.

Gentle Kotlin

Web Services with Kotlin using Ktor (Installation)

Installation using Gradle from Scratch

Installation using Gradle from Ktor Starter (Recommended)

Launch, Join, And Hundreds of Thousands of Jobs

launch

join

Intro to Coroutines

Import kotlin coroutines

The suspend keyword

Sleep vs delay

Async and await

runBlocking

See More

Generics

What are Generics?

Functions

Classes

Why We Use Generics

Real-World Examples

See also

Inheritance

Identify common data and functionality

New Base Class

Derived Classes

Output

See More

Data classes

Creating Objects

Getters and Setters

Equality

Destructure

Copy

See More

Classes and Objects

Data Container

Basic class syntax

Constructor

Constructor short hand

Adding functions

Calling functions on other objects

See More

Lambdas and Higher Order Functions

Lambda Functions

What are Lambda Functions?

Syntax

The it keyword

Why Lambas

Higher-Order Functions

What are Higher-Order Functions?

Built-In Functions

filter

map

fold

Writing Our Own Functions

Why Higher-Order Functions

See More

Collections and Arrays

Arrays

A Real-World Example of Collections

Mutable and Immutable Collections

Immutable

Mutable

Types of Collections

Lists

Adding and Removing Elements

Iterating through the Elments

Maps

How We Use Collections

Lists

Maps

See More

Loops

Why Loops?

While Loops

For with Range

See More

`launch`

`join`

The `it` keyword

`filter`

`map`

`fold`