This workshop covers asynchronous programming in Kotlin using coroutines. It starts with the basics of asynchronous programming and its differences from blocking code and introduces the concept of suspending functions and coroutines. Dealing with the ecosystem of blocking code on JVM is covered in depth, as well as the best practices for managing cancellation of asynchronous operations. The workshop also covers more advanced topics on concurrent decomposition of work via futures, deep dive into coroutine contexts, and includes an overview of Communication Sequential Process (CSP) approach and channels.
Duncan McGregor, Nat Pryce
If you're a Java developer who hasn't yet took the leap to Kotlin, this workshop is for you. Working as a group, we'll take existing Java code, convert it with a single IntelliJ IDEA command, and then refactor the results to idiomatic Kotlin. We'll see how to take advantage of the language to make code smaller, faster, and more expressive, whilst at the same time interoperating with your existing application and Java libraries. In the afternoon, we'll move from the prepared exercises to your code, working together to apply the techniques and insights from the morning to real codebases with real constraints. So if you have some code you'd like to start migrating, bring it along on a laptop with IntelliJ IDEA installed. More information
Florina Muntenescu, Sean McQuillan, Yacine Rezgui, Tiem Song, Wojtek Kaliciński
In this workshop we’ll start by looking at coroutines in Android – what they are, how they work, and in which situations you should use them. We’ll also take a look at some of the integrations that Android Jetpack libraries have with coroutines, and find best practices for architecting your app when working with coroutines. We’ll see if and how testing changes when you work with Kotlin in Android. Then we'll explore Jetpack Compose, a native UI toolkit for Android, written in Kotlin. You'll learn how it fits together with your existing architecture to build reusable UI components. Built to integrate with your existing code we'll take a look at how to combine Jetpack Compose with Android Views. We'll also cover some best practices for how to use Jetpack Compose! We’ll end with a high-level exploration of Kotlin/Native – and see how it can all be used to build a multiplatform library.
This workshop will fully explore how Kotlin/Native can be used to generate native applications for different platforms. We will explain how the language uses reference counting and a standard memory model to produce non-VM based applications that can be compiled across multiple platforms. We'll then create a sample library in C, and use the cinterop tool to generate wrapper types which can be called directly from Kotlin. We'll build progressively on this library, enhancing it with the use of pointers (including function pointers and void *), opaque types, callbacks, dynamically allocated memory, and other C features. Once every aspect of interoperability has been addressed, we will take one or more open source libraries and access them via Kotlin/Native to see these features used in anger. Finally, we will design some metrics and performance tests to measure the speed of execution of the programs we have created, relative to versions written in pure Java and C++. By the end, you will have both hands-on experience with Kotlin/Native and an understanding of how things work under the hood.
In this workshop, we'll learn how to leverage Kotlin to reuse our business (and other) code across multiple platforms. Using the language and Kotlin tooling, we can create applications that target Android, iOS, and Web. We'll see how to define the architecture of our applications, create the necessary abstractions for code-reuse, and how to test multiple code for multiple platforms and deploy our apps. Through a series of simple exercises we'll build a business application together which will be deployed to each platform, each with their corresponding presentation layers. Note that while it is recommended to have a MacBook for this workshop – as we'll also be targeting iOS – it is not entirely mandatory as you'll still be able to leverage the multiplatform code to target Android and Web. More information