kotlinx.coroutines

unfortunately they've never really taken off so folks reach for explicit state machines instead. there have been a handful of options on the jvm over the years (e.g. quasar, kilim) but they're all abandoned now, the loom continuation API is internal with no hint of it becoming public, kotlin's aren't serializable and the issue is inactive (https://github.com/Kotlin/kotlinx.coroutines/issues/76), etc.. such a shame

Interestingly, Kotlin Coroutines have been available and in production for a LONG time now. https://github.com/Kotlin/kotlinx.coroutines In fact, Kotlin Coroutines are an brilliant on the android platform. We are talking severely memory and CPU constrained architectures here. That said, Kotlin Coroutines are popularly used in production on server side - https://vertx.io/docs/vertx-lang-kotlin-coroutines/kotlin/ I doubt anyone would switch to Java Virtual Threads anytime soon, unless via Kotlin. Maybe Kotlin will leverage this in its underlying infrastructure.

The constraints of fast startup + "green threads" + easy deployment are actually a sound argument for using Go. The simplicity of the language isn't. Kotlin and Rust also have the "green threads" [1] that Java lacks, both of them can also produce a native binary giving you fast startup. So the claim that "Java solves all the problems that Kotlin does" is not completely true. Finally both Kotlin and Rust can let you write safer concurrent code, because their type systems actually can enforce constraints on what's shared between threads, and what's immutable and safe to accesss. Go gives you nothing in the type system, but there is a thread sanitizer. [1] Here's a Kotlin program that spins up 100K coroutines: https://github.com/Kotlin/kotlinx.coroutines/blob/master/kot...

This reminds me of a POC I did to serialize Kotlin continuation state in order to achieve something similar with Kotlin coroutines. The main issue with that approach is that the continuation context can end up closing over a huge variety of types (since it has to serialize the entire asynchronous stack). There was some discussion in this issue (https://github.com/Kotlin/kotlinx.coroutines/issues/76) about annotating suspend functions so that their continuation only closes over objects compatible with Kotlin serialization. This approach removes the requirement for all non-determinism in the code to go through some kind of framework, which seems like a plus. I think in the future what will happen is someone will build a language with CSP style concurrency that deals with the "update-in-flight" and "persistence" problems. Essentially extend

There's threading, just not as painless as in JVM https://touchlab.co/kotlin-native-stranger-threads-ep-1/ We're even getting early support for multi-threaded coroutines https://github.com/Kotlin/kotlinx.coroutines/blob/native-mt/...

Everywhere I used to use CompleteableFutures, except without ending up with completely unmaintainable code. https://github.com/Kotlin/kotlinx.coroutines/blob/master/cor...

I think the way is to write libraries for these use-cases. There is already a persistence lib for Kotlin Native called KNArch.db https://github.com/touchlab/knarch.db and it supports Android too. We are already using libraries to make easier to use background threads (RxJava, RxSwift) so I don't think it's that hard to implement a cross platform lib for that purpose. JetBrains is already trying to tackle the task with Coroutines for Kotlin Native: https://github.com/Kotlin/kotlinx.coroutines/tree/master/nat...

On JVM and Native kotlin does support coroutines and supports all kinds of concurrency models (including go style goroutines). Check this more details - https://github.com/Kotlin/kotlinx.coroutines/blob/master/cor...