Impressions from KotlinConf 2023

Attending KotlinKonf 2023 (remote) has been great to get an idea of what is happening in the community and the development of the language. The 2 day conference hosted by Jetbrains, the creators of Kotlin, was live streamed on Youtube - perfectly for anyone remote to join and all of that free of charge.

The conference covered a range of topics, including coroutines, Kotlin Multiplatform and compose. Some Spring Framework and compiler (plugin) talks rounded off with some real-world learnings. Kotlin does not only run on backend systems, but also Android (main programming language), Desktop and in the browser (wasm).

All talks are listed on the schedule. The links are:

Besides the excited news about the upcoming features and the future development of the language (static functions like Companion, named based destruction, kotlin notebooks, …), I was positively impressed by the technical level. While other conferences often focus on new features, libraries in the ecosystem and best practises, KotlinConf managed to also dive deeper on some topics and explained the reasoning/problems behind it.

One of these examples is coroutines and how building a simple abstraction is difficult. Structured concurrency is a solution to handle scenarios in which multiple concurrent operations (for example in coroutines, but also threads) are running and one is aborted. Aborting can happen for many reasons¹ and in most cases the other operations should be aborted as well. However, those other operations cannot be just stopped (1) nor left running in the background (2):

1. The operation might have resources open that need to be released/cleaned up/etc.
2. The operation in the background might update (global) state, while the update is not expected anymore or the resource to be updated does not exist anymore. You might have observed this when building UIs, i.e. with React and the useEffect handler.

Summarizing, concurrency is not simple, but Kotlin wants to help developers build correct applications. Deeper understanding is necessary.

There are many topics and aspects to dive into further, I can recommend you go and watch those talks that are interesting to you. Still, I want to particular recommend two talks:

1. Urs Peter’s Kotlin & Functional Programming: pick the best, skip the rest. The talk is a great mix of theory with code insight, best practises touching various topics.
2. Dmitry Kandalov’s Gilded Rose Refactoring Kata. He impressively shows how shortcuts can speed up your refactoring and the refactoring capabilities of modern IDEs.