With @preussler.berlin 👍 at #dcbln25 Thank you @droidcon.bsky.social for inviting me another time to this event!

To optimise, you must measure. To choose the right approach for performance measurement, you must answer the most important question: What do you want to measure?

Which one really scales better for high-concurrency workloads? 🤔 Are there reliable benchmarks comparing coroutine performance with Loom’s virtual threads?

Only 7 days left to buy Coroutines Mastery at a better price!

Boost your Kotlin performance with Project Loom's virtual threads! Say goodbye to `Dispatchers.IO` and run blocking code like it's non-blocking. Faster, simpler, smarter. ⚡ 🔗 Dive in now: kt.academy/article/disp...

Curious about Rich Errors in Kotlin? Here is the first KEEP document, explaining their motivation and implementation: github.com/Kotlin/KEEP/...

Updates to MutableStateFlow should be made using the update function; otherwise, conflicts might cause some updates to be lost.

I will be speaking at #JDDKrakow on October 21-22, 2025! Let's meet in Krakow, Poland - join the conference at: jdd.org.pl #JavaDevelopment #JavaConference #SoftwareEngineering #TechConference #Krakow

A lightweight wrappers over arrays, providing efficient collection processing functions, immutability, equality, and proper type hierarchy. Those are arrays done well, I love it! github.com/daniel-rusu/... #Kotlin #ImmutableCollections #FunctionalProgramming #SoftwareEngineering #DeveloperTips

Ready and excited for today's sessions! Can't wait to share this content with you all. See you all very soon! webinar.kt.academy/why-you-shou... #Kotlin #KotlinCoroutines #Concurrency #AsyncProgramming #DeveloperCommunity

Still debating whether you should introduce coroutines—or where to even begin? Skip the internal tug-of-war and bring your toughest questions to my live Q&A TOMORROW! I’ll be dedicating extra time to answer everything you throw. Last chance to sign up: webinar.kt.academy/why-you-shou...

Coroutines power-user? Grab my brand-new Flow Cheat-Sheet—operators, builders, the whole buffet. 👇 cheat-sheet.kt.academy/flow

Many ask me how to stay in touch with what's happening in Kotlin. My answer is simple: Kotlin Weekly! kotlinweekly.net

In 3 days, we go live! ⏳ Seats are filling up! 👉 webinar.kt.academy/why-you-shou... #KotlinCoroutines #StructuredConcurrency #ReactiveProgramming #SoftwareEngineering #KtAcademy

Most people do not even think about cancellation, but it is extremely important, and both Android and backend developers benefit from Kotlin Coroutines cancellation mechanisms. Let me give you some examples.

Coroutines are incredibly powerful, but their hidden complexities can trip up even experienced developers. While this topic is not new, my recent webinar on "Mistakes You Make Using Kotlin Coroutines" was packed — and for good reason!

Teaching Flow for years has taught me one thing: developers, including myself, love quick references. So here’s mine—totally free. Join the list, grab the PDF, and tell me what you think! 👉 cheat-sheet.kt.academy/flow

Who should join my free webinar, “Why You Should Use Kotlin Coroutines”? Anyone who wants to START USING COROUTINES CORRECTLY in real projects. 👨💻 Developers 🧑💼 Team Leads & Tech Managers 📊 Project Managers (with a technical background) Reserve your spot: webinar.kt.academy/why-you-shou...

What are the advantages of Kotlin over Java TODAY? Since Kotlin gained popularity, Java has started dynamically introducing features inspired by Kotlin. But what does Kotlin still have up its sleeve, and is it reachable for Java? Here is the list of the most important advantages:

Where should I keep me state in Compose? In component, view model, data layer or outside? This question can be reformulated as: How long do you want it to exist?

Kotlin Coroutines provide special support to interoperate with Java, Swift and JavaScript. Thanks to that, calling suspending functions is a breeze.

Many devs start using technology without understanding it first. That is fine, but some technologies give fake confidence, and devs misuse it without even realizing it. Let me use Kotlin Coroutines as a case study. Thread 👇🧵

Testability is one of the most important advantages of Kotlin Coroutines. It supports operating in virtual time, which lets us write precise, fast, and deterministic tests for cases that are hard to test with other libraries. You can easily check any scenario and assert how much time it would take.

Are you also annoyed by the fact that capitalize was deprecated and the replacement is crazy long? I am, but why did it actually happen?

VOTING 👇 What’s the #1 reason developers avoid or struggle with Kotlin Coroutines? 1️⃣ Seems too complex 2️⃣ Legacy code (RxJava) 3️⃣ Unclear best practices 4️⃣ Don’t know where to start Vote and share your experience in the comments, I’m really curious to hear your stories!

Dispatchers.Default and Dispatchers. IO share the same pool of threads, but each has its own independent limit. The pool is unlimited, and threads are created as needed.

Using apply to make SendGrid API usable 👍

Never make blocking operations on suspending functions without appropriate dispatcher! Most coroutines run on a small pool of threads (Main in Android, Default on backend), and blocking can easily cause thread starvation. The simplest way to fix that is using IO dispatcher, there are better options:

To turn a function into a flow that emits its result, you can just use flow builder with emit. Many projects define a function for that. You can also turn a lambda function using asFlow.

There is amazing interoperability between Kotlin Coroutines and RxJava/Reactor❗

Have you known that in Android Studio you can preview animations, controlling their time or starting them in slow motion. 🐌

Kotlin allows turning nearly any function into a fluent single-expression style. Some love it, some hate it. Let's see how it works, discuss the pros and cons, and decide whether we should do it or not.

One of the most confusing comparison in Kotlin Coroutines is between CoroutineScope and coroutineScope.

In Kotlin we implement interface intersection types using interface delegation. This way we can simply aggregate functionalities of two interfaces into one class. This ScopedRise comes from Arrow library.

Say hello to Kotlin stdlib atomics! One of the most important tools for concurrent applications and libraries is now standarized, multiplatform and really efficient. 💪💪💪

A coroutine can only be cancelled when it gets suspended, so blocking or CPU-intensive operations often need a special attention to support cancellation.

Thank you, Copilot -.-

Dispatchers. IO.limitedParallelism(n) creates a dispatcher that is limited to n threads. It has as little to do with Dispatchers. IO as it has with Dispatchers.Default. I think that is an unintuitive API, so some people prefer defining a top-level function.

I am always disappointed when I see that in Kotlin, but I see it surprisingly often. It makes no sense to make an async call and immediately await its completion. You should call await after the last async.

Have you ever wondered why toUpperCase and toLowerCase were deprecated in Kotlin? The original reason was the Turkish language.

Are your coroutines silently failing? Don’t worry I know a few tricks that can help you eaisily. We’ll cover: ✅ Sync vs async mistakes ✅ Dispatcher misuse ✅ Cancellation gotchas ✅ Structured concurrency traps 📅 July 10 — 2 time zones 👉 Sign up webinar.kt.academy/common-mista...

Exceptions should not be represented with object declarations❗ Even though they look like having no mutable state, they do - each exception contains stacktrace, so each exception must be unique.

People often misuse SupervisorJob, what leads to terrible mistakes❗ Let me explain how it should be used, and how it should be not.

A fake interface constructor returning a private class or object expression is a very common pattern in Kotlin team libraries. It allows us to expose only the interface, which is safe and offers maximum API flexibility.

Kotlin stdlib provides simple but very useful functions that can be called on any value, known as scope functions. Each has its purpose and use cases where it truly shines. Let's discuss let, also, takeIf, apply, with and run.

There is no other feature that shaped so strongly what Kotlin looks like today! Extension functions, one of the most beloved Kotlin features, turned out to be likely the most influential one. Let me explain briefly 👇🧵

Did you know that JetBrains is now in Poland, and recruiting like crazy?!

One important challenge in a bigger project is transforming nested objects. The default solution is using copy; the popular library that helps with that is Arrow Optics, but soon, we might also get a new feature to help us: copy var. 👇🧵

One common mistake is using UI thread for everything on an Android application. Let’s discuss how to property manage dispatchers on smaller and bigger Android applications. 👇🧵

That game was hard to prepare, but I believe now you will have a lot of fun plying it :heart: I challenge you now! Test your coroutines understanding withi this new game! kt.academy/article/game...