Kotlin Coroutines & Flows: The single Most Important Skill to Be Mastered By Any Android Developer in 2024
Learn what every app demands and get into the internals of Android’s native technology for asynchronous & reactive programming.
– This Masterclass contains concepts I’ve never shared before –
You want to…
- … get a clear structure to learn Kotlin Coroutines & Flows as an Android dev?
- … learn about all the deadly traps you can step into with Coroutines & Flows?
- … master a skill that’s a common topic in Android tech interviews?
- … use async programming to multiply the performance of parts of your code?
- … learn all that with real practical use cases and no abstract examples?
Why Every Android Developer Should Know About Coroutines & Flows
Kotlin Coroutines & Flows are the primary native way to implement asynchronous and reactive programming in Kotlin.
Think about it: There is not a single serious app out there that does not require calling certain functions at the same time. Any code that could possibly take a moment to complete has to make use of parallel computing or your app’s performance will be equal to what people were used to in 1995.
Some examples that require Coroutines or Flows: The use of databases, calling remote APIs, reading from and writing to files, UI animations, tracking locations, observing sensor data, listening to a web socket stream.
Can you name any app that does not involve ANY of the above functionalities? This shows that Coroutines & Flows are one of the most fundamental topic for every Kotlin developer.
Developers from these companies are learning with Philipp’s Courses…
What the Kotlin Coroutines & Flows Masterclass Helps You With:
Building Faster Apps
Most Android developers don’t know how to really make use of concurrency and parallel computing to increase the performance of their apps.
With this Masterclass, you’ll always know where and when you can make use of coroutines to speed up parts of your app.
Reducing Bugs
Coroutines appear simple on the surface, but come with a lot of potential traps that cause hard to debug bugs & race conditions in your code.
You’ll learn about all the best practices and anti-patterns when using coroutines & Flows.
Interview Prep
Asynchronous & reactive programming does not only apply to Kotlin and Android apps. This fact makes it a common topic for coding interviews.
The Masterclass helps you to understand the internals, so there’s one less reason for you to fail a tech interview.
Philipp Lackner has over 13 years of experience in the software field. Over the past years, he built a following of over 200,000 developers on social media who trust his work. With over 10,000 sold copies of his courses and 700h+ spent for teaching Android concepts, he already helped hundreds of thousands people to learn practical skills they can immediately apply.
He has a degree in computer science, however it didn’t go as expected. The amount of theory that was taught in university made him think about a better approach to learn what is really needed in the real world. Over time, Philipp found mentors who taught him exactly that in a practical setting. That was the game changer for his career.
After having worked for dozens of companies around the globe as a consultant, Philipp now wants to teach other mobile developers what really counts for becoming an outstanding developer.
Philipp Lackner has over 13 years of experience in the software field. Over the past years, he built a following of over 200,000 developers on social media who trust his work. With over 10,000 sold copies of his courses and 700h+ spent for teaching Android concepts, he already helped hundreds of thousands people to learn practical skills they can immediately apply.
He has a degree in computer science, however it didn’t go as expected. The amount of theory that was taught in university made him think about a better approach to learn what is really needed in the real world. Over time, Philipp found mentors who taught him exactly that in a practical setting. That was the game changer for his career.
After having worked for dozens of companies around the globe as a consultant, Philipp now wants to teach other mobile developers what really counts for becoming an outstanding developer.
700H+
of Created Android content
10,000+
Enrolled Students
13
Years of Experience
Make the self-check!
How Many Issues Can you Spot here?
Click here for the solution...
#1: Blocking call converted to a suspend function without withContext(...). This may freeze the app’s UI thread accidentally.
#2: Constructing a huge string without switching to default dispatcher.
#3: Missing ensureActive() check for cancellation of this coroutine.
#4: Hardcoding dispatchers may break testing this function.
#5: Missing ensureActive() or yield() call to check for cancellation between blocking calls.
#6: Possibly CPU-intensive function call without switching to the default dispatcher.
#7: Using SupervisorJob() as parent coroutine context breaks structured concurrency and won’t grant the error-handling behavior of SupervisorJob in this case. The failure of child1 will cancel child2 despite of SupervisorJob being used.
#8: Hardcoding dispatchers may break testing of this function.
#9: Suspending calls inside a finally blocked will be skipped if the coroutine is in the cancelled state. In that case, clean up wouldn’t happen in the example.
If you did not find these issues, this Masterclass is for you!
Enroll Now
What you will learn in this course
Coroutine Basics
In case you have never heard of coroutines before, this first introductory section is for you: It will teach you about what a coroutine is, Coroutine Scopes, Jobs & Deferreds and how they apply in Android development.
Coroutine Contexts
Did you know that a Coroutine Context behaves similar to a HashMap? In this part you’ll dive into the internals of a coroutine context, different dispatchers and why each dispatcher is better for its use case than others.
Cancellation
Cancellation is among the most error-prone features of coroutines. In this section you’ll learn about what exactly happens when a coroutine is cancelled and how you can prevent super common bugs caused by doing it wrong.
Error Handling
What happens when a coroutine throws an Exception? In this part, you’ll learn what that means internally and how you can set up your coroutines to work just the way you want in case of failures.
Synchronization
Race conditions are a natural byproduct of working with multiple coroutines carelessly. The Masterclass will teach you everything you need to know to confidently synchronize different coroutines with various mechanisms and therefore avoid race conditions completely.
Flow Fundamentals
In this section, you’ll get into Flows and all the different types of Flows you can use in Kotlin:
- Cold Flows vs. Hot Flows
- The Flow builder
- SharedFlow & shareIn()
- StateFlow & stateIn()
- Callback Flows
Flows In Practice
You’ll learn to apply Flow operators in a real practical environment. This means you’ll work with location tracking, web socket connections and more to immediately grasp the practical use of Kotlin Flows.
Testing Coroutines & Flows
Lastly, you’ll learn proven strategies to write automated test cases for your asynchronous coroutines code to make sure you’ll easily catch bugs in future.
These 45+ Videos Are Waiting for You
Get Access to 400 Minutes of Exclusive Video Material
1. Introduction
- How to navigate through the course?
2. Coroutine Basics
- What Is a coroutine?
- Launching your first coroutines
- Suspend functions
- Coroutine scopes
- Jobs & Deferreds
- Coroutines in Jetpack Compose
3. Coroutine Contexts
- What is a coroutine context?
- withContext
- IO & Default dispatcher
- Main & Main immediate dispatcher
- Unconfined dispatcher
- Main-safety
4. Coroutine Cancellation
- Why cancellation seems simple, but is hard
- The consequences of cancellation
- Cancellation trap #1: try/catch
- Cancellation trap #2: Transaction-like behavior
- Cancellation trap #3: try/finally
- ensureActive() vs. yield()
5. Coroutine Error Handling
- How coroutines treat exceptions
- Catching errors with CoroutineExceptionHandler
- SupervisorJob
- coroutineScope & supervisorScope
6. Combining What You've Learnt so Far
- Converting a location callback to a suspend function
7. Synchronization Mechanisms
- When do you have to think of synchronization?
- synchronized and Mutex
- Concurrent lists and HashMaps
- Single thread dispatcher
8. Flow Fundamentals
- What is a Flow?
- The structure of every launched Flow
- SharedFlow
- StateFlow
- stateIn()
- shareIn()
- CallbackFlow
9. Flows In Practice
- Timer Flow
- Location tracking Flow with combine & zip
- Combining UI states
- Listening to a web socket stream
- Handling Flow errors & retrying failed Flows
- flatMapConcat / flatMapMerge / flatMapLatest
- Handling backpressure
10. Testing Coroutines & Flows
- Testing simple suspend functions
- Testing functions that launch coroutines
- Testing Flows
1. Introduction
- How to navigate through the course?
2. Coroutine Basics
- What Is a coroutine?
- Launching your first coroutines
- Suspend functions
- Coroutine scopes
- Jobs & Deferreds
- Coroutines in Jetpack Compose
3. Coroutine Contexts
- What is a coroutine context?
- withContext
- IO & Default dispatcher
- Main & Main immediate dispatcher
- Unconfined dispatcher
- Main-safety
4. Coroutine Cancellation
- Why cancellation seems simple, but is hard
- The consequences of cancellation
- Cancellation trap #1: try/catch
- Cancellation trap #2: Transaction-like behavior
- Cancellation trap #3: try/finally
- ensureActive() vs. yield()
5. Coroutine Error Handling
- How coroutines treat exceptions
- Catching errors with CoroutineExceptionHandler
- SupervisorJob
- coroutineScope & supervisorScope
6. Combining What You've Learnt so Far
- Converting a location callback to a suspend function
7. Synchronization Mechanisms
- When do you have to think of synchronization?
- synchronized and Mutex
- Concurrent lists and HashMaps
- Single thread dispatcher
8. Flow Fundamentals
- What is a Flow?
- The structure of every launched Flow
- SharedFlow
- StateFlow
- stateIn()
- shareIn()
- CallbackFlow
9. Flows In Practice
- Timer Flow
- Location tracking Flow with combine & zip
- Combining UI states
- Listening to a web socket stream
- Handling Flow errors & retrying failed Flows
- flatMapConcat / flatMapMerge / flatMapLatest
- Handling backpressure
10. Testing Coroutines & Flows
- Testing simple suspend functions
- Testing functions that launch coroutines
- Testing Flows
What People Say About Philipp’s Courses
Martin Kiper convinced his interviewers thanks to Philipp’s courses.
“The return of the investment is insane for the courses.”
Rahul Ahuja gained the knowledge needed for an Android job in another country
“What these courses gave me was a push to develop real-world applications rather than doing some proof-of-concept stuff.”
Alon Shlider saved countless hours thanks to Philipp’s courses
“You can try it on your own with the Android docs, but it will take MUCH longer.”
Pavel learned building apps for his clients thanks to Philipp’s courses
“If it wasn’t for him, I wouldn’t be here today.”
Simon applies concepts learned from Philipp’s courses in an app with 5M downloads
“After just 20min, Philipp was able to answer all my questions.”
Esau has the same position as developers with 2 more years of experience
“Philipp’s courses are really worth what they cost.”
This course is for you if…
- … you know about the basics of coroutines, but feel like there are gaps in your knowledge.
- … you want to learn asynchronous & reactive programming for Android from the ground up.
- … you learnt about Kotlin Flows, but don’t really know how you can apply them in practice.
- … you lack a clear structure to learn coroutines because online resources are sprinkled all over the internet.
- … you are sick of all those resources that only cover theory, but don’t show you how things work in a REAL app.
The Masterclass at a Glance
Make a one-time investment for lifetime access to
-
27 Exclusive Videos About Kotlin Coroutines: Learn about the coroutine internals from cancellation to synchronization with practical examples.
-
18 Dedicated Videos on Kotlin Flows: Get into all the different types of Flows and learn about Flow operators in a real-world environment with examples straight from practice.
-
15 Homework Assignments to Practice What You’ve Learnt: Make sure what you learnt really sticks by practicing these concepts in your own pace.
-
Certificate Awarded at the End: At the end of the course, you’ll be able to take a quiz and get a certificate after passing to show future employers that you’ve internalized this topic.
-
Unlimited Access: You can watch the course materials in your own pace at any time.
Total value: 199€
LAUNCH OFFER:
99€
FAQ
What are the prerequisites to take this course?
Other than knowing the basic Kotlin language features and basic Android development, there are no prerequisites for this Masterclass.
Will I get a certificate on completion?
Yes, after following through the course, you can take a final quiz that covers the concepts taught in the course. If you pass it, you will be awarded a certificate you can use to show off that you have the essential skills of software development.
Is there a money back guarantee?
Just as for all of our courses, you get a voluntary 30-day money back guarantee in case you’re not satisfied with the course content.
Is this course for any kotlin developer?
This course covers all the core concepts of Kotlin coroutines & Flows which apply to any Kotlin based software. The course targets Android developers however and provides most practical examples for Android apps.
Do I get lifetime access?
Yes, it’s a one-time investment into your career to keep access to the course and updates in future.