Reactive Spring Boot With Coroutines and Virtual Threads

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.

Cooking your Ravioli "Al Dente" with Hexagonal Architecture

Hexagonal architecture (a.k.a. ports and adapters) is a fancy name for designing your application in a way that the core domain is separated from the outside world by input and output ports. With a little bit of imagination one can visualise this as a hexagon made up of domain objects, use cases that operate on them, and input and output ports that provide an interface to the outside world.

Many projects involve integration or communication with external software systems. Think of databases, 3rd party services, but also application platforms or SDKs. Such integrations and dependencies can quickly get in your way, clutter your core domain and reduce the testability of your core business logic. In this talk, I will demonstrate how a hexagonal architecture helps you to reduce dependencies on external software systems and enables you to apply standard software engineering best practices on the core domain of your application, such as testability, separation of concerns, and reusability.

Join this talk to learn the ins and outs (pun intended) of the hexagonal architecture paradigm and get practical advice and examples to apply to your software projects right away!

Advanced Kotlin Workshop

Do you have some Kotlin experience and want to take your skills to the next level? …then our hands-on workshop will get you there in no time.

Our expert track will enlighten you with the sophisticated yet easy-to-use Kotlin features that can unleash tremendous power in your codebase.

The following is on the menu:

Type-Safe Builders and DSLs
• You will learn how to write type-safe builders, which make the creation of internal DSL’s a snap.

Coroutines, Channels, and Flow
• Get to know the mind-blowing approach Kotlin takes on the concurrency side by playing with Coroutines and more advanced Concurrency constructs like Channels and Flow. You will also learn how easy it is to integrate Coroutines in your existing reactive stack like CompletableFuture, WebFlux, etc.

Spring Boot with Coroutines, Channels, and Flow
• Finally, you will rewrite a reactive Spring Boot web application created in Java and WebFlux to Coroutines and experience the ease and peace of mind this approach can offer you. You will also create a streaming API based on ServerSentEvents that brings together all the reactive building blocks you learned previously.

We will provide a web IDE that allows you to complete all the challenges of your preference. So all you need is a browser, and off you go.

CU in class for a tasty cup of Kotlin 😉

Programming Polyglot: A Journey Through Effective Language Learning

Embarking on the journey of learning a new programming language can be a complex endeavor, often filled with challenges and uncertainties. In this enlightening conference talk, we explore the parallels and lessons from language acquisition theories, valuable insights, and practical techniques to empower developers at all levels in their pursuit of mastering programming languages.

Discover that, despite our differences and unique learning styles, we effectively acquire (programming) languages in roughly the same way. Hint: pair programming might NOT be the solution and could be even harmful.

Whether you're a seasoned developer exploring new languages, a coach, trainer, or a novice taking the first steps, gain actionable insights into effectively learning new programming languages.

Kotcha!

An interactive walkthrough several gotchas I ran into in my Kotlin projects and trainings

After programming in Java and Scala for many years, I found a best-of-both-worlds language in Kotlin. Luckily enough I was able to work with Kotlin quite extensively, during projects and trainings. While doing that I stumbled upon many gotchas that have lead to true face palm and eye opening moments!

I'll happily share these (slightly embarrassing) war stories in this talk. To keep things fair, I'll put your knowledge to the test: May the best Kotcha spotter win!

Join this talk to learn from my failures and mistakes so you won't make them in your next Kotlin project!

Strangling a Finance Monolith: When CDC Can't Reach Your Data

Debezium and Kafka Connect are the standard way to stream data from legacy databases into Kafka. But what if your data is hidden behind complex views or stored procedures that don’t show up in the redo log and can’t be polled easily, like multi-table joins, aggregations, or computed results?

In this talk, I’ll walk you through how we broke down a large finance Oracle system at a Dutch retailer. I’ll explain where Debezium and JDBC Source Connectors didn’t work for us, how we made things 80 times faster using plain JDBC cursors and Kotlin Sequences, and how we built a bridge so old and new systems could share data both ways.

You’ll see how the transactional outbox pattern helps us get data into Kafka reliably, how we prevented silent data loss when streaming large result sets, and how our bridge lets the old and new systems run side by side until the monolith can be switched off for good.

If your organization has legacy data that CDC can't reach, this talk is for you. You’ll walk away with patterns you can apply immediately.

Target audience: Intermediate-to-advanced Java/Kotlin developers working with legacy systems, event-driven architecture, or monolith migrations.

Preferred format: Technical session (50 minutes).

Based on production experience at a large Dutch enterprise (anonymized). A companion blog post on the cursor streaming pattern is available as follow-up material for attendees.

Technical requirements: standard projector setup, no live coding (prepared code snippets in slides).

State of Confusion: Data Ownership in Event-Driven Systems

In event-driven systems you should not call another service's API but instead consume its events and maintain local state. However, how much state should you store? If you limit yourselves to the state that is needed at the moment you will find yourself having to rush to deal with changes in requirements over a number of sprints. If you store all the state then you end up being coupled to the other team's schema evolution.

In every architecture review, this decision comes up, gets discussed in a Slack thread, and is regretted six months later. However, most teams lack a systematic approach to considering it.

In this talk, I’ll walk you through the range of options, from making REST calls up to full event replication. I’ll share examples of teams that kept too little data and teams that kept too much, and I'll hand you a practical decision-making framework based on four criteria: topic retention, schema stability, requirements clarity, and query patterns.

You'll end up with a method that you can use to assess this trade-off in your own systems. It won't be a set of rules, but rather a structured approach that recognizes there is no one-size-fits-all solution.

What we'll cover:
- The spectrum: REST calls, thin projections, full event replication, raw event storage, and when each breaks down
- Real examples of teams that stored too little and teams that stored too much, and what it cost them
- A decision framework built on four axes and how to apply it in your next architecture review

Target audience: Intermediate-to-advanced developers and architects building event-driven systems

Preferred format: Technical session (50 minutes).

Based on architecture guidance and real examples observed across teams at large Dutch enterprises.

Technical requirements: standard projector setup, no live coding. Prepared code snippets and diagrams in slides.

When Virtual Threads Aren't Enough: Coroutines in Spring Boot

Virtual threads have transformed the game. With Spring Boot 4, you can get reactive-level performance using simple, blocking code. WebFlux is no longer required. So why should you still care about coroutines?

Because virtual threads solve the concurrency problem, not the composition problem. When you need to combine multiple async data sources, stream results in real time, or apply backpressure, coroutines and flows remain the most expressive tool on the JVM.

In this workshop, you'll learn when virtual threads are enough and when coroutines give you something virtual threads can't. You'll build a reactive API in Spring Boot from scratch and learn how to:

- Use virtual threads as the default for simple request/response services.
- Switch to coroutines when you need structured concurrency, parallel decomposition, or flow-based streaming.
- Make non-blocking remote API calls with WebClient.
- Access a relational database with the reactive R2DBC driver.
- Create an advanced streaming API based on Server-Sent Events that combines coroutines and flows.
- Write and test reactive API endpoints.

By the end of the workshop, you'll know when to reach for virtual threads, when to reach for coroutines, and how they complement each other in Spring Boot 4. No more choosing between simplicity and power. You'll know how to use both.

Previously delivered at KotlinConf 2024 and Spring I/O 2024. Fully updated for Spring Boot 4 and Java 25+.

Preferred duration: full day (6 hours).

Participants need a laptop with JDK 25+, IntelliJ IDEA, and Docker. All exercises are provided as a prepared code repository.

Technical requirements: projector, flip chart appreciated.