Workshops

In this workshop, you’ll learn everything you need to know about how to be productive with coroutines in Kotlin. We’ll start with the basics of asynchronous programming, its differences from blocking code, and the concepts of suspending functions and coroutines. We’ll explore coroutine contexts, concurrent decomposition of work via deferreds, and structured concurrency with coroutine scopes.

The second part of the workshop will be devoted to Kotlin Flows. We’ll study how Kotlin Flows are designed on a basic level, learn the difference between hot and cold flows, discuss their typical usage patterns, and explore how they incorporate ideas from reactive streams. To deepen our understanding, we’ll also take a peek at some of the implementations behind flows and collectors. Throughout, we’ll see how they help you in writing safe and reliable concurrent systems, and how modern applications can use them to work with asynchronous streams of data, manage system state, and broadcast events.

Through this workshop, you’ll enhance your coroutines-related vocabulary, understand how to spot and avoid common problems, and be able to effectively and confidently use coroutines and flows in your own projects.

This is an intermediate / advanced workshop for experienced Android developers. It is aimed at engineers who have built projects with Kotlin and Jetpack Compose and now want to progress onto multiplatform application development.

The workshop is split into two parts. In the morning session, we’ll build an application entirely using Kotlin Multiplatform libraries. This will feature a Compose Multiplatform user interface, testing with kotlin.test and Kotest, and networking with Ktor and coroutines. Additional libraries will be used to show data caching, dependency injection, serialization, and more.

In the afternoon session, we’ll explore real-world issues associated with taking these kinds of applications into production. We’ll explore general issues with architecture and deployment but then shift our focus to issues specific to iOS. In particular, we’ll cover how best to package and expose Kotlin APIs to be consumed by Swift code, and vice versa. We’ll also explore how to share business logic with a SwiftUI interface, work with XCode, and distribute your application.

Morning Topics

1. Review the basics of KMP development.
2. Introducing the workshop sample application.
3. Adding shared business logic with unit tests.
4. Platform integration with expected and actual declarations.
5. Extending the existing Compose Multiplatform UI.
6. Interacting with services via Ktor and coroutines.
7. Creating integration tests at different levels.
8. Refactoring the app to use dependency injection.
9. Adding client side caching to improve performance.

Afternoon Topics

1. Best practices for building multiplatform applications.
2. Guidelines for creating and distributing your KMP library.
3. Making the most out of the existing KMP ecosystem.
4. A primer for using XCode effectively in KMP apps.
5. Effectively sharing Kotlin APIs with Swift codebases.
6. Mixing Compose Multiplatform and SwiftUI components.
7. Options for testing a Compose Multiplatform UI in iOS.
8. Distributing your shared code to iOS teammates.

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 plugin API and write a simple plugin for our web application.

By the end of the workshop, you will know:

• How to structure your Ktor project
• How to test Ktor applications
• How to create and deploy RESTful services using Ktor
• How to 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.

The needs of a codebase change over time. We have to implement new features that weren’t anticipated when the product was first designed, changing existing code to model a combination of old and new behaviors. Refactoring is an essential skill that allows us to accommodate new requirements without ever-increasing complexity.

Duncan McGregor and Nat Pryce are authors of the book “Java to Kotlin: A Refactoring Guidebook”. Join them in this workshop to continue the journey. Together, you will refactor a web application from Kotlin to even better Kotlin, combining language features to ensure greater type safety, more explicit data flow, and a clear architecture.

In this workshop, you’ll learn how to:

• Master the IntelliJ Platform’s Kotlin refactoring tools.
• Devise a test strategy to safely refactor with confidence.
• Plan multistep refactorings so that code continues to build and run.
• Migrate from mutable objects to immutable data classes, functions, and state machines modeled with sealed class hierarchies.
• Migrate a layered or Hexagon software architecture to Functional Core, Imperative Shell.
• Use AI to improve refactoring productivity.

If you want to get the most out of Spring Boot in terms of low latency, high throughput, and resource efficiency, there’s no way around Spring Boot’s reactive stack WebFlux. However, the price you pay in terms of WebFlux code’s complexity, readability, and maintainability is rather high and will likely give you a lot of headaches.

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

You’ll also explore Kotlin’s reactive building blocks, such as coroutines, channels, and flows, and apply them in Spring Boot. By building a reactive API in Spring Boot from scratch, you’ll learn how to:

• Perform non-blocking remote API calls using WebClient.
• Access a relational database with the reactive R2DBC driver.
• Apply parallelism in your business logic.
• Write and test reactive API endpoints.
• Create an advanced streaming API based on Server-Sent Events that combines coroutines and flows.

By the end of the workshop, you’ll know all the ins and outs of reactive programming in Spring Boot with coroutines, as well as the benefits they offer over the WebFlux abstractions Mono and Flux.

Furthermore, you’ll explore Project Loom’s virtual threads and see how they fit into the picture. You’ll also learn how virtual threads can further leverage the power of coroutines.