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.

Take this course

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.

Skills You'll Learn

After this course, you’ll be able to:

understand parallelism and concurrency at a deep level
understand and work with the JVM thread model
read and write any code that uses coroutines
test coroutines for your use-case
implement different mental models on top of coroutines

You will learn:

Parallelism vs concurrency
Threads on the JVM
- the Thread model
- Virtual Threads (project Loom)
- Thread synchronization
Coroutines
- Suspending functions
- Coroutine builders
- Structured concurrency
- Cancellation
- Error handling
- Cooperative scheduling (vs preemptive scheduling)
- Configuring coroutine platforms
Advanced coroutine tools
- Flows
- Channels
- Testing & manipulating time

and much more, all with live runnable examples and practiced with exercises.

Plus some extra perks:

You’ll have access to the entire code I write on camera (2000 LOC)
You’ll be invited to our private Slack room where I’ll share latest updates, discounts, talks, conferences, and recruitment opportunities
You’ll have access to the takeaway slides

Meet Rock the JVM

Daniel Ciocîrlan

I'm a software engineer and the founder of Rock the JVM.

I'm a software engineer and the founder of Rock the JVM. I started the Rock the JVM project out of love for Scala and the technologies it powers - they are all amazing tools and I want to share as much of my experience with them as I can.

As of February 2024, I've taught Java, Scala, Kotlin and related tech (e.g. Cats, ZIO, Spark) to 100000+ students at various levels and I've held live training sessions for some of the best companies in the industry, including Adobe and Apple. I've also taught university students who now work at Google and Facebook (among others), I've held Hour of Code for 7-year-olds and I've taught more than 35000 kids to code.

I have a Master's Degree in Computer Science and I wrote my Bachelor and Master theses on Quantum Computation. Before starting to learn 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.

What's Included

Loading...

Take this course now!