Workshops

This is an intermediate/advanced workshop for experienced Kotlin Multiplatform developers. It is aimed at developers who have built projects with Kotlin Multiplatform and Jetpack Compose / Compose Multiplatform and now want to progress onto more advanced topics.

The workshop aims to equip attendees with the skills to write high-quality code and apps using Kotlin Multiplatform. The workshop will address the following topics:

A Gentle(r) Introduction

• Introducing an example project
• Explaining project structure and architecture
• Highlighting a few key libraries used in the project

Native Integrations

• Splash screens
• Notifications
• Working with files

Advanced Kotlin Multiplatform for iOS Targets

• Debugging Kotlin/Swift
• Understanding and improving Kotlin/Swift interoperability

Code Quality

• Code coverage with Kover (JVM-only)
• Modularization

App Quality

• Fixing memory leaks
• Performance testing
• App size optimization

Managing Workflows

• Basics of building CI/CD pipelines for your apps

You will need to bring a MacBook along with you to participate in all the practical exercises. Installation instructions will be provided one week prior to the workshop.

Ktor is a lightweight and flexible toolkit for building HTTP applications. This workshop will use the Kotlin programming language, the Ktor framework, the Exposed database access library, and several other Kotlin and Java libraries to build a feature-complete web application.

We’ll start with the basics by exploring the Ktor framework and learning how to build a simple web application using essential functions. We’ll cover topics like handling HTTP requests, working with WebSockets, database access, authentication, logging, and deployment.

For testing, we will look into the APIs that Ktor provides but also use the Testcontainers library for integration testing. Finally, we will explore the API for writing plugins and use it to create a simple plugin for our web application.

By the end of the workshop, you’ll be able to:

• Structure Ktor projects
• Test Ktor applications
• Create and deploy RESTful services using Ktor
• Integrate Ktor with external libraries

This will be a fast-paced workshop where attendees will spend most of their time coding. You will walk away armed with a cookbook of various Ktor recipes for building web applications.

Take the next step in your cross-platform Kotlin journey with Compose Multiplatform! This workshop is for developers already familiar with the basics of Kotlin Multiplatform and Jetpack Compose who are looking to extend their skills by building a shared UI.

We’ll discuss how Compose Multiplatform works and show you how your existing Compose skills are reusable across platforms. You’ll have hands-on time with a wide range of Compose features, focusing on how they work across different platforms. During the workshop’s exercises, you’ll work with Compose code, explore APIs, build new features, improve accessibility, test the UI, and more.

Covering the latest available APIs and best practices, we’ll equip you with everything you need to start using Compose Multiplatform in your own apps! Here is how the workshop will be structured:

Introduction

• How Compose Multiplatform works
• Running Compose on Android, iOS, Desktop, and Web
• Writing basic Compose code for multiplatform use

Compose building blocks

• Resources (localization, fonts, and more)
• Image loading
• ViewModels and architecture components
• Navigation
• Animations
• Dependency injection
• Theming

Mastering Compose Multiplatform

• Interop with native components
• Dialogs
• Insets
• Accessibility
• Testing

This workshop includes exercises for participants to complete on their own laptops. Using a MacBook is highly recommended for participation in all exercises, as iOS applications can only be built on macOS. Detailed setup instructions will be provided prior to the workshop.

Kotlin supports both Object-oriented and functional styles of programming, but what should we do when we have OO code that should be functional? Refactor, of course!

In this workshop, Nat and Duncan, the authors of Java to Kotlin: A Refactoring Guidebook, take a web application and introduce techniques to gradually and safely migrate the code to the functional style better suited to today’s architectures. Topics include:

• Thinking in a functional way – Data, Calculations, and Actions
• Migrating from mutable objects to immutable data classes
• Converting business logic to a functional domain model
• Where does the state live? Functional core / imperative shell
• Choosing between functions and methods
• Functional error handling
• Expand and Contract refactoring for safety over many commits

If you want to get the most out of Spring Boot in terms of low latency, high-throughput, and resource efficiency, there is no way around virtual threads and/or reactive libraries like Webflux.

However, both won’t get you far: Virtual threads are limited to non-blocking operations, and WebFlux — even though offering all reactive qualities, like non-blocking, parallelism, streaming, etc. — will give you a lot of headaches due to its complexity, bad readability, and maintainability.

In this workshop, you’ll learn how Spring Boot’s coroutine support will wipe out all the downsides of the ‘raw’ WebFlux approach or the limitations of virtual threads and provide you with the best of both worlds: non-blocking reactive characteristics without the complexity.

During the workshop, we will explore Kotlin’s reactive building blocks, such as coroutines and flows, and apply them in Spring Boot. By building a non-blocking API in Spring Boot from scratch, you’ll learn how to:

• Use coroutines on top of WebFlux and/or virtual threads.
• Perform non-blocking remote API calls using WebClient or RestClient.
• Access a database in a reactive way, either via the R2DBC or JDBC, including framework support.
• Apply structured concurrency in your business logic, like requesting data in parallel.
• Create an advanced streaming API based on ServerSentEvents that combines coroutines and flow.

In addition, we will explore virtual threads in-depth and see how they can leverage the power of coroutines even more.

At the end of the workshop, you’ll know all the ins and outs of programming in Spring Boot with coroutines while having experienced the tremendous benefits they offer over raw virtual threads or WebFlux.

With the knowledge you gain, you can enlighten your Spring Boot project with coroutines the very next day.

This workshop is designed for all Kotlin developers who need simple and convenient tools within their native ecosystem to assist them when working with data, understanding its nature, performing any necessary processing, and presenting the results to their team or stakeholders as a report or chart.

In this workshop, you’ll learn how to build data processing pipelines in your applications. We’ll explore the best practices for extracting data from various sources, aggregating and transforming it, and then exporting it as a collection of data classes, displaying it as tables, or visualizing it with insightful charts.

By the end of the workshop, you’ll be able to:

• Load, transform, and export data using the Kotlin DataFrame library.
• Visualize data with the Kandy library to effectively convey insights.
• Access and manipulate data from various sources: REST APIs, SQL databases, CSV files, and other tabular data.
• Handle both flat and hierarchical JSON-like data structures.
• Boost your code written with the help of the kotlin.collections or SQL-like frameworks.
• Solve practical problems by applying your skills to three real-world scenarios.
• Present the insights in Kotlin notebooks and easily share them on GitHub Gists.