How to learn Kotlin: A guide for beginners & Android developers
Tags: kotlin, android, programming, beginners
Published: 2023-04-19 17:29:22

Kotlin is quickly joining the ranks of the most popular programming languages. Now that Google supports Kotlin for [Android app development](https://www.educative.io/blog/how-to-develop-an-android-app?eid=5082902844932096) as the primary choice over Java, we’ll only see more developers making the switch. The job market for Kotlin developers has skyrocketed across the board. In addition to mobile development, it can be used for virtually anything, including web applications and embedded devices.

In this post, we'll take a look at the following:
* [What is Kotlin?](#what)
* [How is Kotlin used?](#use)
* [Why you should learn Kotlin](#why)
* [Why developers prefer Kotlin for Android development](#benefits)
* [Java vs. Kotlin](#vs-java)
* [Introduction to Kotlin language and syntax](#syntax)
* [What to learn next?](#next)

By the end of this post, you'll have an understanding of the benefits of Kotlin, and you'll be ready to write your own simple scripts and applications.

<br>
 
<a name="what"></a>

## What is Kotlin?
Kotlin is an open-source, statically typed programming language. It can transpile to Java bytecode to run on the Java Virtual Machine (JVM) or Android. Interestingly, it can also transpile to JavaScript code or native bytecode, allowing you to use it for many different use cases.

Kotlin is developed by JetBrains, the company behind the IntelliJ IDEA and other development tools. They designed Kotlin to be 100% interoperable with Java, meaning that you can use any Java libraries and frameworks in Kotlin, and vice versa.

<br>
 
<a name="use"></a>

## How is Kotlin used?
Currently, it’s most prominent for Android application development. However, its usage for developing server-side applications for the JVM is increasing.

Additionally, it can be used to write web applications by transpiling to JavaScript. Kotlin then lets you use popular libraries and frameworks such as [React](https://www.educative.io/blog/what-is-react-tutorial?eid=5082902844932096) and [VueJS](https://www.educative.io/blog/vue-js-tutorial?eid=5082902844932096).

It’s useful to know about the corresponding sub-projects in case you encounter them:
* **Kotlin/JVM:** lets you write JVM applications by transpiling to Java bytecode (e.g., Android development, Spring services, desktop applications)
* **Kotlin/JS:** lets you write web applications by transpiling to JavaScript (e.g., React apps, and Vanilla JS apps)
* **Kotlin/Native:** lets you write applications for any target platform such as embedded devices or iOS (e.g., iOS apps, microcontroller programming)

As a side note, Kotlin supports multi-platform application development, which enables you to share code between apps for different platforms. **The most obvious use case is to share core functionality between your Kotlin Android app and your Kotlin iOS app.**

<br>
 
<a name="why"></a>

## Why should you learn Kotlin?

Learning Kotlin can teach you a lot about language design and some of the shortcomings of Java that you may not have been aware of previously. Therefore, it can be a great way to learn about modern programming language features that you will encounter in other languages as well, such as [TypeScript](https://www.educative.io/blog/typescript-tutorial?eid=5082902844932096), [Scala](https://www.educative.io/blog/scala-101-a-beginners-guide?eid=5082902844932096), Go or Rust.

Apart from this, there are many companies actively looking for Kotlin developers, especially in the Android development space. So having experience in Kotlin can give you an edge in the interview process.

But even without the goal of landing a Kotlin developer job, learning the language and its concepts will allow you to quickly master other modern languages such as [TypeScript](https://www.educative.io/blog/typescript-tutorial?eid=5082902844932096), [Scala](https://www.educative.io/blog/scala-101-a-beginners-guide?eid=5082902844932096), and Swift because they share many language concepts.

<br>
 
<a name="benefits"></a>

## Why developers prefer Kotlin for Android development
In 2019, Google announced that the Kotlin programming language is now its preferred language for Android app development, as opposed to Java. For a lot of developers, this is a breath of fresh air. Java, for all its strengths, has its share of detractors as well. So, here are a few reasons why developers are making the switch to Kotlin.

### 100% interoperability with Java
Kotlin and Java are 100% interoperable, meaning you can have any percentage of code written in Kotlin, and the rest in Java, and it will all work together. So you don't have to worry about how it will affect your legacy code.

Additionally, there is a tool in Android Studio that allows you to instantly “translate” Java into Kotlin.

<br>

### Boilerplate code
In Kotlin, you can accomplish the same task with fewer lines of code. Just take a look at this click listener example:

**Java:**

```java
view.setOnClickListener(new View.OnClickListener() {
     @Override
     public void onClick(View v) {
         // Do whatever you want to
}});
```

**Kotlin:**

```kotlin
view.setOnClickListener { // Do whatever you want to }
```

<br>

### There is no NullPointerException

With Kotlin, you needn't worry about NPEs because null safety is built into Kotlin's type system. This way you can catch NPEs at compile time instead of at runtime.



<br>

### Great IDE and Tooling support
Kotlin has great support because it's backed by JetBrains, a company that specializes in creating some of the most used IDEs in the world. With a strong community behind the language and tools, you'll always have support when you need it.

All of Android Studio's IDE features work perfectly in Kotlin. You can mix and match Kotlin and Java code in the same project, and everything still works. 

<br>
 
<a name="vs-java"></a>

## Java vs. Kotlin

![Java vs Kotlin](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/q2bd07d0fyj3zwvkb3uj.png)

### Size, complexity, and quality of code
While using Java, developers typically have to write more lines of code, while Kotlin enables developers to accomplish the same tasks without writing so much code, making it more expressive. 

Further, it helps developers to make code more organized, readable and reusable. So, some developers opt for Kotlin to develop a concise, readable and maintainable code base.

To help manage the quality of your code, Kotlin makes use of type inferencing, eliminating much of the frustrating and overly tedious syntax that Java developers face. Often, code written in Kotlin is more concise, but it also happens to be a little more complex for those used to programming in Java. 

<br>

### Null Safe
In Java, NullPointerException causes a lot of frustration for developers, they can even be the main reason why you would experience crashes in your app.

 However, in Kotlin, all types of variables are non-nullable by default. So if you try to assign or return null values, Kotlin will catch NPEs at compile time. 

<br>

### Coroutines support
In Java, whenever you start a long running process with CPU intensive operations, the corresponding thread will be blocked. You can create multiple threads in the background, but managing them is a complex task.

In Kotlin you can create multiple threads to run long processes, and with [coroutine](https://www.educative.io/answers/what-is-a-coroutine?eid=5082902844932096) support, it will suspend execution at a certain point without blocking threads.

<br>

### Type inference
In Java you need to specify a type of each variable when you declare it. In Kotlin, you don't need to specify the type of each variable.

<br>

### Functional programming
Java has support for [functional programming](https://www.educative.io/blog/what-is-functional-programming-python-js-java?eid=5082902844932096) but it’s only available in Java 8, whereas most Android development is done with Java 6 and 7. 

Kotlin is a mix of functional and procedural programming which consists of many useful methods such as lambdas, higher-order functions, lazy evaluation, etc. Most of these methods are not offered for Android developers in [Java 8](https://www.educative.io/blog/master-stream-api-and-beyond?eid=5082902844932096).

<br>
 
<a name="syntax"></a>

## Introduction to Kotlin language and syntax

Kotlin aims to be a readable, pragmatic, safe, and interoperable programming language:

* **Readability** is supported by language features such as type inference, data classes, and infix functions. Such features allow writing concise code without losing readability.

* **Pragmatism** is crucial because Kotlin is for large-scale enterprise software development. JetBrains use it themselves to develop their IDEs. Thus, Kotlin incorporates industry feedback and addresses issues of large-scale software development.
* **Safety** aims to prevent common software bugs by design. This is aided by several language features such as nullable types (to prevent null pointer exceptions) and by nudging you towards best practices such as designing for inheritance.

* **Interoperability with Java** is a major selling point of Kotlin and a necessary base for its widespread adoption in the JVM world. Interoperability allows Kotlin and Java to be used side by side, including the use of Java libraries or frameworks from Kotlin. 

  * For instance, the Kotlin standard library interoperates with Java by reusing the Java Collections API. Similarly, it interoperates with JavaScript in the context of Kotlin/JS.

Now that you have a basic understanding of the philosophy of the language, let's dive in and understand how to use this language.

### Read-only vs Mutable variables

Let’s start with the Kotlin basics: declaring variables. Kotlin fundamentally differentiates between read-only and mutable data.

#### Mutable variables
To declare a mutable variable, you use the `var` keyword:

```kotlin
var number = 17
println("number = $number")
 
number = 42  // var can be reassigned
println("number = $number")
```

Mutable means that the variable can be reassigned to a different value after initial assignment.

#### Read-only variables
In contrast, a read-only variable can be declared using `val` (instead of `var`):

```kotlin
val number = 17
println("number = $number")
 
number = 42  // Not allowed, throws an exception
```

Read-only means that the variable cannot be reassigned once initialized.
**You should prefer read-only variables to mutable ones whenever possible**, i.e., whenever you don’t have to change the value after initialization.

> Tip: Prefer `val` to `var` to simplify data flow and facilitate reasoning about your code.

#### Summary
Kotlin differentiates between read-only and mutable variables at declaration time, forcing you to think about the mutability of state from the start.
* `val` lets you declare read-only variables.
* `var` lets you declare mutable variables.
* Good practice is to prefer `val` over `var` whenever possible to reduce mutability and therefore facilitate understanding of the program’s state and data flow.

<br>

### Basic data types
Here, we'll take a look at integers, floating point numbers, text, and booleans.

#### Integers
There are four basic data types to store integer numbers of different sizes in Kotlin:

```kotlin
val byte: Byte = 127
val short: Short = 32767
val int: Int = 2147483647
val long: Long = 9223372036854775807
```

<br>

#### Floating Point Numbers
Additionally, Kotlin has `Float` and `Double` to store floating point numbers up to different precision and sizes:

```kotlin
val float: Float = 3.4028235e38f
val double: Double = 1.7976931348623157e308
```

**Two things to note:**
* The `e` in both values denotes exponentiation, for instance `10e3 == 1000`.
* In order to denote a `Float` value, you have to add the `f` suffix. Otherwise, Kotlin infers `Double` as the type of the number.

<br>

#### Text
Kotlin uses the `Char` type for single characters and `String` for arbitrary sequences of characters:

```kotlin
val character: Char = '#'
val text: String = "Learning about Kotlin's data types"
```

Single characters are denoted using single quotes `''`, whereas basic strings use double quotes `""`.

However, you can also use multiline strings by wrapping your string into three double quotes: `"""<multiline string here>"""`.

<br>

#### Booleans
Finally, Kotlin uses `Boolean` to store either `true` or `false`:

```kotlin
val yes: Boolean = true
val no: Boolean = false
```

<br>

#### Summary
Here’s what you should take away from this section:
* Kotlin has `Byte`, `Short`, `Int`, and `Long` as basic types for integer numbers.
* Kotlin uses `Float` and `Double` for floating point numbers. A `Float` is denoted with a trailing `f`, as in `17f`.
* Kotlin has `Char` to store single characters and `String` to store strings of text.
* Kotlin’s basic types map to Java’s primitive types when targeting the JVM (and `String` maps to `String`).

<br>

### Kotlin's type inference
Type inference is a compiler feature that allows you to omit types in your code when the compiler can infer it for you.

#### Type Inference in Kotlin
Kotlin’s compiler can infer the types of most variables, so adding the type is optional:

```kotlin
// Run the code to see the variable's types
val string = "Educative"
val int = 27
val long = 42L
val double = 2.71828
val float = 1.23f
val bool = true
```

<br>

#### Type Inference for Literals
The compiler automatically infers that the string variable must have type `String` because it’s assigned to the value `"Educative"`.

For integer values, the compiler infers `Int` by default. You can use the `L` suffix as in `42L` to transform the value into a `Long`. Similarly, the compiler infers `Double` for floating point numbers unless you add an `f` as suffix as in `1.23f`, in which case it is considered a `Float`. There’s no such shortcut suffix for `Byte` or `Short` because these aren’t used as often.

<br>

#### Type Inference for Objects 
Naturally, type inference doesn’t only work with literal values on the right-hand side. The compiler can infer types of object just as easily:

```kotlin
import java.util.*
import java.time.*
import java.io.*
 
val stringBuffer = StringBuffer("PREFIX")
val localDate = LocalDate.now()
val file = File("foo.txt")
```

<br>

#### Summary
Here are the key takeaways:
* The Kotlin compiler can infer most types.
  * Writing down the type explicitly is optional in these cases.
* You may prefer to use explicit types for clarity.
  * Especially when the right-hand side is a complex expression or function call.
* Inferred types are ubiquitous in idiomatic Kotlin code.

<br>

### Conditions with "if"
Conditions with `if` can be written as follows:

```kotlin
if (planet == "Jupiter") {
 println("Radius of Jupiter is 69,911km")
} else if (planet == "Saturn") {
 println("Radius of Saturn is 58,232km")
} else {
 println("No data for planet $planet")
}
```

Each condition is followed by a block of code in curly braces. There can be any number of else-if blocks (including zero) and up to one else-block.

> Note: In the else-block, the planet variable is included in the output string using string interpolation. To do so, you just prepend the variable with a `$`. More complex expressions must be wrapped with curly braces: `"${user.name} logged in"`.

<br>

#### Equality and Comparison Operators
Kotlin’s operators to formulate conditions are the following:

![Kotlin operators](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0cayj9784lr7m8l0366o.png)

Note that the comparison operators work on any `Comparable` by using its `compareTo` method.

> **Note for Java developers:** In Kotlin, you use `==` where you would use equals in Java and `===` where you would use Java’s `==`.

<br>

#### Logical Operators
To build up more complex conditions from primitive conditions (using the operators above), Kotlin provides the standard logical operators:

![Logical operators](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/r23my51x7upf1t0yrrny.png)

Using these, you can combine multiple primitive conditions:

```kotlin
if (planet == "Jupiter" || planet == "Saturn" || planet == "Uranus" || planet == "Neptune") {
 println("Your chosen planet has rings, typically made of rocks and ice boulders")
}
```

<br>

#### Summary
* Kotlin’s `if` conditions work the exact same way as in other languages like Java or C.
* The logical and comparison operators are also known from some other languages.
  * But in contrast to Java, Kotlin offers `==` for structural equality and `===` for referential equality checks.

<br>

### Arrays
Like lists and sets, arrays store multiple values in a linear data structure.

<br>

#### What is an Array?
An array is a basic data structure in all programming languages. It stores multiple elements by placing them consecutively in memory. This structure is represented in the following illustration:

![Arrays](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7c589wvu5r7u3un4xvxv.png)

#### What’s the Difference Between Arrays, Lists, and Sets?
Sets are easy to distinguish from both lists and arrays based on their special properties: no ordering and no duplicates.

To understand the difference between lists and arrays, we’ll have to look at the way their elements are stored and what implications this has for us as developers. While arrays store their values in one consecutive part of computer memory, list and set elements may be spread across memory. This has several implications:
* Arrays are a fixed-length data structure. This is because, after the array is initially created, the next consecutive place in memory may be taken by another value. Thus, no more consecutive values can be added to the array. Not being able to add or remove elements distinguishes them from mutable lists.
* Differences between arrays and read-only lists exists only on a lower level, i.e., in the exact API they provide, the storage structure in memory, and their resulting runtime performance.

Finally, there’s no differentiation between read-only and mutable arrays in Kotlin. Array elements can be overwritten but no elements can be added or removed, as they’re fixed in length.

![Kotlin](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ix7bco3ui46bv2vucvgg.png)

#### Creating an Array
Kotlin’s API is very consistent when it comes to helper functions so the way to create an array should look familiar:

```
val priorities = arrayOf("HIGH", "MEDIUM", "LOW")
```

The `arrayOf` function accepts any number of arguments and returns an `Array<Something>`. In the example, it returns an `Array<String>` (reads “array of string”).

<br>

#### Working with arrays
While you can’t add or remove elements from an array, you can access and manipulate all its elements using the indexed access operator:

```
val priorities = arrayOf("HIGH", "MEDIUM", "LOW")
println(priorities[1])
priorities[1] = "NORMAL"
println(priorities[1])
println(priorities.size)
```
<br>

#### Summary
Arrays are a linear data structure that store multiple values in memory sequentially.
* In contrast to sets, arrays are ordered, may contain duplicates, and store elements sequentially in memory.
* In contrast to lists, arrays are fixed-length because they store elements sequentially, and are always mutable.
* You can create arrays using `arrayOf(...)`.

<br>

### Kotlin functions
Functions separate useful chunks of code into a named entity you can reference in your code. Along with variables, they are the absolute fundamental language construct to avoid code duplication.

#### Function Signatures
A function signature defines a function’s name, inputs, and outputs. In Kotlin, it looks like this:

```
fun fibonacci(index: Int): Long
```

This signature defines a function named `fibonacci` with one input parameter named `index` of type `Int` and a return value of type `Long`. In other words, you give the function an integer and get back a `Long`. This function implements the well-known Fibonacci sequence.

<br>

#### Declaring a function
In a function declaration, both a function signature and a function body are required:

```
fun fibonacci(index: Int): Long {
 return if (index < 2) {
   1
 } else {
   fibonacci(index-2) + fibonacci(index-1)  // Calls `fibonacci` recursively
 }
}
```

The function body is a code block (thus surrounded by curly braces) and defines what the function does. The `return` keyword defines the return value of the function call.

<br>

#### Calling a function
Once you have declared a function, you can call it by passing in a value for each required input parameter:

```kotlin
val output = fibonacci(6)
println(output)
```
This function call sets the `index` parameter to `6` and runs the function with that input. For the `output` variable, the Kotlin compiler infers the type `Long` based on the function’s return type.

<br>

#### Function types
Functions have well-defined types in Kotlin. For instance, the `fibonacci` function has type `(Int) -> Long`, which means it accepts an `Int` as input and returns a `Long`. In other words, it’s “a function from Int to Long”. This concept becomes important once you get into functional programming in Kotlin.

<br>

#### Summary 
Functions are possibly the most crucial concept to understand as they are one of the main building blocks in your code. Most day-to-day programming consists of adding, splitting up, removing, and otherwise working with functions.
* Kotlin uses the `fun` keyword to introduce functions.
* A function consists of function signature and function body.
  * The signature defines a function’s name, parameters, and return type.
  * The function body defines what the function does.
* Functions in Kotlin have well-defined types that contain parameter types and return type.

<br>
 
<a name="next"></a>

## What to learn next

Now that you have some basic understanding, you can move on to more complex concepts.

If you want to get up-to-speed fast, check out Educative's [**Kotlin Crash Course for Programmers**](https://www.educative.io/courses/kotlin-crash-course-for-programmers?eid=5082902844932096). you’ll learn all the language basics including variable declarations, data types and the type system to conditions, loops, functions, and exception handling.

By the end of the course, you'll have the hands-on experience you'll need to make your own Kotlin apps.

*Happy learning!*

### Continue reading about mobile app development on Educative
* [How to develop your first an Android app with Kotlin](https://www.educative.io/blog/android-development-app-kotlin?eid=5082902844932096)
* [Android Tutorial: How to Develop an Android App](https://www.educative.io/blog/how-to-develop-an-android-app?eid=5082902844932096)
* [Flutter Tutorial: the beginner's guide to cross-platform apps](https://www.educative.io/blog/flutter-tutorial?eid=5082902844932096)

### Start a discussion
Why do you want to be an Android developer? Was this article helpful? Let us know in the comments below!