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.

What to Expect

Enrollment for this first cycle of the course is limited to the first 25 students, and closes on Friday, June 20. This cycle begins Monday, June 23, and runs three months.

⭐ Each week you'll get access to either a new video or a live Q&A session.

⭐ Watch the videos on your own schedule during the week.

⭐ Plan for 60-90 minutes each week to watch the videos and write some code.

⭐ Students enrolling in the first cycle get the course for a reduced rate!

What Experience Do I Need?

This course covers coroutines and concurrency in Kotlin, so you'll want to have a basic understanding of Kotlin, including things like lambdas, scope functions, and extension functions. 

If you're brand new to Kotlin, start with my book, Kotlin: An Illustrated Guide. Once you've ramped up, you'll be ready to join a future cycle.

What's in store?

✅ Coroutines and suspending functions
✅ Coroutines in the standard library
✅ Builders and scopes
✅ Context and dispatchers
✅ Wrapping futures & callbacks

✅ Managing shared mutable state
✅ Main-safety conventions
✅ How to use the Flow API
✅ Structured concurrency
✅ Coroutine debugging tools

✅ Testing coroutine-based code
✅ Using coroutines in popular frameworks
✅ Advanced exceptions and cancellations
✅ Managing timeouts in coroutines
✅ Channels, producers, and actors

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.