Kotlin The Whole Damn Family

garth.gilmour@instil.co
@GarthGilmour
Limerick KUG - February 2019
© Instil Software 2018
Kotlin - The Whole Damn Family
https://bitbucket.org/GarthGilmour/limerick-kug-feb-2019

We’ve bought into Kotlin in a big way
About Instil

We held a workshop at the conference
•  React Web App with Kotlin on
Server & Browser
About Instil

Excellent interoperability
•  Call legacy Java code easily
•  Make calls into Kotlin from Java
Really clear, yet concise syntax
•  Reduces your codebase by 1/3+
Beloved by frameworks
•  First class language on Android
•  Mainstream language for Spring via
the Spring Initializr and Spring Fu
•  New language for the Gradle DSL
•  Kotlin specific frameworks emerging
•  Notably Arrow and Ktor
Why Kotlin? Null Safety
String Templates
Default parameters
Extensions
Free Functions
Coroutines
Single Expression
Functions
Reified generics
Data classes and
Properties
Type Inference
Smart Casts
Operator
overloading

C
C++
Java
C#
Pascal
Delphi
Basic
Visual Basic
VB .NET
Perl
F#
Java
Script
CoffeeScript
1990
2000
2010
TypeScript
Jython
JRuby
PowerShell
Dart
Scala
Clojure
Kotlin
Groovy
Go
Objective C
Shell
Scripting
Swift
Python
Ruby

Java is a legacy language!
But in Java 11…
Kotlin has it today!!
Scala had it
years ago!!
No one gives
a **** about
modules!!

Kotlin was originally for the desktop and server
•  As JetBrains own internal language
Then it exploded amongst the Android community
•  This is still where it is most commonly found
Now its going further
•  Kotlin Native builds apps to run outside the VM
•  Kotlin JS is transpiled to run inside the browser
Kotlin On Other Platforms

Let the buyer beware!
•  Everything you see is the
result of my own hacking
•  I am very much still in the
learning stages myself…
A Warning…

•  Building Native Applications
Part 1a

Kotlin Native compiles Kotlin code to native binaries
•  It produces executables that run without a virtual machine
The binary output is not portable, but the source is
•  The compiler can compile the same source to multiple outputs
•  The source can be placed into a multiplatform project
Introducing Kotlin Native
Kotlin Native
Compiler
LLVM Source LLVM
IR
Native
Binary

Supported platforms include,
•  iOS (arm32, arm64, emulator x86_64)
•  MacOS (x86_64)
•  Android (arm32, arm64)
•  Windows (mingw x86_64)
•  Linux (x86_64, arm32, MIPS, MIPS little endian)
•  WebAssembly (wasm32)
There is interop with C, Objective-C and Swift
•  Kotlin code can call into any of these and vice versa
•  Tools like ‘cinterop’ generate Kotlin declarations
based on C declarations found in header files

Common things such as Kotlin.io aren’t available
You can use POSIX and interop to achieve functionality or
use other multiplatform libraries
import kotlinx.cinterop.*
import platform.posix.*
import kotlinx.io.*

Anyone Ever Heard of Pthreads?

From the main thread we wish to start two Pthreads
•  With the names ‘Thread No1’ and ‘Thread No2’
•  This can be accomplished via ‘pthread_create’
Each thread will print out twenty messages
•  In turn each message will be divided into three parts
We want the parts of each message to be atomic
•  We do this by creating a mutex and passing it to the threads
•  Each thread will:
•  Acquire the mutex via ‘pthread_mutex_lock’
•  Print the three parts of the message and releases it
•  Release the mutex via ‘pthread_mutex_unlock’
The main thread will waits for the Pthreads
•  This can be accomplished via ‘pthread_join’
A Demo of Pthreads

A Demo of Pthreads
Pthread Thread No1 message 1 part A
Pthread Thread No1 message 1 part B
Pthread Thread No1 message 1 part C
...
...
…
Thread 1 holding mutex

Creating a Project in Clion (with Kotlin Native Plugin)

plugins {
kotlin("multiplatform") version "1.3.21"
}

repositories {
mavenCentral()
}

kotlin {
macosX64("KotlinNativePThreads") {
binaries {
executable("KotlinNativePThreadsApp") {
entryPoint = "limerick.kug.main"
}
}
}
}
build.gradle.kts
The Gradle Build File

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Build tasks
-----------
assemble - Assembles the outputs of this project.
build - Assembles and tests this project.
buildDependents - Assembles and tests this project and all projects that depend on it.
buildNeeded - Assembles and tests this project and all projects it depends on.
clean - Deletes the build directory.

Run tasks
---------
runKotlinNativePThreadsAppDebugExecutableKotlinNativePThreads - Executes Kotlin/Native
executable KotlinNativePThreadsAppDebugExecutable for target KotlinNativePThreads
runKotlinNativePThreadsAppReleaseExecutableKotlinNativePThreads - Executes Kotlin/Native
executable KotlinNativePThreadsAppReleaseExecutable for target KotlinNativePThreads

Verification tasks
------------------
check - Runs all checks.
KotlinNativePThreadsTest - Executes Kotlin/Native unit tests for target
KotlinNativePThreads.

Some Tasks Available via the Build File

package limerick.kug

import kotlinx.cinterop.*
import platform.posix.*

fun napTime(microseconds: Int=250)
= usleep(microseconds.toUInt() * 1000.toUInt())

fun foobar(input: COpaquePointer?): COpaquePointer? {

}

fun main() {

}
Demo.kt
The Demo Code
Code to run in Pthread goes here…
Code to launch Pthreads goes here…

fun foobar(input: COpaquePointer?): COpaquePointer? {
kotlin.native.initRuntimeIfNeeded()
memScoped {
val data = input?.asStableRef<Pair<CPointer<ByteVar>,
pthread_mutex_t>>()
val name = data?.get()?.first?.toKString() ?: "No Name"
val dummy = alloc<pthread_mutex_t>()
val mutex = data?.get()?.second ?: dummy

for (x in 1..20) {
doWork(mutex, name, x)
}
}
return StableRef.create(0).asCPointer()
}
Demo.kt
The Demo Code

private fun doWork(mutex: pthread_mutex_t, name: String, x: Int) {
pthread_mutex_lock(mutex.ptr)
print("Pthread $name message $x part An")
napTime()
print("Pthread $name message $x part Bn")
napTime()
print("Pthread $name message $x part Cn")
napTime()
pthread_mutex_unlock(mutex.ptr)
napTime()
}
Demo.kt
The Demo Code

fun main() {
memScoped {
val mutex = alloc<pthread_mutex_t>()
pthread_mutex_init(mutex.ptr,null)

val threadHandle1 = alloc<pthread_tVar>()
val attrs = null

val data1 = StableRef.create("Thread No1".cstr.ptr to mutex)

pthread_create(threadHandle1.ptr,
attrs,
staticCFunction(::foobar),
data1.asCPointer())
Demo.kt
The Demo Code

attrs,
data2.asCPointer())

val result = null
pthread_join(threadHandle1.value, result)
pthread_join(threadHandle2.value, result)

pthread_mutex_destroy(mutex.ptr)
}

println("End of main...n")
}

Demo.kt
The Demo Code

Let’s look at some function signatures…

Comparing Signatures for ‘pthread_create’
int pthread_create(pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)(void*),
void *arg);
public fun pthread_create(
arg0: CValuesRef<pthread_tVar>?,
arg1: CValuesRef<pthread_attr_t>?,
arg2: Cpointer<CFunction<(COpaquePointer?) -> COpaquePointer? >>?,
arg3: CValuesRef<*>?
): kotlin.Int

Comparing Signatures for ‘pthread_join’
int pthread_join(pthread_t thread,
void **retval);
public fun pthread_join(
arg0: pthread_t?,
arg1: CValuesRef<COpaquePointerVar>?
): kotlin.Int

Comparing Signatures for Mutex functions
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
public fun pthread_mutex_init(
arg0: CValuesRef<pthread_mutex_t >?,
arg1: CValuesRef<pthread_mutexattr_t >?
): kotlin.Int
public fun pthread_mutex_destroy(
arg0: CValuesRef<pthread_mutex_t>?
): kotlin.Int

The ‘cinterop’ tool generates Kotlin types from C types
•  For structures the Kotlin name is the same as the C name
•  For other types (e.g. opaque types) it is ‘${type}Var’
A void pointer is represented by the ‘COpaquePointer’ type
•  An in-memory instance is represented by ‘COpaquePointerVar’
Pointers are represented in two ways:
•  For variables use ‘CPointer<T>’ and ‘CPointerVar<T>’
•  For parameters use ‘CValuesRef<T>’
What Have We Learned

Now lets look back at the code…

Memory is allocated via ‘alloc’ functions
•  There are versions for single types, arrays, pointers etc…
The memory allocated must be freed
•  This can be managed for you via ‘memScoped { … }’
Null in Kotlin is translated into NULL in C
•  I.e. the address denoted by zero where nothing lives
•  NB Pthreads uses NULL to mean ‘go with the defaults’
Explaining the Demo Code
val mutex = alloc<pthread_mutex_t>()
pthread_mutex_init(mutex.ptr,null)

Kotlin strings are interoperable with C Strings
•  The compiler converts between Strings and ‘const char *’
Manual conversion methods are available
•  Calling ‘cstr’ on a String returns ‘CValuesRef<ByteVar>’
•  You can call ‘toKString’ on a ‘CPointer<ByteVar>’
The ‘StableRef’ type is used to pass values through C
•  This typically happens when you are writing a function in Kotlin
which will be called at a later date from C with cached data
•  The Pthreads library is a good example of where this is useful

When working with generated types
•  Use ‘ptr’ to get the address in memory of a value
•  Use ‘value’ to get the value from an address in memory
Standard Kotlin functions can be used as C callbacks
•  As long as you convert the reference via ‘staticCFunction’
•  Within the function you must call ‘initRuntimeIfNeeded()’
attrs,
data1.asCPointer())

In the code below we:
•  Convert the opaque pointer to a StableRef of a Pair of values
•  Convert the first value in the pair from a byte pointer to a String
•  Specify default values for either item if it is missing
•  Run the job of work to be done asynchronously
val data = input?.asStableRef<Pair<CPointer<ByteVar>, pthread_mutex_t>>()
val name = data?.get()?.first?.toKString() ?: "No Name”
val dummy = alloc<pthread_mutex_t>()
val mutex = data?.get()?.second ?: dummy
for (x in 1..20) {
doWork(mutex, name, x)
}

Let Us Return To Normality
Let’s return to the normal world of sane people…

Kotlin Native has its own concurrency model
•  Possible as JetBrains now has control of the underlying runtime
The main abstraction is a ‘Worker’
•  Workers are similar to Actors in frameworks like Akka
You pass data and jobs to a worker via its ‘execute’ method
•  The producer lambda returns a graph of objects whose
ownership will now be transferred to the target worker
•  The calling thread won’t be able to access those objects
The Kotlin Native Concurrency Model
fun <T1, T2> execute(mode: TransferMode,
producer: () -> T1,
job: (T1) -> T2): Future<T2>

Objects in Kotlin Native can be frozen
•  This is an operation that is performed at runtime
•  All objects in a graph are marked as immutable
•  Any writes result in an ‘InvalidMutabilityException’
Frozen objects can safely be shared between Workers
•  Kotlin Native does not allow Workers to share mutable state
There are multiple ways to freeze an object:
•  Singleton objects and enums are automatically frozen
•  Arbitrary objects can be frozen via the ‘freeze’ method
•  Global variables can be marked with ‘SharedImmutable’
Global variables can also be marked with ‘@ThreadLocal’
•  In which case each Worker gets its own copy of the data
The Kotlin Native Concurrency Model

package native.workers

import kotlin.native.concurrent.TransferMode
import kotlin.native.concurrent.Worker

fun main() {
fun job(name: String): String {
for(x in 1..20) {
print("$name message $xn")
}
return "$name Done!"
}
val w1 = Worker.start()
val w2 = Worker.start()

val future1 = w1.execute(TransferMode.SAFE, {"Worker No1"}, ::job)
val future2 = w2.execute(TransferMode.SAFE, {"Worker No2"}, ::job)

println(future1.result)
println(future2.result)
}
Demo.kt
Using Kotlin Native Workers

Using Kotlin Native Workers
Worker No1 message 1
Worker No1 Done!
Worker No2 Done!

•  Multiplatform Projects
Part 1b

Multiplatform Libraries
Kotlin / JVM
Kotlin / JS
Kotlin / Native
Common

Multiplatform Libraries - Compatability

•  Building Web Applications
Part 2

Imagine a Developer Was Frozen in the 1990’s

The Myth Of The Full Stack Developer…

React 101
<Ticker name=“Fred”/>

class Ticker extends React.Component {
constructor(props) {
super(props);
this.state = {secondsElapsed: 0};
}
componentDidMount() {
this.interval = setInterval(() => this.tick(), 1000);
}
componentWillUnmount() {
clearInterval(this.interval);
}
tick() {
this.setState({secondsElapsed: this.state.secondsElapsed + 1});
}
render() {
return (
<div>
<h1>Hello, {this.props.name}!</h1>
<p>Page open {this.state.secondsElapsed} seconds.</p>
</div>
);
}
}

class Ticker extends React.Component {
constructor(props) {
super(props);
this.state = {secondsElapsed: 0};
}
componentDidMount() {
this.interval = setInterval(() => this.tick(), 1000);
}
componentWillUnmount() {
clearInterval(this.interval);
}

tick() {
this.setState({secondsElapsed: this.state.secondsElapsed + 1});
}
render() {
return (
<div>
<h1>Hello, {this.props.name}!</h1>
<p>Page open {this.state.secondsElapsed} seconds.</p>
</div>
);
}
}
Initial State
Lifecycle
Methods
Changing state marks component as dirty
Rendering uses embedded JSX templating language

The ‘create-react-kotlin-app’ script

class WidgetDisplay extends React.Component {
}

class WidgetDisplay(props: WidgetDisplayProps)
: RComponent<WidgetDisplayProps,
WidgetDisplayState>(props) {
}

//Properties are strongly typed
class WidgetProps(var foo: String,
var bar: Int) : RProps

//State is also strongly typed
interface WidgetState: RState {
var widgets: List<Widget>
}
Sample.kt
React Components in JS and Kotlin
JavaScript
Kotlin

render() {
return (
<div>
<h1>Hello, {this.props.foo}!</h1>
</div>
);
}
}

: RComponent<WidgetDisplayProps,
WidgetDisplayState>(props) {
override fun RBuilder.render() {
div {
h1 { +props.foo }
}
}
}

Sample.kt
JavaScript
Kotlin

render: function () {
return <div>
<button onClick={this.eventHandlerFunc}>
Something
</button>
</div>;
}
}

: RComponent<WidgetDisplayProps,WidgetDisplayState>(props) {
div {
button {
+props.foo
attrs { onClickFunction = ::eventHandlerFunc }
}
}
}
}

Sample.kt
JavaScript
Kotlin

We Need Services and a Data Source
Having defined the problem, the first step
towards a solution is the acquisition of data.

The Neo4J Desktop and Movies DB

interface MovieRepository : Neo4jRepository<Movie, Long> {
@Query("""
MATCH (a:Actor)-[:ACTS_IN]->(m:Movie)
WITH a, collect(m) AS filmograpy
WHERE size(filmograpy) >= {0}
RETURN a
""")
fun findActorsByFilmography(minMovies: Long): List<Actor>

@Query("""
MATCH (m:Movie)<-[:ACTS_IN]-(a:Actor)
WHERE a.name STARTS WITH {0}
RETURN m SKIP {1} LIMIT {2}
""")
fun findByActorName(actorName: String,
skip: Long,
limit: Long): List<Movie>
}
MovieRepository.kt
A Spring Data Repo to Talk to Neo4J

@CrossOrigin
@RestController
@RequestMapping("/movies")
class Neo4JMoviesService(val repo: MovieRepository) {

@GetMapping("/byFilmography/{minMovies}")
fun byActorId(@PathVariable("minMovies") minMovies: Long): Flux<Actor> {
return Flux.fromIterable(repo.findActorsByFilmography(minMovies))
}

@GetMapping("/byActorName/{name}/{skip}/{limit}")
fun byActorName(
@PathVariable("name") name: String,
@PathVariable("skip") skip: Long,
@PathVariable("limit") limit: Long
): Flux<Movie> {
return Flux.fromIterable(repo.findByActorName(name, skip, limit))
}
}
Neo4JMoviesService.kt
A RESTful Service Written in WebFlux

class MovieTableProps(var movies: List<Movie>,
var selectedHandler: (Movie) -> Unit) : Rprops

interface MovieTableState: RState {
var movies: List<Movie>
}
MovieTable.kt
A Sample Component

class MovieTable(props: MovieTableProps) :
RComponent<MovieTableProps, MovieTableState>(props) {

init {
state.movies = props.movies
}

override fun componentWillReceiveProps(nextProps: MovieTableProps) {
state.movies = nextProps.movies
}

private fun sortMovies(selector: (Movie) -> String) {
val sortedMovies = state.movies.sortedBy(selector)
setState { movies = sortedMovies }
}

private fun sortByTitle(e: Event) = sortMovies { it.title }

private fun sortByGenre(e: Event) = sortMovies { it.genre }

MovieTable.kt
A Sample Component

table(classes = "table table-striped table-bordered") {
thead {
tr {
th {
+"Title"
span(classes="fas fa-sort ml-2") {}
attrs { onClickFunction = ::sortByTitle }
}
th {
+"Genre"
span(classes="fas fa-sort ml-2") {}
attrs { onClickFunction = ::sortByGenre }
}
th { +"Tagline" }
}
}

MovieTable.kt
A Sample Component

tbody {
state.movies.map { movie ->
tr {
td { +movie.title }
td { +movie.genre }
td { +movie.tagline }
attrs {
onClickFunction = {
props.selectedHandler(movie)
}
}
}
}
}
}
}
}
MovieTable.kt
A Sample Component

•  Some Conclusions
Part 3

Kotlin The Whole Damn Family

More Related Content

What's hot (20)

Similar to Kotlin The Whole Damn Family (20)

More from Garth Gilmour (20)

Recently uploaded (20)

Kotlin The Whole Damn Family