Search

You can now search through our archive !
Please specify a keyword

• Issue #677

  SharedFlow — Practical Examples. How does it work?

  Dilipchandar explains how SharedFlow works in Kotlin coroutines with practical examples, focusing on collector timing and emission handling.
• Issue #675

  Kotlin Coroutine Cancellation: An Advanced Guide

  Omar offers an advanced guide to Kotlin coroutine cancellation, focusing on cooperative mechanisms, common pitfalls, and lifecycle management best practices.
• Issue #673

  Effective Strategies for Testing Asynchronous Kotlin Code

  Ignacio Carrión shares patterns for reliably testing Kotlin coroutines and flows, focusing on controlling coroutine execution in unit tests.
• Issue #671

  Kotlin Coroutines: The real difference between Job.cancel() and Scope.cancel()

  Anatolii Frolov explains the key difference between job.cancel() and scope.cancel() in Kotlin coroutines, focusing on their impact on coroutine lifecycle management in Android.
• Issue #671

  Making Android Code Cleaner with Use Cases

  Siarhei Krupenich advocates for replacing bloated interactors with single-responsibility use cases in Kotlin Coroutines to improve testability, maintainability, and adherence to Clean Architecture principles.
• Issue #670

  Debugging Coroutines in IntelliJ and Android Studio

  Amanda Hinchman shows how to debug Kotlin coroutines in IntelliJ and Android Studio using logging, VM options, and built-in GUI tools.
• Issue #662

  Advanced Exception Handling in Kotlin Coroutines: A Guide for Android Developers

  Dobri Kostadinov provides an in-depth guide on advanced exception handling in Kotlin coroutines, covering topics such as exception propagation in coroutine hierarchies.
• Issue #661

  How To Create a Kotlin Coroutine Scope INSIDE suspend Functions

  Yanneck Reiß shows how to create a coroutine scope inside suspend functions in Kotlin to easily launch async tasks!
• Issue #659

  Android Quiz #3 Coroutines and Flow

  Marcin Adamczewski presents the third installment of the Android Quiz series, focusing on Kotlin Coroutines and Flow.
• Issue #657

  Mastering Kotlin Coroutine Channels in Android: From Basics to Advanced Patterns

  Ioannis Anifantakis shows how using the channel type that suits your use case helps to create robust, scalable Android apps free from callback spaghetti.
• Issue #654

  Kotlin Coroutines: Fix 'Optimised Out' Variables

  Tom Sabel shows how to dynamically enable debug-friendly settings using the idea.active property, ensuring you can inspect coroutine variables without impacting production performance.
• Issue #652

  Using BlockHound to track blocking calls in non-blocking dispatchers

  Marcin Moskała shows how to use BlockHound to track blocking calls in Kotlin Coroutines non-blocking dispatchers.
• Issue #648

  Top 10 Coroutine Mistakes We All Have Made as Android Developers

  Dobri Kostadinov's guide to understanding and avoiding common pitfalls in asynchronous programming with Kotlin Coroutines
• Issue #636

  Android Process Lifecycle + Coroutines == ❤

  Joost Klitsie shows how Kotlin Coroutines and Android Lifecycle are a match made in heaven
• Issue #635

  Composing Suspend Functions

  Tanya Arora dives into the world of asynchronous programming with Kotlin coroutines and unlock the full potential of concurrent computation and parallel processing.
• Issue #632

  Coroutine Cancellation and Timeouts

  Tanya Arora takes a look at how cancellation is a crucial feature of Kotlin coroutines for managing resources.
• Issue #630

  Kotlin Coroutines dispatchers

  Kotlin Coroutines library offers an important functionality that lets us decide which thread (or pool of threads) a coroutine should be running on (starting and resuming). Marcin Moskała shows how this is done using dispatchers.
• Issue #629

  Kotlin Flows — Fundamentals

  Anitaa Murthy continues a series on Kotlin Coroutines, this time examining Kotlin Flows.
• Issue #627

  Cancellation in Kotlin Coroutines

  Marcin Moskała writes about one of the most important mechanisms of Kotlin Coroutines for Android developers, cancellation.
• Issue #627

  Kotlin Coroutine mechanisms: launch v. async

  Amanda Hinchman-Dominguez examines join, await, and coroutine behavior through playful examples.
• Issue #620

  Kotlin Coroutine mechanisms: runBlocking v. launch

  Amanda Hinchman-Dominguez examines coroutine behavior through playful examples.
• Issue #616

  Why Non-Blocking?

  Renato Costa reviews the current status of blocking systems by building and examining a simple Spring Boot application, then introduces Kotlin Coroutines, and how they can help us to model our non-blocking services.
• Issue #612

  Seven demos to understand coroutines: scope, context and Jobs

  Tom Colvin continues his series by examining the inner workings of Kotlin Coroutines, taking a closer look at scope, context, and Jobs.
• Issue #605

  Launch vs Async in Kotlin Coroutines

  Amit Shekhar teaches about Launch vs Async in Kotlin Coroutines. See how the Launch and Async differ from each other and when to use which one.
• Issue #603

  Structured Concurrency for Coroutines: Unraveling the Fundamentals

  Rohit Singh explains some of the fundamentals of structured concurrency under Kotlin Coroutines.