Search

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

• Issue #721

  Kotlin Coroutine bridges: converting any callback-based Android API to suspend functions

  Jaewoong Eum explains the suspendCoroutine bridge pattern for converting callback-based Android APIs into clean suspend functions.
• Issue #721

  IntelliJ IDEA Introduces New Coroutine Warnings

  Marcin Moskala walks through new IntelliJ IDEA warnings for common Kotlin coroutines misuses, including awaitAll, currentCoroutineContext, and more.
• Issue #714

  What Really Is Structured Concurrency In Kotlin?

  Philipp Lackner explains structured concurrency in Kotlin coroutines, using a cooking analogy to illustrate concurrency concepts.
• Issue #710

  Kotlin Coroutines Cancellation and Exception Handling

  Vasya Drobushkov clarifies cancellation and exception handling in Kotlin coroutines and suggests relying on safe return types over exceptions.
• Issue #703

  How to Prevent Race Conditions in Kotlin Coroutines

  Dave Leeds shows several tools to choose from to prevent race conditions, including atomics, confinement, mutexes, and more.
• Issue #701

  Recover Kotlin coroutine traces with Decoroutinator

  Reformator introduces Decoroutinator for restoring accurate coroutine call stacks by generating auxiliary frames and continuing suspended continuations to reveal the true trace.
• Issue #701

  stacktrace-decoroutinator

  Small lib for recovering stack trace in exceptions thrown in Kotlin coroutines
• Issue #700 🎉

  Inside Kotlin Coroutines: State Machines, Continuations, and Structured Concurrency

  Ioannis Anifantakis dives deep into the Finite-State-Machine (FSM) transformation that powers Kotlin Coroutines, from Compiler Mechanics to Structured Concurrency.
• Issue #700 🎉

  Mastering Kotlin Coroutines: Dispatchers, Jobs, and Structured Concurrency

  Ignacio Carrión explains proper use of Dispatchers, Jobs, and structured concurrency to manage coroutine context, lifecycle, and error isolation in Kotlin.
• Issue #697

  Discussing Kotlin Coroutines with Marcin Moskała

  Sebastian and Márton chat with Marcin Moskała about coroutines
• Issue #694

  EasyAndroidPermissions

  A lightweight Android library for easy runtime permission handling with Kotlin coroutines and Jetpack Compose - no more callbacks, just clean suspend functions.
• Issue #694

  The Golden Rule of Coroutine Exceptions

  Baljeet Singh details structured concurrency and exception handling patterns in Kotlin coroutines.
• Issue #694

  Threads vs. Kotlin Coroutines vs. Dispatchers - The Last Video You'll Need

  Philipp Lackner explains the differences between threads and coroutines in detail. You'll understand exactly what blocking code is, multithreading vs. parallelism and more.
• Issue #687

  How to Build Scalable AI Agents with Kotlin, Ktor & Koog

  Using Kotlin Coroutines and Ktor we can easily build reactive, and lightweight services and by leveraging Koog, the Kotlin-based framework for building and running AI agents.
• Issue #686

  Kotlin Coroutines - Detailed Animation Visualizer

  Kotlin Coroutines - Detailed Animation Visualizer: watch step-by-step execution with detailed logging.
• Issue #679

  Kotlin Coroutines - Debugging Tools Overview

  Dave Leeds' quick fly-by of a few coroutine debugging tools you might have missed in IntelliJ IDEA and Android Studio.
• Issue #679

  Kotlin Coroutine Gotchas

  Dave Leeds shares a few common Kotlin Coroutine bloopers that can take you by surprise if you're not watching for them.
• Issue #678

  Free Webinar — Understanding structured concurrency in Kotlin Coroutines

  Marcin Moskala is hosting a free live webinar to break down structured concurrency with clear examples — showing both the best practices and the most common pitfalls.
• 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.