April 12
9:00 – 17:00
  • The workshops will take place on April 12 and cost 695 euro each (excl. VAT).
  • If you have a conference ticket you can add a workshop in your Order Details. Read the instruction
  • Workshop tickets are only valid for entry on April 12 and cannot be used to gain entry to the conference.

Multiplatform Madness With Compose (Plus Friends)

Garth Gilmour
Kotlin GDE

Compose may have started out on Android, but it has since matured into a multiplatform framework that provides a unified approach to creating clients.

Whether on the Web, Desktop or Mobile, you can share the same language, APIs, patterns, and even custom components. Looking beyond that, you can integrate with the wider multiplatform world of (for example) networking clients, threading libraries, testing utilities, and FP toolkits.

In this workshop, we will first explore, and then extend, a multiplatform UI built for disparate environments. You will deepen your understanding, not just of multiplatform and Compose in general, but also architecting and enhancing DSLs, structured concurrency with coroutines, functional architecture, and the internals of the Kotlin compiler.

Kotlin Multiplatform Mobile in Production

Kevin Galligan
Tadeas Kriz
Russell Wolf

Samples and tutorials are a great way to get started, but actually integrating Kotlin Multiplatform into a production environment with platform-specific teams requires more. In this workshop, you’ll learn about the various concerns that emerge when putting Kotlin Multiplatform into production, and we’ll work through some hands-on examples that address these concerns. We’ll cover the following topics:

  • Build system and tooling integration
  • iOS-side SDK design
  • Team structure and "who writes Kotlin?"
  • iOS package managers and binary distribution
  • Modularization and "what to share?"
  • Binary size impact
  • Performance considerations

Having worked with engineering teams of all sizes on this, we know that what works for a team of two does not always work for a team of twenty (or more). In a professional environment, advanced knowledge and preparation is the best path to Kotlin Multiplatform Mobile success. You will leave this workshop with that knowledge and preparation.

This workshop is primarily for developers with at least a basic working knowledge of Kotlin Multiplatform for native mobile. If you are new or want a refresher on the technology, please go through our ‘Getting Started Basics’ section of KaMP Kit, as this will be the project and configuration of reference in the workshop.

Kotlin TDD Masterclass

Nat Pryce
Consulting Developer
Duncan McGregor
Consulting Developer

In this hands-on Test-Driven Development workshop, we’ll lead the group through building a small application from the ground up. We’ll explore what Kotlin brings to TDD, and what TDD brings to Kotlin. How does a functional style affect testing and design? Can we avoid mocking, and should we? What role does the type system play when we have tests? Join us and find out.

Nat Pryce and Duncan McGregor are the authors of Java To Kotlin, A Refactoring Guidebook, published by O'Reilly. Nat is also the co-author of the highly influential Growing Object-Oriented Software Guided by Tests. Between them they have written thousands of lines of sweet test-driven code in applications including finance, fashion, set-top boxes, video editing, motorsport, satellite data distribution, academic publishing and climate science. Since adopting the language in 2016, they have introduced Kotlin to development teams in London and around the world through consultancy, conference talks, videos and workshops.

Building Scalable Microservices With Ktor and Kafka

Anton Arhipov
Viktor Gamov
Kong Inc.

Writing a single RESTful service is easy, but creating a scalable design is hard. Developers building their first distributed apps in the cloud are often puzzled by the choice of available frameworks and the variety of design options for the system architecture

This workshop will use Kotlin programming language, the Ktor services framework, and Kafka for event streaming to build a feature-complete backend application. We’ll start with the basics by exploring the Ktor framework and learning how to build a simple web application using obligatory functions. We’ll cover topics like handling HTTP requests, working with WebSockets, database access, authentication and authorization, logging, and more. We will also explore the plugin API and write a simple plugin for our web application.

Once you’re comfortable with Ktor, we will model a distributed system where the actors communicate asynchronously. What are the requirements for such a system? Messaging, long-term storage, and real-time stream processing immediately come to mind. This is where Apache Kafka comes in. Kafka will help make the system truly asynchronous, distributed, and resilient.

By the end of the workshop you will know:

  • How to create and deploy resilient RESTful services using Ktor.
  • How to integrate Ktor with external libraries that require additional configuration.
  • How to flexibly connect services using various tools, such as Kafka streams.

This will be a fast-paced workshop where attendees will spend most of their time coding.

Asynchronous Programming With Kotlin Coroutines

Svetlana Isakova
Sebastian Aigner
Roman Elizarov

In this workshop, you’ll learn everything you need to know to become 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 futures (represented by the Deferred type), and structured concurrency.

The second part of the workshop will be devoted to Kotlin Flows. Together, we’ll study how Kotlin Flows are designed on a basic level, discuss their typical usage patterns and the differences with other communication mechanisms like Channels, and even peek into some of their implementation details. In the process, we’ll see how they enable you to write safe, reliable, and leak-free concurrent systems. We’ll also talk about how they relate to and incorporate ideas from reactive extensions and reactive streams, and how they can be used together.

Svetlana and Sebastian will be leading you throughout the workshop. Roman, the original creator of Kotlin coroutines, will be available throughout to provide in-depth detail and answer your questions.

By the end of this workshop, you’ll have enhanced your coroutines-related vocabulary, understand how to spot and avoid common problems, and will be able to effectively and confidently use coroutines in your own projects.

Reactive Spring Boot With Coroutines

Urs Peter

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 Spring Boot's reactive stack Webflux. However, the price you pay in terms of complexity, readability, and maintainability of Webflux code is tremendous 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.

During the workshop, we’ll 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 ServerSentEvents that combines Coroutines and Flow.

At the end of the workshop, you’ll know all the ins and outs of reactive programming in Spring Boot with Coroutines while having experienced the tremendous benefits they offer over raw Webflux. With the knowledge you gain, you can enlighten your reactive Spring Boot project with Coroutines the very next day.

Elegant, Powerful, and Idiomatic APIs in Kotlin

Romain Boisselle
Kodein Koders
Salomon BRYS
Kodein Koders

Designing an effective API is a challenge every developer faces when they start developing with someone else. Whether you are a library or an application developer, your API defines how you communicate with other developers – it serves as the rules and practices that govern the usage of your work. As we all know, if an API can be abused, it will be, so expressing a tight and precise API is a very important skill that saves a lot of debug and verbal communication time. However, being tight and precise should come in the way of being concise, expressive, and powerful.

Kotlin offers many features that can be combined together to provide efficient APIs and DSLs. This workshop is for those who want to discover and understand the complex and advanced features of the Kotlin language. We will first discover each of them individually, and have a look at their compiler implementations, in order to understand their best usage and optimizations. We will then combine them to write tight, precise, concise, expressive, and powerful APIs and DSLs!

Finally, we will see that writing APIs for a Server, Android, or Multiplatform usage, means taking different design decisions. We'll have a look at the different constraints each Kotlin target imposes, and how we can use our knowledge of the Kotlin language to adapt our APIs for each platform.

Functional Programming in Kotlin

Raúl Raja Martínez
47 Degrees
Alejandro Serrano Mena
47 Degrees
Simon Vergauwen
47 Degrees

Functional programming has been on the rise, given its advantages in code readability and maintenance. In this workshop, we’ll look at concepts from functional programming that are directly applicable to Kotlin code. We’ll use Arrow as a supporting library, which includes many useful types and extensions to make a functional style even more pleasant. This workshop covers:

  • How to model your domain using hierarchies of data classes.
  • The importance of immutability and how it impacts your code style.
  • How to approach validation in a more composable way.
  • Keeping track of contexts and side effects.
  • Making asynchronous code more resilient with Arrow Fx.