Learn how to successfully program Kotlin Coroutines to build scalable, resilient, bomb proof Coroutines!
Asynchronous or non-blocking programming is an important part of the development landscape.
Kotlin solves this problem in a flexible way by providing coroutine support at the language level and delegating most of the functionality to libraries. In addition to opening the doors to asynchronous programming, coroutines also provide a wealth of other possibilities, such as concurrency and actors.
However, while using and learning Coroutines on the surface seem easy and straightforward, when we try to
something vaguely interesting we soon start hitting 'gotchas' - it's not so easy and straightforward after all :( especially when we start adding Android App development to the mix.
Understanding what's going on behind the scenes is essential for building scalable, robust Asynchronous or non-blocking code.
Sometimes the magic of Coroutines can be just that, magic but with a bite!!
This course takes away the mystery to successful Kotlin Coroutine development.
Idive deep behind the scenes, so we can understand what's going on and why...
This is the only way learning becomes knowledge!
So you can take this new knowledge onto your next project and blow colleagues away with your Coroutine skills!!
Topics covered include the basics to the advanced and leaves nothing behind.
We dive into:
1) Why we should use Coroutines?
2) Structured Concurrency.
3) Suspendable functions.
4) Achieving Concurrency.
5) Grouping Coroutines.
6) Android Apps with Coroutines including the Android Jetpack framework.
7) Cancellations.
8) Failures.
9) Supporting Callbacks with Coroutines.
10) Modern 3rd party frameworks with Coroutines.
11) Shared State.
The course also includes a couple of hands on assignments for you to complete along with numerous Quizzes, to help turn your learning into knowledge.
I only ask that you come open minded and ready to learn.
