# kotlin-coroutines Published articles for kotlin-coroutines. This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles. ## How Kotlin Flow Operator Fusion Works and When Ordinary Operators Break It DevFeed: [How Kotlin Flow Operator Fusion Works and When Ordinary Operators Break It]() Original publisher: [Read original article]() Author: Majidshahbaz Published: 2026-09-13T05:43:21Z Content type: article Language: en Sources: [ProAndroidDev - Medium]() Topics: [kotlin-flow](), [Coroutines](), [Code]() Tags: [android](), [code](), [coroutines](), [jetpack-compose](), [kotlin](), [kotlin-coroutines](), [kotlin-flow]() ### AI overview This article investigates Kotlin Flow operator fusion by instrumenting the runtime and comparing pipelines with adjacent fusible operators against pipelines interrupted by an ordinary map() call. It explains that adjacent channelFlow, flowOn, buffer, and produceIn calls can share one underlying channel through FusibleFlow, while an intervening non-fusible operator causes additional wrapper structure. ### Source excerpt Image Generated for the ArticleI Counted Every Hidden Channel Kotlin Flow Creates -- Most Devs Are Wrong About Which Operators Are Freebuffer() and flowOn() are supposed to fuse into one channel when chained. I wrote code to prove it -- and then found four "harmless" operators that quietly break it. Ask any experienced Kotlin developer what happens when you chain .buffer().flowOn(Dispatchers.IO).buffer(), and you'll usually get a confident answer: "it fuses into one channel." That's the folklore, repeated in talks, docs, and Stack Overflow answers. It's also only half true, and nobody seems to have actually checked the other half: which everyday operators quietly stop that fusion from happening. I decided to stop trusting folklore and instrument the actual runtime. Five separate experiments later, I had a very clear, very measurable answer -- and one of the results genuinely surprised me. The Myth, and the Mechanism Behind It Kotlin's coroutines library really does fuse adjacent channelFlow, flowOn, buffer, and produceIn calls into a single underlying channel instead of creating one per operator. This isn't a rumor -- it's real, deliberate behavior, implemented through an interface called FusibleFlow. Here's the actual check, straight from the source: https://medium.com/media/1cd3b407c1f2b2955b3df4be68ca18b5/href When flowOn() or buffer() is called, it checks whether the flow it's being called on already implements FusibleFlow. If it does, instead of wrapping it in a new object, it calls .fuse() -- which updates the existing object's settings (buffer size, dispatcher) in place. No new object. No new coroutine. No new channel. But that check only succeeds if the upstream is already a ChannelFlow. And that's where the folklore quietly stops being true. Building Something to Actually Measure This I wrote two nearly identical pipelines -- one where the fusible operators sit directly next to each other, and one where a completely ordinary map() sits in the middle: https://medi ## IntelliJ's New Kotlin Coroutine Inspections, Explained DevFeed: [IntelliJ's New Kotlin Coroutine Inspections, Explained]() Original publisher: [Read original article]() Published: 2026-03-30T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [IntelliJ IDEA](), [Kotlin](), [kotlin-coroutines](), [Coroutines](), [Android Studio](), [Exception]() Tags: [android-studio](), [exceptions](), [intellij-idea](), [kotlin](), [kotlin-coroutines](), [workshop-learning-programming]() ### AI overview This article explains new Kotlin coroutine inspections introduced in IntelliJ IDEA and also available in Android Studio. It describes warnings for coroutine usage patterns, including preferring awaitAll over await and currentCoroutineContext() over coroutineContext. ### Source excerpt Exploration and explanation of new Kotlin coroutine inspections in IntelliJ IDEA. ## Practical Kotlin Deep Dive: A Book and Course on Kotlin Internals DevFeed: [Practical Kotlin Deep Dive: A Book and Course on Kotlin Internals]() Original publisher: [Read original article]() Author: Jaewoong Eum Published: 2026-02-18T03:55:53Z Content type: article Language: en Sources: [Stories by Jaewoong Eum on Medium]() Topics: [Kotlin](), [Compiler](), [Code](), [Development]() Tags: [analysis](), [android](), [bytecode](), [compiler](), [internals](), [kotlin](), [kotlin-coroutines](), [programming](), [technical](), [technical-interview]() ### AI overview This article introduces Practical Kotlin Deep Dive, a book and companion course focused on Kotlin internals. It describes coverage of bytecode decompilations, compiler source code, KEEP proposals, code examples, Code Playgrounds, and quiz questions across six chapters. ### Source excerpt Most Kotlin developers can write a data class, launch a coroutine, or use lazy without thinking twice. These features work, the code compiles, and the app runs. But there is a gap between knowing how to use Kotlin and understanding what the compiler actually does with your code. That gap is where performance intuition, debugging skill, and technical interview confidence come from. Practical Kotlin Deep Dive is a book designed to close that gap, covering 70 Kotlin topics across 492 pages with bytecode decompilations, compiler source code references, and KEEP proposal analysis that reveal the machinery behind every feature you use daily. In this article, you'll explore what the book and its companion course cover, walking through each of the six chapters with examples of the insights you'll find inside. You'll see how the book approaches topics differently from typical Kotlin resources, what the "Pro Tips for Mastery" sections reveal about internal mechanisms, and how the interactive course format turns that knowledge into verified understanding through Code Playgrounds and 158 quiz questions. Beyond the syntax: Why internals matter Knowing that lazy caches a value on first access is useful. Knowing that the default lazy implementation uses double checked locking with a synchronized block, and that you can switch to a lock free compareAndSet strategy by passing LazyThreadSafetyMode.PUBLICATION, is the difference between using a feature and making informed decisions about it. The same applies across the language. Understanding that every lambda passed to a higher order function creates a Function object on the heap explains why inline exists. Seeing a data class decompiled into seven generated methods explains what the compiler is doing on your behalf. This is the approach Practical Kotlin Deep Dive takes throughout. Rather than describing what Kotlin features do, it examines how they work internally, what bytecode they produce, what design trade-offs the language desi ## 5 Kotlin Internals You Should Know DevFeed: [5 Kotlin Internals You Should Know]() Original publisher: [Read original article]() Author: Jaewoong Eum Published: 2026-02-17T01:29:40Z Content type: article Language: en Sources: [Stories by Jaewoong Eum on Medium]() Topics: [Kotlin](), [Compiler](), [Code]() Tags: [analysis](), [android](), [article](), [bytecode](), [code](), [compiler](), [data-class](), [kotlin](), [kotlin-coroutines](), [programming]() ### AI overview This article explains five Kotlin internals: compiler-generated methods for data classes, thread-safety strategies used by lazy delegates, type erasure for value classes, hidden allocations from higher-order functions and their removal through inline functions, and the JVM compilation of extension functions. ### Source excerpt Unsplash@mrsimonfischer Kotlin makes writing clean, expressive code feel effortless. Features like data classes, lazy properties, and extension functions save you from the boilerplate that Java developers deal with daily. But behind every concise Kotlin feature is a compiler performing real work, generating bytecode, managing thread safety, and making allocation decisions on your behalf. Understanding what the compiler actually produces helps you write more performant code and make better design decisions. In this article, you'll explore five Kotlin internals that most developers should know, revealing what really happens when the compiler transforms your code. You'll examine how a single line data class expands into a full suite of generated methods, how the lazy delegate implements three distinct thread safety strategies, how value class achieves zero cost type safety through erasure, how higher order functions create hidden object allocations (and how inline eliminates them), and how extension functions compile to static methods on the JVM. These insights originate from Practical Kotlin Deep Dive, a book that explores 70 Kotlin topics at this level of depth and The Course: Practical Kotlin Deep Dive, covering the language fundamentals, standard library, coroutines, compiler internals, and Kotlin Multiplatform. Each section below is a window into the kind of "Pro Tips for Mastery" analysis you'll find throughout the book and course. 1. Data class: One line, six generated methods Most developers know that data class auto-generates equals(), hashCode(), and toString(). But the full scope of what the compiler produces from a single line is worth seeing firsthand. Start with this Kotlin class: https://medium.com/media/b1b28a62953d8d21ec6bb27a95216361/href One line. Two properties. Now look at what the Kotlin compiler generates when this is decompiled into Java bytecode: https://medium.com/media/a9bbcc4370d6da0f974bf53f903967f9/href The data keyword is an instruction t ## Kotlin Coroutines Cancellation and Exception Handling DevFeed: [Kotlin Coroutines Cancellation and Exception Handling]() Original publisher: [Read original article]() Published: 2026-01-11T00:00:00Z Content type: tutorial Language: en Sources: [Vasya Drobushkov]() Topics: [kotlin-coroutines](), [cancellation](), [Exception handling](), [Kotlin](), [Concurrency]() Tags: [cancellation](), [concurrency](), [coroutines](), [exception-handling](), [kotlin](), [kotlin-coroutines]() ### AI overview This article explains why cancellation and exception handling in Kotlin coroutines are difficult, emphasizing that the concepts are distinct but coupled. It discusses the flexibility and hidden complexity of the coroutine API and introduces explanations and best practices for learning and using these mechanisms. ### Source excerpt Cancellation and exception handling in coroutines is by far the most complex thing I've faced during my entire career. These two things are so complicated that I sometimes ask myself how people are using such a difficult-to-use framework. I read all the possible docs that I found, many different articles, video courses, and even tried to look at the code - and still, I feel that my understanding of this topic is quite bad. When reading articles, I often thought that their structure was not good and that things were not clarified in a reasonable way. Usually, articles are just a collection of examples that show how certain combinations of suspending functions or coroutine builders will work. Learning by examples is good, but they should help with understanding core concepts so that all other situations are easy to relate to what was learned. ## How to Prevent Race Conditions in Coroutines DevFeed: [How to Prevent Race Conditions in Coroutines]() Original publisher: [Read original article]() Author: author@typealias.com (Dave Leeds) Published: 2025-11-24T00:00:00Z Content type: tutorial Language: en Sources: [Dave Leeds on Kotlin - typealias.com]() Topics: [Coroutines](), [kotlin-coroutines](), [Kotlin](), [Concurrency]() Tags: [actor](), [atomicint](), [atomics](), [concurrency](), [coroutine](), [coroutines](), [how-to](), [kotlin](), [kotlin-coroutines](), [limitedparallelism](), [mutex](), [programming](), [race-condition](), [shared-mutable-state](), [state](), [stateflow](), [structured-concurrency]() ### AI overview This tutorial explains that Kotlin coroutines and structured concurrency do not automatically protect shared mutable state from race conditions. It introduces the issue using an example that creates 100,000 random bakery orders. ### Source excerpt Thanks to structured concurrency, there are a lot of concerns that we don't have to handle manually when working with Kotlin coroutines. For example, parent coroutines automatically wait for their children to complete before completing themselves. And when a parent coroutine is cancelled, its children are automatically cancelled, too. But when it comes to shared mutable state - mutable data that multiple coroutines could update at the same time - there's nothing magical in the design of coroutines to ensure that the state is updated properly. ## Suspending functions vs. Flow: When to use which? DevFeed: [Suspending functions vs. Flow: When to use which?]() Original publisher: [Read original article]() Published: 2025-10-28T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Kotlin](), [kotlin-coroutines](), [Coroutines]() Tags: [coroutines](), [flow](), [guide](), [kotlin](), [kotlin-coroutines](), [workshop-learning-programming]() ### AI overview A guide to the differences between suspending functions and Flow in Kotlin Coroutines, including when to use each. ### Source excerpt A comprehensive guide to understanding the differences between suspending functions and Flow in Kotlin Coroutines, and when to use each. ## How to implement a random coroutines challenge generator DevFeed: [How to implement a random coroutines challenge generator]() Original publisher: [Read original article]() Published: 2025-10-20T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [kotlin-coroutines](), [Kotlin](), [Learning]() Tags: [code](), [coroutines](), [game](), [generate](), [generator](), [how-to](), [implement](), [kotlin](), [kotlin-coroutines](), [learning](), [workshop-learning-programming]() ### AI overview This tutorial describes the implementation of a random challenge generator for learning Kotlin Coroutines. It covers representing challenges with a sealed class hierarchy, generating random statements and sub-blocks, supporting different game levels, and improving the algorithm to produce more meaningful challenges. ### Source excerpt A behind-the-scenes look at how to implement a generator of interesting challenges for learning Kotlin Coroutines. ## Discussing Kotlin Coroutines on Talking Kotlin Podcast DevFeed: [Discussing Kotlin Coroutines on Talking Kotlin Podcast]() Original publisher: [Read original article]() Published: 2025-10-17T00:00:00Z Content type: article Language: en Sources: [Kt. Academy]() Topics: [kotlin-coroutines](), [Coroutines](), [Kotlin](), [Development]() Tags: [coroutines](), [development](), [kotlin](), [kotlin-coroutines](), [podcast](), [workshop-learning-programming]() ### AI overview A discussion about Kotlin Coroutines on the Talking Kotlin podcast. The supplied evidence identifies Marcin Moskala as the author and Kotlin instructor, but does not provide further details about the discussion. ### Source excerpt An insightful discussion about Kotlin Coroutines on the Talking Kotlin podcast. ## Kotlin Coroutines Compared with Reactor for Sequential and Asynchronous Operations DevFeed: [Kotlin Coroutines Compared with Reactor for Sequential and Asynchronous Operations]() Original publisher: [Read original article]() Published: 2025-10-06T00:00:00Z Content type: comparison Language: en Sources: [Kt. Academy]() Topics: [Coroutines](), [Kotlin](), [kotlin-coroutines](), [Reactive Streams](), [RxJava](), [async/await](), [Android](), [Back end]() Tags: [android](), [async](), [asynchronous](), [await](), [backend](), [compare](), [comparison](), [coroutines](), [kotlin](), [kotlin-coroutines](), [programming](), [programming-languages](), [reactive-streams](), [rxjava](), [simple](), [time](), [workshop-learning-programming]() ### AI overview This article compares Kotlin Coroutines with Reactor for backend and Android development. It argues that coroutines provide more readable and straightforward syntax for sequential and asynchronous operations, while Reactor requires additional operators, concepts, and patterns. ### Source excerpt A comparison of Kotlin Coroutines and Reactor, highlighting the elegance and simplicity of Coroutines over the complexity of Reactor. ## Suspending functions into blocking functions or CompletableFuture DevFeed: [Suspending functions into blocking functions or CompletableFuture]() Original publisher: [Read original article]() Published: 2025-09-29T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Kotlin](), [kotlin-coroutines](), [Coroutines](), [Java](), [functions]() Tags: [blocking](), [coroutines](), [guide](), [how-to](), [kotlin](), [kotlin-coroutines](), [workshop-learning-programming]() ### AI overview A guide to converting suspending functions into blocking functions or CompletableFuture in Kotlin Coroutines, with advice for APIs used by Java or non-coroutine Kotlin callers. ### Source excerpt A guide on how to correctly convert suspending functions into blocking functions or CompletableFuture in Kotlin Coroutines. ## Kotlin Coroutines and JavaScript DevFeed: [Kotlin Coroutines and JavaScript]() Original publisher: [Read original article]() Published: 2025-09-08T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [JavaScript](), [Kotlin](), [kotlin-coroutines](), [Concurrency](), [Promise](), [TypeScript](), [React]() Tags: [async](), [asynchronous](), [callback](), [coroutines](), [how-to](), [javascript](), [kotlin](), [kotlin-coroutines](), [react](), [typescript](), [workshop-learning-programming]() ### AI overview This tutorial explains how to make Kotlin Coroutines APIs usable from JavaScript and TypeScript projects. It covers converting suspending functions to JavaScript async functions, exposing Flow values through callbacks or wrapper classes, and calling regular or promise-returning JavaScript functions from Kotlin Coroutines. ### Source excerpt How to use Kotlin Coroutines in JavaScript projects, or JavaScript libraries from Kotlin Coroutines. ## Flow from suspending functions and vice versa DevFeed: [Flow from suspending functions and vice versa]() Original publisher: [Read original article]() Published: 2025-08-18T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Kotlin](), [kotlin-coroutines](), [Coroutines](), [functions]() Tags: [coroutines](), [functions](), [guide](), [how-to](), [kotlin](), [kotlin-coroutines](), [workshop-learning-programming]() ### AI overview A guide to converting suspending functions to Flow and converting Flow back to suspending functions in Kotlin Coroutines. ### Source excerpt A guide on how to convert suspending functions to Flow and vice versa in Kotlin Coroutines. ## Suspending functions or flows into callbacks DevFeed: [Suspending functions or flows into callbacks]() Original publisher: [Read original article]() Published: 2025-08-11T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [kotlin-coroutines](), [Kotlin](), [Coroutines](), [callback]() Tags: [callback](), [coroutines](), [guide](), [how-to](), [kotlin](), [kotlin-coroutines](), [workshop-learning-programming]() ### AI overview A practical guide to converting Kotlin suspending functions and flows into callback-based functions using Kotlin Coroutines. ### Source excerpt A guide on how to correctly convert suspending functions or flows into callback-based functions in Kotlin Coroutines. ## Calling blocking functions from suspending functions DevFeed: [Calling blocking functions from suspending functions]() Original publisher: [Read original article]() Published: 2025-07-21T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Coroutines](), [kotlin-coroutines](), [Kotlin](), [interoperability](), [Concurrency]() Tags: [blocking](), [guide](), [how-to](), [interoperability](), [kotlin](), [kotlin-coroutines](), [workshop-learning-programming]() ### AI overview A guide to using blocking library functions with Kotlin Coroutines by converting them into suspending functions or flows. It explains how blocking operations affect the current thread and how to identify whether a function is blocking. ### Source excerpt A guide on how to correctly convert blocking functions into suspending functions in Kotlin Coroutines. ## How to turn callback functions into suspend functions or Flow DevFeed: [How to turn callback functions into suspend functions or Flow]() Original publisher: [Read original article]() Published: 2025-07-14T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Kotlin](), [kotlin-coroutines](), [callback](), [functions](), [Continuation](), [API]() Tags: [callback](), [cancellation](), [continuation](), [coroutines](), [exceptions](), [functions](), [guide](), [how-to](), [interoperability](), [kotlin](), [kotlin-coroutines](), [suspend](), [workshop-learning-programming]() ### AI overview A guide to adapting callback-based APIs for Kotlin Coroutines. It explains how to convert callbacks that return one value into suspending functions and how to adapt callbacks that emit multiple values into Flows, including handling cancellation and exceptions. ### Source excerpt A guide on how to correctly convert callback-based functions into suspending functions or Flows in Kotlin Coroutines. ## A Kotlin Coroutines Guessing Game DevFeed: [A Kotlin Coroutines Guessing Game]() Original publisher: [Read original article]() Published: 2025-06-24T00:00:00Z Content type: article Language: en Sources: [Kt. Academy]() Topics: [Coroutines](), [kotlin-coroutines](), [Kotlin](), [Programming]() Tags: [coroutines](), [fun](), [kotlin](), [kotlin-coroutines](), [programming](), [workshop-learning-programming]() ### AI overview A game designed to test and improve understanding of Kotlin Coroutines. ### Source excerpt A fun game that pushes your understanding of Kotlin Coroutines. ## Coroutines Mastery DevFeed: [Coroutines Mastery]() Original publisher: [Read original article]() Published: 2025-05-23T00:00:00Z Content type: article Language: en Sources: [Kt. Academy]() Topics: [kotlin-coroutines](), [Kotlin](), [Exception handling](), [Concurrency](), [debugging](), [Testing](), [Android](), [Back end]() Tags: [2025](), [android](), [backend](), [coroutines](), [debugging](), [exception-handling](), [kotlin](), [kotlin-coroutines](), [testing](), [workshop](), [workshop-learning-programming]() ### AI overview Coroutines Mastery is a five-week, self-paced Kotlin Coroutines course with video lessons, exercises, twice-weekly live Q&A sessions, and platform discussions. It covers topics including debugging, testing, exception handling, and synchronization issues, and is intended for Kotlin Coroutines users from beginners to advanced developers. ### Source excerpt 5-weeks-long kohort workshop to master Kotlin Coroutines. ## Understanding Dispatchers: Main and Main.immediate DevFeed: [Understanding Dispatchers: Main and Main.immediate]() Original publisher: [Read original article]() Author: Shreyas Patil Published: 2025-04-02T12:22:06Z Content type: tutorial Language: en Sources: [Shreyas Patil's Blog]() Topics: [Coroutines](), [kotlin-coroutines](), [Kotlin](), [Android](), [Programming]() Tags: [android](), [android-app-development](), [android-apps](), [android-studio](), [coroutine](), [coroutines](), [coroutines-flow](), [kotlin](), [kotlin-beginner](), [kotlin-coroutines](), [kotlin-multiplatform](), [main-thread](), [multithreading](), [reactive-programming](), [threadpools](), [threads]() ### AI overview A deep dive into Kotlin coroutine dispatchers on Android, explaining the difference between Dispatchers.Main and Dispatchers.Main.immediate. It describes how HandlerContext dispatches work and when execution is posted to the main thread or performed synchronously on the current thread. ### Source excerpt A deep dive into Kotlin Coroutine Dispatchers. Understand the subtle but important difference between Dispatchers.Main and Dispatchers.Main.immediate in Android. ## Benchmark Insights: Direct State Propagation vs. Lambda-based State in Jetpack Compose DevFeed: [Benchmark Insights: Direct State Propagation vs. Lambda-based State in Jetpack Compose]() Original publisher: [Read original article]() Author: Shreyas Patil Published: 2024-11-19T14:19:27Z Content type: article Language: en Sources: [Shreyas Patil's Blog]() Topics: [Jetpack Compose](), [benchmarking](), [Compose](), [Kotlin](), [Android](), [ui]() Tags: [android](), [android-app-development](), [android-apps](), [android-studio](), [benchmark](), [benchmarks](), [compose-compiler](), [jetpack](), [jetpack-compose](), [jetpack-compose-ui-components](), [kotlin](), [kotlin-coroutines](), [performance](), [recompose](), [ui](), [ux]() ### AI overview This article compares direct state propagation with lambda-based state propagation in Jetpack Compose using a prototype stock-market screen with frequent UI updates. It describes a macrobenchmark setup intended to analyze their performance and recomposition behavior, but the supplied text does not include the benchmark results or conclusions. ### Source excerpt Performance benchmarks of direct state propagation vs. lambda-based state in Jetpack Compose. Learn which approach minimizes recompositions for better UI performance. ## Choosing a Coroutine Dispatcher for Spring Boot Backend Request Handlers DevFeed: [Choosing a Coroutine Dispatcher for Spring Boot Backend Request Handlers]() Original publisher: [Read original article]() Published: 2024-11-13T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [kotlin-coroutines](), [Spring Boot](), [backends](), [Kotlin](), [Ktor]() Tags: [kotlin](), [kotlin-coroutines](), [network](), [spring-boot](), [threads](), [workshop-learning-programming]() ### AI overview This article compares coroutine dispatchers for Spring Boot backend request handlers. It explains how dispatcher choice affects thread usage, blocking operations, coroutine resumption, and request throughput, including examples involving DefaultExecutor, Dispatchers.IO, and Ktor Client. ### Source excerpt Let's explore different dispatchers and find the best one for a backend request handlers. ## Why Kotlin Coroutines simplify asynchronous, non-blocking development DevFeed: [Why Kotlin Coroutines simplify asynchronous, non-blocking development]() Original publisher: [Read original article]() Published: 2024-10-09T00:03:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Coroutines](), [Kotlin](), [kotlin-coroutines](), [multiplatform](), [Android](), [RxJava]() Tags: [asynchronous](), [blocking](), [coroutines](), [kotlin](), [kotlin-coroutines](), [multiplatform](), [reactive-streams](), [rxjava](), [workshop-learning-programming]() ### AI overview This tutorial chapter explains why Kotlin Coroutines are useful for asynchronous programming. It highlights their multiplatform support, lightweight execution, non-blocking imperative and reactive styles, reduced boilerplate, and simpler debugging and maintenance compared with callbacks and reactive streams. ### Source excerpt The explanation of why coroutines stand out and offer us what hasn't been offered by other technologies. ## Orbit Multiplatform wins Kotlin Foundation Grant: A Journey and a Look Ahead DevFeed: [Orbit Multiplatform wins Kotlin Foundation Grant: A Journey and a Look Ahead]() Original publisher: [Read original article]() Author: Matthew Dolan Published: 2024-10-02T13:30:16Z Content type: article Language: en Sources: [Stories by Matthew Dolan on Medium]() Topics: [Kotlin](), [multiplatform](), [Coroutines](), [Library](), [kotlin-coroutines](), [Open Source](), [Android](), [RxJava](), [reactive](), [Programming]() Tags: [android](), [android-app-development](), [coroutines](), [development](), [kotlin](), [kotlin-coroutines](), [kotlin-multiplatform](), [multiplatform](), [mvi](), [open-source](), [orbit](), [reactive](), [rxjava]() ### AI overview The article announces that the Kotlin Foundation awarded a grant to Orbit Multiplatform and reviews the open-source library's evolution. It describes Orbit 1's reactive, RxJava-inspired architecture and debugging and maintenance challenges, then explains the redesign leading to Orbit 2, including Kotlin coroutines, structured concurrency, composition, direct function calls, and a simplified DSL. ### Source excerpt We're thrilled to announce that the Kotlin Foundation has awarded Orbit Multiplatform a grant! This recognition is a tremendous honour and a chance to reflect on Orbit's journey and share our vision for the future. Orbit's Origins Orbit began as an open-source project over five years ago, in September 2019. It was one of the first libraries I co-created with Mikołaj Leszczyński, and its development has been a journey of constant learning and evolution. The Early Days: Orbit 1 I first encountered Orbit when I joined the Android team at Babylon Health in July 2018. Mikołaj had already developed the initial version of Orbit, heavily inspired by RxJava and talks such as Jake Wharton's Managing The Reactive World with RxJava. RxJava's influence was evident in Orbit's reactive approach, with chained operations driving the architecture. However, while this design worked well in some cases, it posed significant challenges -- especially with debugging. For instance, one event could trigger multiple others, leading to hard-to-trace bugs. Additionally, we ran into issues with type erasure due to the use of generics, which made it even harder to maintain the library. Here's an example of the syntax from Orbit 1: data class State(val total: Int = 0) data class AddAction(val number: Int) class CalculatorMiddleware: Middleware by middleware(State(), { perform("addition") .on() .withReducer { state, action -> state.copy(state.total + action.number) } }) While the initial approach was a valuable learning experience, it became clear that Orbit needed a shift. The Transition: Kotlin Coroutines and Orbit 2 In October 2018, Kotlin 1.3 introduced coroutines, offering an opportunity to rethink Orbit's architecture. Coroutines brought structured concurrency to Kotlin, making asynchronous programming more straightforward and less error-prone. However, it wasn't until May 2020 that we began redesigning Orbit's syntax to leverage coroutines. By August 2020, we released ## Job and children awaiting in Kotlin Coroutines DevFeed: [Job and children awaiting in Kotlin Coroutines]() Original publisher: [Read original article]() Published: 2024-07-15T00:00:00Z Content type: tutorial Language: en Sources: [Kt. Academy]() Topics: [Job](), [kotlin-coroutines](), [Structured concurrency](), [cancellation]() Tags: [cancellation](), [job](), [kotlin-coroutines](), [structured-concurrency](), [workshop-learning-programming]() ### AI overview This tutorial explains the Kotlin Coroutines Job context. It describes how each coroutine has its own Job, how parent-child Job relationships support structured concurrency, and how Jobs enable cancellation, completion waiting, and exception handling within a coroutine scope. ### Source excerpt What Job is and how it is the most important context responsible for structured concurrency. [Next page]()