Announcing New Kotlin Coroutines: In Depth Pro Course!

Announcing Our New Kotlin Coroutines: In Depth Pro Course!

Learn how to implement coroutines in a real-world example of an Android application, with structured layers and decoupled dependencies in our new Kotlin Coroutines: In Depth Pro course!

You'll see how to test coroutines, handle errors, and structure concurrency in a clean and stable way.

Keep reading to hear more about it from course instructor Filip Babić:

Why should I take your Kotlin Coroutines: In Depth course?

"A lot of what we, as programmers, do every day in applications is fetch data from databases or network APIs. And to do that properly, you need a great, in depth, understanding of how threading works and what you can apply to your functions to achieve parallel computing.

In this course, you'll see the internal works of Kotlin Coroutines, and how it is one of the best approaches you can use in Android applications for asynchronous programming, in terms of performance, code clarity, and ease of use."

How do you use Coroutines in your job?

"I use Coroutines in nearly all my projects, as a way to communicate to a networking API or a database. Its syntax and ease of use is just amazing, and by using Coroutines correctly, your code becomes so similar to normal sequential code, that you're not even thinking of it as asynchronous programming.

And in the end, you don't have to separate your code from being synchronous and asynchronous, all the while keeping the performant and non-blocking nature of coroutines."

Can you please share a cool Coroutines tip with us?

"When you're working with heavy operations, you don't have to worry about threading, and how to process the values, and return them to the main thread.

You can simply launch a coroutine using the Main dispatcher, and then use `withContext` to compute the value in another thread, and return back to the main thread:

And you don't have to worry about internal works. It's even better if your API is suspended internally, as you can remove the whole `withContext` block. You can apply this to Room and Retrofit calls if you're using support libraries for those frameworks."

Is there anything else you'd like to share about Coroutines?

"Coroutines are extremely fun and interesting to get into, even though they seem like a complex topic.

Once you start working with them, and testing various parts of the API, or playing with custom functions and things you can create, you'll definitely get the idea of how cool they are, and the scale of the cool features you can implement using them."

Filip's Kotlin Coroutines: In Depth course is available for Professional subscribers now!

— Ray