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 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 Get
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 worked on my first production Kotlin server-side application in 2017 (when Kotlin server-side seemed crazy), a logistics management application for a big plane manufacturer. I've written a lot more code since, I learned a ton, and I want to share everything.
As of February 2024, I've taught Kotlin, Scala and other libraries to 100000+ students at various levels and I've held live training sessions for some of the top 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 (not in Kotlin, yet 😆).
You're in good hands in this course. I'll guide you every step of the way, and our private community at Rock the JVM is full of passionate people just like you.
with Riccardo Cardin
Riccardo is a senior software engineer focusing on high-performance systems in Scala, Kotlin and Java. He's one of my oldest students and long-time collaborators.
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
📹 8 hours of 4K content
👩💻 2000 lines of code written
🏋️ 50+ complex examples and exercises
📽️ 1 real-life project
🤯 1 mind blown away - hopefully yours!
100% Money Back Guarantee
If you're not happy with this course, I want you to have your money back. If that happens, email me at [email protected] 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.
FAQ
1. Does this coroutine course cover Android?
This is beyond Android - this course is 100% focused on Kotlin as a programming language, without caring which platform you're going to write code for.
2. How is a typical lesson like?
We generally create separate mini-applications where we'll explore a certain feature of the Kotlin language, with examples and exercises. Each lesson is about 20-30 mins long.
3. Is this Kotlin coroutines course hard?
If you know your way around Kotlin basics (at the level of the Kotlin Essentials course), you should be fine.
If this is your first time with Kotlin (or first time coding), I recommend you take the Kotlin Essentials course first.
4. Do you give a certificate?
Sure do! You'll automatically get a certificate which you can export and use this to get reimbursed or land your Kotlin job.
5. Can I expense this at my company?
Of course! After you enroll, you'll automatically get a tax-compliant receipt which you can use to reimburse this course with your employer.
6. I'm just starting out with Kotlin. Should I take this course?
Probably not. The essentials course might be better for you.
7. What if I don't like the course?
Money back, easy 💰 Only a handful of people ever asked for a refund on the entire site of 20+ courses, just to give you an idea.
8. Do you have any connection to JetBrains or the Kotlin Foundation?
Nope - this course is not affiliated with JetBrains (the creators of Kotlin), Google or the Kotlin Foundation. I hope they say good things about this course once they see it, though!
9. Do I need to know threads first?
It helps, but it's not necessary. We'll cover all important ideas on JVM threads in the course so that you're well equipped to work with coroutines.