CODEWITHSUNDEEP
kotlindartasynchronousasync-awaitkotlin-coroutines
Advitiay Anand
Advitiay Anand

Reputation: 37

How are Kotlin coroutines different from async-await in Dart?

Dart makes asynchronous programming extremely easy. All you need to do is surround the asynchronous code in an async method, and within it, use await before every call that is going to take a while.

I'm new to Kotlin, and asynchronous programming doesn't seem that simple here. (Probably because Dart is single-threaded.)

It'd be nice to get a rough outline of the differences both languages provide in their implementation of asynchronous code.

Apologize if I miss-stated any facts. Thanks in advance!

Upvotes: 4

Views: 2249

Answers (3)

Marko Topolnik
Marko Topolnik

Reputation: 200168

I'm new to Kotlin, and asynchronous programming doesn't seem that simple here.

In fact, Kotlin takes it to the next level of simplicity: it's almost invisible. For example:

suspend fun main() {
    println("Hello")
    delay(1000)
    println("Hello again")
}

This code, unbeknownst to you, is actually implemented as asynchronous. But you just see simple, sequential code. The compiled code (in case of the JVM backend) has structure something like this:

public static void main(String[] args) {
    System.out.println("Hello");
    globalThreadPool.scheduleAfterDelay(() -> { 
        println("Hello again");
    }, 1000, TimeUnit.MILLISECONDS);
}

On top of that, Kotlin makes it super-simple to adapt any async code you may have today so that you can use in the same native way as the above built-in delay function.

Where people trip up mostly is not this basic scenario, but dealing with more advanced topics like structured concurrency, choosing the right thread pool to run your code, error propagation, and so on.

I haven't studied Dart, but from what I know about the async-await pattern in other languages, whenever you call an async function, you have implicitly created a concurrent task, which is very easy to leak out -- all it takes is forgetting to await on it. Kotlin prevents these bad outcomes by design and forces you to address the concurrency you're creating head-on, instead of decyphering out-of-memory logs from production.

Upvotes: 2

Aivean
Aivean

Reputation: 10882

The most important difference, beside the syntax, is the multithreading model of these languages.

Check this article:

Dart supports multi-threading using Isolates. Right in the introduction to Isolates, it has been said that isolates [are] independent workers that are similar to threads but don’t share memory, communicating only via messages.

While Kotlin (on JVM) uses Java threads under the hood, which have access to shared memory.

async/await in both languages is implemented roughly the same, using CPS (glorified callbacks). The important distinction, in Dart you have single threaded event loop dispatching these callbacks, while in Kotlin on JVM you can have multiple event dispatches working together and continuations (callbacks) running truly in parallel on different threads and sharing memory, with all the benefits and issues resulting from that.

Also, note, Kotlin aims to be a multiplatform language, so while on JVM it has multithreaded model, if you compile Kotlin program into JS backend, it would be single-threaded with event-loop, basically same as Dart.

P.S. Watch this video from Roman Elizarov (designer of coroutines in Kotlin), is has a good overview of coroutine usage and internals.

Upvotes: 0

Dai
Dai

Reputation: 155250

Dart makes asynchronous programming extremely easy. All you need to do is surround the asynchronous code in an async method, and within it, use await before every call that is going to take a while.

Yes (though async+await is not Dart's invention, it dates back to at least C# 5.0 in 2012, which then directly inspired JavaScript, Python, Julia, Kotlin, Swift, Rust, many others, and Dart).

I'm new to Kotlin, and asynchronous programming doesn't seem that simple here.

Kotlin 1.1 has async+await, although await is a postfix method, not an operator unlike in most other languages, but the end-result is the same.

It'd be nice to get a rough outline of the differences both languages provide in their implementation of asynchronous code.

Kotlin and Dart are different languages because they solve different problems, consequently there's simply too much to write about their differences, even when focused entirely on how they handle concurrency and coroutines.

...but in-short, the main difference (as far as you're concerned) is syntactical (which is as far as I can tell: Be aware that I am not a Dart/Flutter nor Kotlin expert, I just know how to read documentation and use Google)

I suggest seeing some simple examples in Kotlin, such as:

Upvotes: 3

Related Questions