Introduction to kotlin

- modern
- pragmatic
Kotlin Programming
Language

Kotlin developers
0
750
1500
2250
3000
2016 2017 2018
156K
700K
2.2M

Timeline
… …
2017 Ofﬁcial on Android
2010 Project started
2016 Kotlin 1.0
2018 Kotlin 1.3

Pragmatic
- good tooling
- good Java
interoperability

- completion
- navigation
- refactorings
- inspections
…

can be easily mixed with
Java code

Kotlin code
Java code
You can have Java &
Kotlin code in one project

You can gradually add Kotlin to
your existing app

Modern
- concise
- safe
- expressive

public class Person { 
private final String name; 
private final int age; 
 
public Person(String name, int age) { 
this.name = name; 
this.age = age; 
} 
 
public String getName() { 
return name; 
} 
 
public int getAge() { 
return age; 
} 
}

- equals
- hashCode
- toString
 
data
 
class Person(val name: String, val age: Int)

public void updateWeather(int degrees) { 
String description; 
Colour colour; 
if (degrees < 5) { 
description = "cold"; 
colour = BLUE; 
} else if (degrees < 23) { 
description = "mild"; 
colour = ORANGE; 
} else { 
description = "hot"; 
colour = RED; 
} 
// ... 
}
enum Colour { BLUE, ORANGE, RED, /*...*/; }

fun updateWeather(degrees: Int) { 
val description: String 
val colour: Colour 
description = "cold" 
colour = BLUE 
description = "mild" 
colour = ORANGE 
} else { 
description = "hot" 
colour = RED 
} 
// ... 
}

val (description: String, colour: Colour) = 
Pair("cold", BLUE) 
Pair("mild", ORANGE) 
} else { 
Pair("hot", RED) 
}
// ... 
}

val (description, colour) = 
Pair("cold", BLUE) 
Pair("mild", ORANGE) 
} else { 
Pair("hot", RED) 
}
// ... 
}

val (description, colour) = when { 
degrees < 5 -> Pair("cold", BLUE) 
degrees < 23 -> Pair("mild", ORANGE) 
else -> Pair("hot", RED) 
}
// ... 
}

val (description, colour) = when { 
degrees < 5 -> Pair("cold", BLUE) 
degrees < 23 -> Pair("mild", ORANGE) 
else -> Pair("hot" to RED) 
}
String description; 
Colour colour;
description = "cold"; 
colour = BLUE; 
description = "mild"; 
colour = ORANGE; 
} else { 
description = "hot"; 
colour = RED; 
}

Modern approach:
to make NPE
compile-time error,
not run-time error

Nullable types in Kotlin
val s1: String = "always not null"
 
val s2: String? = null
s1.length ✓
✗s2.length
"can be null or non-null"
null ✗

val s: String?
if (s != null) { 
s.length 
}
Dealing with Nullable Types

s?.length
val s: String?
Dealing with Nullable Types

val length = if (s != null) s.length else null
val s: String?
Nullability operators
val length = s?.length

val length = if (s != null) s.length else null
val s: String?
val length: Int? = s?.length

val length = if (s != null) s.length else 0
val s: String?
val length: Int = s?.length ?: 0

val s: String?
Making NPE explicit
s!!
throws NPE if s is null
s!!.length

Nullable Types Under the Hood
No performance overhead
@Nullable, @NotNull annotations

class Optional<T>(val value: T) {
 
fun isPresent() = value != null 
 
fun get() = value ?: 
throw NoSuchElementException("No value present")
}
Nullable types ≠ Optional

Using annotated Java types from Kotlin
Type
behaves like
regular Java type
@ParametersAreNonnullByDefault
@Nullable
@NotNull Type
Type?
Type
Type
@MyNonnullApi
Type/
Type?

you can avoid any repetition
you can make the code look nicer
you can create API looking like DSL
expressive

Extension Functions
val c: Char = "abc".lastChar()
fun String.lastChar() = get(length - 1)

this can be omitted
Extension Functions
fun String.lastChar() = this.get(this.length - 1)

Calling Extension Functions
from Java code
StringExtensions.kt
char c = StringExtensionsKt.lastChar("abc");
JavaClass.java
import static StringExtensionsKt.lastChar;
char c = lastChar("abc");

No. Because it’s a regular
static method under the hood.
Extension Functions
Is it possible to call a private
member of String here?

Lambdas
button.addActionListener { println("Hi") }

{ employee: Employee -> employee.city == City.PRAGUE }
What’s an average
age of employees
working in Prague?
Working with collections with Lambdas
val employees: List<Employee>
employees.filter { it.city == City.PRAGUE }.map { it.age }.average()
data class Employee(
val city: City, val age: Int
)

What’s an average
age of employees
working in Prague?
Working with collections with Lambdas
val employees: List<Employee>
data class Employee(
val city: City, val age: Int
)
extension functions
employees.filter { it.city == City.PRAGUE }.map { it.age }.average()

Kotlin library: extensions on collections
• filter
• map
• reduce
• count
• find
• any
• flatMap
• groupBy
• …

Extension Function & Lambda
Lambda with receiver

val sb = StringBuilder() 
with (sb) { 
appendln("Alphabet: ") 
for (c in 'a'..'z') { 
append(c) 
}
toString() 
}
The with function
with is a function
sb.appendln("Alphabet: ") 
for (c in 'a'..'z') { 
sb.append(c) 
} 
sb.toString()

with (sb) { 
this.appendln("Alphabet: ") 
for (c in 'a'..'z') { 
this.append(c) 
}
this.toString() 
}
with (sb, { -> 
this.appendln("Alphabet: ") 
for (c in 'a'..'z') { 
this.append(c) 
}
this.toString() 
})
lambda
is its
second
argument
Lambda with receiverwith is a function
this is
an implicit receiver
in the lambda
with (sb) { 
for (c in 'a'..'z') { 
append(c) 
}
toString() 
}
this can be omitted

Lambda with receiver
with (sb) { 
for (c in 'a'..'z') { 
this.append(c) 
}
}
lambda with
implicit this

Under the Hood
No performance overhead
Lambdas can be inlined

with (window) {
width = 300
height = 200
isVisible = true
}
The with function
class Window(
var width: Int,
var height: Int,
var isVisible: Boolean
)

window.width = 300
window.height = 200
window.isVisible = true
with (window) {
width = 300
height = 200
isVisible = true
}
Inline functions
is declared as
inline function
generated bytecode is similar to:
No performance overhead for creating a lambda!

The apply function
val mainWindow =
windowById["main"]?.apply {
width = 300
height = 200
isVisible = true
} ?: return
Applies the given actions
and returns receiver as a result:

html { 
table { 
for (product in products) { 
tr { 
td { text(product.description) } 
td { text(product.price) } 
td { text(product.popularity) } 
} 
} 
} 
}
HTML Builders
lambdas with receiver

plugins {
application
kotlin("jvm") version "1.3.50"
}
application {
mainClassName = "samples.HelloWorldKt"
}
dependencies {
compile(kotlin("stdlib"))
}
repositories {
jcenter()
}
Gradle Build Script in Kotlin

router {
accept(TEXT_HTML).nest {
GET("/") { ok().render("index") }
GET("/sse") { ok().render("sse") }
GET("/users", userHandler::findAllView)
}
"/api".nest {
accept(APPLICATION_JSON).nest {
GET("/users", userHandler::findAll)
}
accept(TEXT_EVENT_STREAM).nest {
GET("/users", userHandler::stream)
}
}
resources("/**", ClassPathResource("static/"))
}
Kofu* (Kotlin + functional) DSL for Spring Boot
*part of Spring Fu
(an incubator for
new Spring features)

Multi-platform projects
Browser
Kotlin/JS
Android
Kotlin/JVM
iOS
Kotlin/Native
Server
Kotlin/JVM
common

code

Sharing common code
• Sharing business logic
• Keeping UI platform-dependent
• The shared part might vary

Common code
• you deﬁne expect declarations in the common
code and use them
• you provide different actual implementations
for different platforms

Time measurement example
expect fun measureTime(action: () -> Unit): Duration
Expected platform-speciﬁc API:
Expected API can be used in the common code:
measureTime {

// operation

}

Platform-speciﬁc Implementations
expect fun measureTime(action: () -> Unit): Duration
actual fun measureTime(action: () -> Unit): Duration {

// implementation using System.nanoTime()

}

// implementation using window.performance.now()

}

// implementation using std::chrono::high_resolution_clock

}
Kotlin/JVM
Kotlin/JS
Kotlin/Native

Common code
• can use the standard library
• can deﬁne expect declarations and use them
• can use other multi-platform libraries

Multi-platform libraries
• Standard library
• Ktor HTTP client
• kotlinx.serialization
• kotlinx.coroutines
• … and more

Many apps already in production
Going Native: How I used Kotlin Native to Port 6 years
of Android Game Code to iOS in 6 months
Shipping a Mobile Multiplatform Project on iOS &
Android
Your Multiplatform Kaptain has Arrived: iOS release is
powered by Kotlin Multiplatform

Introduction to kotlin

More Related Content

Introduction to kotlin