2

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!

Advitiay Anand
  • 23
  • 8
  • 1
    "Dart is single-threaded" - yes-and-no. [Dart **does** let you _do stuff_ in other threads](https://stackoverflow.com/questions/53019756/dart-is-single-threaded-but-why-it-uses-future-objects-and-perform-asynchronous), it's just that Dart is designed to prevent concurrent access to resources/objects/memory from different threads. – Dai Nov 15 '21 at 21:41
  • 1
    Also, [Kotlin has `async` + `await` too](https://kotlinlang.org/docs/whatsnew11.html#coroutines-experimental) - so I'm not sure why you're having difficulties. – Dai Nov 15 '21 at 21:46
  • 1
    "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. – Dai Nov 15 '21 at 21:49

3 Answers3

3

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:

Dai
  • 141,631
  • 28
  • 261
  • 374
2

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.

Marko Topolnik
  • 195,646
  • 29
  • 319
  • 436
  • Then, suspend replaces both async and await keywords? And how do jobs, dispatchers and scopes fit in? – Advitiay Anand Nov 17 '21 at 19:10
  • Yes, calling a suspendable function is like `await asyncFunc()`. Job is a handle to a concurrent coroutine, like `Thread` in Java. You can inspect its state and cancel it. You can also get its children. Dispatcher encapsulates the concern of executing the coroutines. This is needed because Kotlin, like Java, has threads exposed to the programmer first-class, and there is freedom to choose on which thread/pool to execute coroutines. Coroutine scope is a simple object with almost no functionality, but allows to establish coroutine hierarchy and cancel it as a whole. – Marko Topolnik Nov 18 '21 at 10:59
  • But you can still use [`async` and `await` in Kotlin](https://kotlinlang.org/docs/composing-suspending-functions.html#concurrent-using-async). Calling `async { ...computation... }` returns `Deferred` — a cancellable "future" object, that has `suspend` `await` method, that asynchronously awaits future completion and returns its result. – Aivean Nov 25 '21 at 18:07
  • Yes, you just have to make sure not to use it by default, copying the way it's used in other languages. In kotlin you use it only when you really need the concurrency. – Marko Topolnik Nov 26 '21 at 07:14
0

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.

Aivean
  • 10,692
  • 25
  • 39