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.
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.
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.
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:
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.
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.
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.
and much more, all with live runnable examples and practiced with exercises.
Plus some extra perks:
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 thesis on Quantum Computation. Before starting to learn programming, I won medals at international Physics competitions.
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.
Just the course with a one-time payment
All of the Rock the JVM courses
Become a Kotlin expert from scratch with our all-inclusive course bundle: master everything you need in one complete package, at a discount
If you're not happy with this course, I want you to have your money back. If that happens, contact me with a copy of your welcome email and I will refund you the course.
Less than 0.05% of students refunded a course on the entire site, and every payment was returned in less than 72 hours.
This site uses cookies. Check our cookie policy (TLDR: no personal information is stored). For more information see our cookie policy.