Asynchronous code can be challenging to debug and optimize, especially when dealing with complex coroutine hierarchies and flow transformations. This session reveals practical techniques for tracking down elusive bugs, optimizing performance, and maintaining reliability in coroutine-heavy applications. Drawing from real production experience, we'll explore advanced debugging techniques, common performance pitfalls, and practical solutions for the most challenging scenarios. You'll learn how to effectively use built-in tools, recognize problematic patterns, and implement proven optimization strategies. Key takeways: - Using kotlinx-coroutines-debug - Using BlockHound - Measuring channel sizes, waiting for coroutines in network clients, and the number of active coroutines - Tracking threads use - Measuring buffer sizes - Tracking and finding memory leaks - Choosing appropriate synchronization - Thread management - Designing concurrency - Proper cancellation use

Kotlin Coroutines simplify asynchronous programming, but that simplicity can mask complex challenges. Developers often run into subtle issues like unexpected cancellations or long-running operations that hurt app reliability and performance. This roundtable will focus on sharing real-world mistakes, troubleshooting strategies, and best practices for working with coroutines effectively. What’s a coroutine-related bug or performance issue you’ve encountered that took you a while to diagnose? How do you handle coroutine cancellations or timeouts in your production apps? Where do you draw the line between using structured concurrency and launching global or unstructured coroutines? What tools or techniques do you use to debug or trace coroutine behavior in complex apps? How do you onboard new team members to ensure they avoid common coroutine pitfalls from the start?