Kotlin Coroutines - Stop programming the wrong way!
Learn how to successfully program Kotlin Coroutines to build scalable, resilient, bomb proof Coroutines!
Ratings 4.15 / 5.00
What You Will Learn!
- Understand all about the fundamentals of Kotlin Coroutines.
- Understand the underlying design and structure of Kotlin Coroutines and why we need them.
- Knowledge of how to achieve concurrency and scalability.
- Develop Android Apps using Coroutine technology.
- Develop Android Apps using Coroutines that interfaces with Callback APIs.
- Develop Android Apps that use modern 3rd party Frameworks.
- Understand cancelling Coroutines and what that means.
- How failures work and how to cope with them.
Description
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.
I dive 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.
Who Should Attend!
- Beginner Kotlin or Android App developer.
- Java developer crossing over to Kotlin or Android App development.
