Maybe we have a path forward for performance stackful coroutine? More pieces need to fall in place but this looks promising.

This is a very valid question. The most likely answer is somewhat cruel though.

Interesting post which gives plenty of insights on how async Rust is designed and behaves.

Its use cases are indeed limited. It's a success for network IO. For everything else, the free threading might be the path forward once it stabilizes.

Indeed, bugs with async/await can be subtle in Rust.

Or why I'm still on the fence regarding async/await. It's rarely the panacea we pretend it to be.

Interesting explanation of a research paper exploring the possibility of a faster SQLite by focusing on async I/O.

Or why going through an event loop might be more work initially but will make some things easier longer term. Nice way to frame how threads are bringing some opaque state.

Not really Rust specific, this might be an interesting way to structure your code once async gets introduced. Should avoid some of the usual traps.

When you're distributed, this is all about asynchronous communication. You can't walk to a person desk (and you should probably avoid it anyway if colocated).

Time and synchronization are complicated in distributed systems. Luckily there are solutions to try to ease the pain. It's not completely avoidable though.

Good exploration on how and why async Rust was designed. As usual it's not purely for technical reasons, there's a human and community factor to it.

More details are surfacing regarding async and Rust... definitely not a match in heaven it seems.

Beware of the problems coroutines might bring. Some are "obvious" and related to concurrency in general, but some are running deep in their design in C++.

A piece criticizing the asyncio approach in Python (especially considering the performance tradeoffs in this language). Also provides viable alternatives.

This is clearly a dangerous pitfall in the asyncio API.

Nice piece on how to handle asynchronous communication in a remote work setup.

Interesting conversation of the growing pains around the introduction of async/await in Rust.