Workshops

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.

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.

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.

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.