Beginner
Intermediate
Advanced
Required
Optional
Intermediate
Kotlin Coroutines & Concurrency
Enhance your Kotlin expertise with our comprehensive course designed for experienced developers. Master Kotlin coroutines and learn to build massively parallel and concurrent applications through hands-on exercises and practical lessons. Perfect for those looking to advance their skills in Kotlin development.
- Duration
- 8h of 4K content
- Lessons
- 22 lessons
By Daniel Ciocîrlan
Money-back guarantee · Unlimited access · Free updates
Course Roadmap
Skills You'll Learn
- Understand parallelism and concurrency at a deep level
- Work with the JVM thread model including Virtual Threads
- Read and write any Kotlin coroutine code
- Test coroutines for your own use case
- Implement different mental models on top of coroutines
- Use suspending functions and coroutine builders
- Apply structured concurrency and cancellation correctly
- Handle errors in coroutines effectively
- Configure coroutine dispatchers and platforms
- Work with Flows and Channels for reactive streams
- Test coroutines and manipulate time in tests
Goal
Coroutines FTW.
You probably know your way around Kotlin by now. Maybe you’ve deployed your JVM server written in Kotlin, maybe you’ve published your first Android app.
After a few thousand lines of code, you probably realized you can write faster code, so you’d like to parallelize your tasks. Or maybe you want to understand how to run actions when a user clicks the “load more” button on your Android app.
Most complex actions in your applications will involve some form of concurrency, and they will likely use coroutines. Few people can confidently work with such code, but this course will show you how to master coroutines.
What are Coroutines?
Light Concurrency.
Coroutines are the Kotlin-specific way of managing concurrency.
What’s that?
Usually, multiple things run at the same time in your application. Maybe background tasks. Maybe while you wait for the database to give you data, you’re handling HTTP requests. Maybe you’re calculating some things in parallel and then you want to aggregate the results.
No matter the situation, we need to organize our computations and tasks in our app. This is concurrency.
The default way of managing concurrency on the JVM is threads. Long story short, they’re terrible. No offense, threads, we love you all. It’s just that the code is a pain to read, understand, debug, maintain, or (knock on wood) grow.
Coroutines fix that.
How This Course Works
Who is this course is for?
This course is for Kotlin developers who need to work with concurrent code. That’s basically every Kotlin developer who wrote a few thousand lines of code.
No matter the application type (server, mobile, web, libraries), you’ll probably need to deal with concurrency:
- parallelizing computations and aggregating results
- updating the UI in your app while tasks are running
- synchronizing conflicting actions
- wait for data without blocking your CPU
- do something else while an operation takes time
If so, you’ll need to know how coroutines work and how to deal with them, and this course is for you.
If this is your first time writing Kotlin, you may want to try Kotlin Essentials instead.
And yes, we write 2000 lines of code from scratch in the course. See attached.
Works on All Platforms.
Once you work with coroutines, you’ll see them everywhere.
This is why this course does not focus on a specific platform, because coroutines work on backend, frontend, Android, server, web, and everything that Kotlin compiles to.
You will learn skills in this course that you can transfer to any library, any platform, and any compilation target.
If you’re looking specifically for something on Android, just about 100% of this course is relevant for you. Coroutines are at the core of any UI action that starts tasks, and we have some dedicated lessons on how to test coroutines, particularly useful for mobile and frontend developers.
100% Hands-On
As with everything else on Rock the JVM, code is king and we write it from scratch.
We have some minimal slides that will give you the basics, and we have them available in the course so that you can refer back to them as “flash cards” if you need.
However, the true learning comes from the real-life examples and exercises, and this course has plenty.
Besides exercises, we also have a project: a mini-Akka framework. You’ve probably heard about the Akka actor model. You’ll get to see how you can write a completely different mental framework on top of coroutines.
More than the code, though, the entire purpose of this course is to expand your mind. You’ll see different forms of concurrency, and you’ll see what it’s like to synchronize threads, or organize coroutines, or send messages to actors. This kind of experience is hard to put into words.
What Our Students Say
Trusted by 100,000+ students worldwide
-
My team is expanding the use of Akka in our products so I needed a quick introduction on this topic. I have tried a couple of courses but the introduction to Akka was always too abrupt, too hard to comprehend. I blamed Akka for this as being too hard to explain. This was until I was exposed to the Rock The JVM courses which were an absolute delight when it comes to presenting such complex topics in such an easy to understand way. And Daniel has not stopped at Akka but has added to his portfolio amazing courses on Scala and Spark too. It seems like he is quite enjoying taking such challenges like complex technologies and making them so simple for everyone. I have instantly recommended Daniel’s work to my team, which helped them immensely with taking their skills to a new level, and I do recommend these courses to anyone who wants to have the fastest ramp-up in these tough but popular technologies.
Mihai FecioruAdobe · California
-
From Scala, to Akka, to Spark, Daniel delivers exceptional material in each and every one of these technologies. I’ve been using them for a long time and there is always something new I will discover from him. The level of detail he gets into as well as the way he delivers material is mindblowing. I personally find his latest course Spark Optimization pure gold and one of a kind. I’ve been using Spark for a year now and I haven’t even thought how much you can leverage query plans to make such optimizations. I can’t stop thinking every time, how he manages to go so deep - because using a technology is one thing, but knowing its internals so well and how everything works behind the scenes is another story when it comes to distributed systems. Long story short Daniel is definitely the best instructor I’ve come across and each one of his courses is the best resource you can find online. Kudos for all your work and knowledge sharing.
Giannis PolyzosVerverica · Greece
-
Daniel’s courses on Scala and Big Data are the best in class. I’ve been in touch with Daniel’s teaching and courses since early 2018. The first course that I took from him was Scala & Functional Programming; I was skeptical about it because over the internet there are many courses you can find, but few really worthy. I remember the very first day when Daniel started to speak and shared his examples - I started to love Scala, and then more as we went on. I am with Scala for the last 5 years now, but never ever has anyone explained to me or gave me comparable resources to Rock the JVM. Daniel gave me a shift in life and helped me crack top tech company interviews. His courses on big data are a must for any aspiring big data developer or data enthusiast. I highly recommend Daniel as an educator both online and on campus.
Anirban GoswamiApple · California
What's Included
Meet Rock the JVM
Daniel Ciocîrlan
Founder, Rock the JVM
I'm a software engineer and the founder of Rock the JVM.
I started Rock the JVM out of love for Scala and the technologies it powers. They are amazing tools, and I want to share as much of my experience with them as I can.
I've taught Java, Scala, Kotlin and related technologies such as Cats, ZIO and Spark to 100,000+ students at various levels. I've held live training sessions for companies including Adobe and Apple, taught university students who now work at Google and Facebook, run Hour of Code for 7-year-olds, and taught more than 50,000+ kids to code.
I have a Master's Degree in Computer Science and I wrote my Bachelor and Master thesis on Quantum Computation. Before learning programming, I won medals at international Physics competitions.
In collaboration with
Riccardo Cardin
Riccardo Cardin is a proud Rock the JVM alumnus and senior software engineer focusing on high-performance systems in Scala, Kotlin and Java.
He is also one of the two leading lecturers of the Software Engineering course inside the Computer Science BSc, hosted by Dipartimento di Matematica of the University of Padova.
Riccardo is actively interested in the application of design patterns and design best practices. He is constantly increasing his knowledge of the software's design and development continuously, which brought him to Rock the JVM.
Enroll now!
Best Value
All-Access Membership
Full (and growing) catalog
$16.25/month
$195 billed yearly —Save 54%
Unlimited access to every Rock the JVM course
- 348 hours of 4K content
- All Scala courses
- All Kotlin courses
- All Typelevel courses
- All ZIO courses
- All Apache Spark courses
- All Apache Flink courses
- All Akka/Pekko courses
- Access to the private Rock the JVM community
- New courses included automatically
The Kotlin Bundle
4 courses, one price
$160Save 35%vs buying separately
All courses in this bundle with a one-time payment
- 4 courses included
- 31 hours of 4K content
- All PDF slides
- Free updates
- Lifetime access
- Access to the private Rock the JVM community
Kotlin Coroutines & Concurrency
Lifetime license
$75Just this course with a one-time payment
- 8 hours of 4K content
- All PDF slides
- Free updates
- Lifetime access
- Access to the private Rock the JVM community
100% Money Back Guarantee
If you're not happy with this course, I want you to have your money back. Contact me with a copy of your welcome email and I will refund you.
Less than 0.05% of students have ever asked for a refund — and every payment was returned in under 72 hours.