Kotlin Coroutines and Concurrency 

If you've been writing coroutine code and just "hoping" that it's right, or if you gave up and settled for other solutions... now's the time to get a full, cohesive mental model that enables you to be effective with coroutines. Once you connect all the dots, you'll be ready to build concurrent and asynchronous apps like a pro!

 

Learn with Ease

Grow your understanding one step at a time, with each lesson building upon earlier lessons.

Craft a Solid Mental Model

Understand how coroutines work, and use them effectively wherever you need them.

Code with Confidence

Know what your coroutines are doing, and eliminate the guesswork.

Learn Coroutines the Easy Way

Asynchronous code. Shared mutable state. Structured concurrency. Context. Scope. When learning coroutines, it can be difficult to know where to start.

Many Kotlin developers have tried piecing together information from different blog posts and articles, hoping to get the full picture, but often end up walking away more confused than ever.

It's not just you!

I had used coroutines in production for years. I'd read the documentation and other articles, watched the conference talks, and even dug into the source code. But still, I always felt it was likely I'd do something wrong with them. For a long time, I just didn't have the same confidence when writing coroutine code as I did with the rest of my code.

But then, while researching and preparing to write the coroutines chapter of my book, Kotlin: An Illustrated Guide, I couldn't put things off any longer - I had to wrestle with the concepts until I figured out how to present them in ways that would be fun, relatable, and accessible.

And you know what I discovered?

The reason many developers struggle with coroutines isn't because they're inherently difficult to understand. Coroutines are often just introduced in overwhelming ways, diving right into asynchronous code, or jumping into the depths of how the internals are structured.

Don't waste your time trying to piece together tidbits of information from lots of small articles about coroutines, hoping to form a full picture. It's a lot of work - trust me! That's why I've designed this course - to ease you into the concepts from beginning to end.

If you've been writing coroutine code and just "hoping" that it's right, or if you gave up and settled for other solutions... now's the time to get a full, cohesive mental model that enables you to be effective with coroutines. Once you connect all the dots, you'll be ready to build concurrent and asynchronous apps like a pro.

The Early Access Advantage

Join today and get access to live calls where I can help answer your questions and clear up confusion. These live sessions happen every third week during the early access season, giving you regular opportunities to get extra assistance.

In between the live call weeks, new course modules are released - typically on Mondays - so you'll keep making steady progress each week.

Early access runs through October 2025, so if you’d like to be part of the live sessions and help shape the course while it’s being built, now's the time to jump in!

What are you waiting for?

Start crafting your coroutines with confidence!

Join The Course

What's covered in this course?

The course is still in early access, with 11 of 12 units complete, totaling almost 9 hours of content. Below is the list of units and lessons, along with the runtime in minutes for each unit.

Coroutines and Suspending Functions (35m)

âś… Intro to Coroutines and Concurrency
✅ Suspending Functions
✅ Coroutines in the Standard Library

Builders, Dispatchers, and Context (35m)

✅ You'll Need a Scope...
✅ Coroutine Builders: launch() and async()
✅ Threads and Dispatchers
✅ Coroutine Context
✅ Ways to Get a Scope

Shared Mutable State (33m)

✅ Intro to Shared Mutable State
✅ Avoiding Shared Mutable State
✅ Confinement
✅ Mutex Locks
✅ Atomics

Structured Concurrency 1 (46m)

✅ Structured Programming & Concurrency
✅ Creating Structured Concurrency
✅ Scopes and Suspending Functions
✅ Structured Concurrency in Practice

 Structured Concurrency 2 (49m)

✅ Cancellations
✅ Managing Cancellations

âś… Exceptions in Coroutines
✅ Supervisors
✅ CoroutineExceptionHandler

 Coroutine Usage Patterns (43m)

✅ Avoiding Unnecessary Coroutines
✅ Attaching a Scope to a Lifecycle
âś… Passing Scopes and Dispatchers
✅ Wrapping Callback-Based APIs

Flow 1: Essentials (55m)

✅ Review of Collections and Sequences
✅ Flows, Collectors, and Emitters
✅ Flow Operators
✅ Flow and Cancellations
✅ Flow and Exceptions

Flow 2: Multi-Coroutine Flows (41m)

✅ Intro to Multi-Coroutine Flows
✅ Multi-Coroutine Flow Operators
✅ Putting Flows Together
✅ Flattening Flows

Flow 3: Hot Flows (43m)

âś… Intro to Hot Flows
✅ SharedFlow
✅ StateFlow
✅ Converting Cold Flows into Hot Flows

 Channels (71m)

✅ Intro to Workflows
✅ Channel Basics
✅ Complex Workflows
✅ Produce and Select
✅ Actors
✅ Terminating Channels
âś… Channels and Flows

Testing and Debugging (86m)

âś…Basics of Testing Concurrent Code
✅ Controlling Time in Tests
✅ Testing Coroutines on External Scopes
✅ Testing Flows
✅ Debugging with IDs and Names
✅ Debugging Coroutines in the IDE
✅ The Coroutines Debugging Library

Coroutines in the Wild (in progress)

This module is in progress.

How coroutines integrate with popular libraries and frameworks, like:

✅ Spring Framework
✅ Ktor Server
✅ Compose Apps

Register Today 

Registration is open from Monday, June 16 until Friday, June 20, and space is limited.

Hey, I'm Dave!

I've been coding professionally for over 25 years, and in that time, I’ve seen programming concepts explained both brilliantly and… well, not so brilliantly. What’s always stuck with me is how much storytelling and visuals can help - making complex ideas feel relatable and easier to understand.

Over the years, I’ve found that I love teaching through creative means, whether it’s illustrations, metaphors, or storytelling that helps the concepts stick.

I'm the author of Kotlin: An Illustrated Guide, a book designed to take you from beginner to confident Kotlin developer. You can catch my videos on YouTube to get a feel for my teaching style. And while you're there, join me for The TypeAlias Show livestream, where we cover all the latest things happening in the Kotlin and Android worlds.

Ready to become a coroutines expert?

Start Today

United States

One-Time Purchase in US Dollars

Continue with US Dollars

Europe

One-Time Purchase in Euros

Continue with Euros

Register Today 

Registration is open from Monday, June 16 until Friday, June 20, and space is limited.

Questions & Answers

Register Today 

Registration is open from Monday, June 16 until Friday, June 20, and space is limited.

❤️ Loved by Learners 

Henry

This is by far the best resource I have used to learn coroutines. I have bought and read all the books on the subject I could get my hands on. I have taken multiple courses on the topic but I have never been able to confidently use coroutines until now.

This course filled in the gaps I didn't know I had in trying to learn to use coroutines confidently. It goes beyond learning the syntax you need to explain why each of the parts are required and that makes all the difference!

Phong

The course has been amazing. I’d highly recommend it to anyone looking to dive deep into Kotlin Coroutines and learn how to use them effectively in real-world Kotlin app development.

I have already gained a huge amount of understanding, and now I feel much more confident applying Coroutines and Structured Concurrency in practice with projects I am working on, not only my tasks, but also helping to review the code of my colleagues.

Codrut

This is one of the few courses that I’ve genuinely enjoyed while gaining useful knowledge about concurrency and coroutines.

The concepts are very well-prepared, with detailed explanations of how things work under the hood rather than just showing how to use APIs or libraries. I especially appreciated the visual support and drawings for the harder parts, and the hands-on exercises that helped the concepts stick.


Gaelle

I have been using coroutines in my day to day work but this course has really helped me gain deeper knowledge of the concepts. It also gave me tips on how to test and experiment myself with coroutines and suspending functions.

The course is clear with real life example easy to follow. The exercises help you experiment with the different concepts. Whether you want to start using coroutines or are already using them in your project you will be able to follow and will learn a lot!

Michael

Really great explanations and good exercises. Just about right for me doing this course between work-time.

Paolo

Dave is a really good teacher. He's definitely well prepared. The lessons are divided into sections that aren't too long and are full of examples. I'm happy with my purchase.

Ready to start?

Join the Course