9:00 – 17:00
In this workshop, you’ll learn how to use Jetpack Compose, Android’s modern, declarative UI toolkit. You’ll start by building a solid foundation and learning the fundamentals of declarative thinking, working with state, layouts, design systems, and animation. We’ll then walk you through a practical migration of a View-based app to Compose to understand how to incrementally adopt Compose and explore the implications for your architecture and testing. We’ll finish by diving deeper into how layouts work in Jetpack Compose, including built-in layouts, modifiers, and building your own custom layout.
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:
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.
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.
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.
In this workshop, we’ll pick the three Ks for server-side development: the Kotlin programming language, the Ktor services framework, and Kafka for event streaming. We’ll start with the basics by exploring the Ktor framework and learn how to build a simple web application using obligatory functions, including 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’re going to 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 us make the system truly asynchronous, distributed, and resilient.
By the end of the workshop you will know:
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:
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.
Learn how to set up a project for Kotlin Multiplatform and deploy your business logic everywhere.
In this workshop, we’ll be building a small application that runs on Android with Jetpack Compose, on iOS with Swift UI, on the web with JetBrains Compose Web, and on desktop JVMs with JetBrains Compose Desktop, providing a native look and feel while reusing a fully tested and coherent business layer. Data modeling and validation code can even be useful on the server side, and will be reused in a small Ktor server.
There are many challenges ahead of us: mastering the specific tools, writing meaningful multiplatform tests, understanding the interoperability layer of each platform, and creating a thoughtful architecture that respects and takes full advantage of all of these platforms.
By the end of the workshop, you will have learned how to overcome each of these challenges and create the entire stack of a Kotlin Multiplatform project.
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:
Take part in the Kotlin
event of the year!