Save the date: Backend meetup - Game changing Concurrency with Kotlin Coroutines

Software development @ Xebia
Software development @ Xebia
Openbare groep


Locatieafbeelding van evenementslocatie

Wat we doen

While reactive programming has revolutionised the way we scale IO bound applications on the JVM it has also induced a great deal of headaches at the expense of engineers. Kotlin recognising the burdon placed upon you ‘the developer’ has come up with an impressive answer called Coroutines, which makes struggling with Threads, CompletableFutures and reactive libraries like Reactor, RxJava etc. history.

18:00 Dinner is ready
18:30 Matthisk Heimensen - Coroutines Basics
19:30 Break
19:45 Urs Peter - Coroutines in Spring Boot
20:45 Borrel, network time

With two talks we will explore Kotlin’s Coroutines in-depth, so that you get to know the in’s and out’s as well as pro’s and con’s of this impressive technology:

Talk 1: Coroutines Basics (Coroutine, Channels, Actors, Flows):
Matthisk Heimensen will introduce you to the Coroutine basics, explain the concept of ‘structured concurrency’, suspend functions and all the building blocks needed to properly program with coroutines. He will also cover more advanced features such as Channels and Actors. Finally, he will dive into Kotlin Flow, which is still an experimental feature. You will learn how Kotlin’s powerful concurrency primitives make reactive streams implementations safer and more powerful.

Talk 2: Coroutines in Spring Boot
Based on the gained knowledge of the first talk Urs Peter will show you how easy it is to apply Coroutines in Spring Boot using live-coding. Staring out with a simple rest service he will transform a CompletableFuture based endpoint into a Coroutine counterpart. He will rebuild a ServerSentEvent stream endpoint written with Reactor’s Flux with a Kotlin Flow and show you how Channels can be applied to broadcast information between Flows. He will finally explain how existing CompletableFuture or Flux/Mono based api’s can easily be ‘lifted’ into Coroutines allowing different reactive libraries to be used in a straightforward synchronous way without losing their asynchronous, non-blocking characteristics.

At the end of the meetup you will have gained a good understanding of what Coroutines are and how to use them in Kotlin code. You will get to know more advanced Coroutines concepts such as Channels, Actors and Flows and when to apply them. Finally, you will see how these concepts are applied in Spring Boot using live-coding, enabling you to build ‘state of the art’ reactive applications with the simplicity of synchronous, blocking ones.