Asynchronous Rust is powerful but has a reputation for being hard to learn. There have been various ideas on how to fix the trickiest aspects, though with my focus being on Tokio 1.0, I had not been able to dedicate much focus to those topics. However, Niko’s async vision effort has recently started the discussion again, so I thought I would take some time to participate. In this article, I collect some previously proposed ideas and offer some new ones, tying them together to explore what could be.
Async from scratch 1: What's in a Future, anyway? | natkr's ramblings
There are a lot of guides about how to use async Rust from a "user's perspective", but I think it's also worth understanding how it works, what those async blocks actually mean. Why you get all those weird pinning errors.
Announcing Topcoat: a framework for building full-stack reactive web apps with Rust | Tokio - An asynchronous Rust runtime
Tokio is a runtime for writing reliable asynchronous applications with Rust. It provides async I/O, networking, scheduling, timers, and more.
Async: What is blocking? – Alice Ryhl
The async/await feature in Rust is implemented using a mechanism known as cooperative scheduling, and this has some important consequences for people who write asynchronous Rust code.
RustFest Interviews Triple Feature: Rust for AAA Game Development; Async Foundations with `async-std`; and Powerful Concurrency Primitives with `crossbeam` :: Rustacean Station
Come journey with us into the weird, wonderful, and wily world of Rust.
Building a mental model for async programs
In my experience writing async programs in Dart and Rust, I have built up a model in my head to avoid bugs caused by async. These bugs are usually hard to find and reproduce, so there is a lot of value in taking preventive measures to avoid them. I hope to improve this model in my head by writing this post and to share them with anyone who might find it helpful.
397 - Challenges with async/await in the control plane | RFD | Oxide
Very early in the development of the control plane, we considered whether to build our big new distributed system using Rust’s async/await or more traditional synchronous threaded code. [RFD 79] discussed this issue and came to the weak conclusion to prefer async/await, in no small part because much of the ecosystem we wanted to use (e.g., low-level http crates) was already async and seemed to be moving further in that direction, and we’d already written some async code.
400 - Dealing with cancel safety in async Rust | RFD | Oxide
While developing the control plane, we’ve found that one of the bigger practical issues has been async cancel correctness: the relatively unpredictable way an async Rust system can behave if futures are dropped [rfd397]. Cancellation is an example of "spooky action at a distance", and having to think about it imposes a significant cognitive burden on authors and reviewers of asynchronous code. Both of these are quite uncharacteristic of Rust.
rumqttc - Rust
A pure rust MQTT client which strives to be robust, efficient and easy to use. This library is backed by an async (tokio) eventloop which handles all the robustness and and efficiency parts of MQTT but naturally fits into both sync and async worlds as we’ll see
Announcing Rust 1.12.1 | Rust Blog
Empowering everyone to build reliable and efficient software.
Rust in 2021
This is my response for this year's call for blog posts. I am writing this as a language implementor, not as a language user. I also don't try to prioritize the problems. The two things I'll mention are the things that worry me most without reflecting on the overall state of the project. They are not necessary the most important things.
One year of Rust | Rust Blog
Empowering everyone to build reliable and efficient software.
Announcing Rust 1.96.1 | Rust Blog
Empowering everyone to build reliable and efficient software.
aturon.log: listening and trust, part 1
For me, most weeks working on Rust are fun — exhilarating, even. But, just like with anything else, some weeks are hard.
Introduction - Learning Rust With Entirely Too Many Linked Lists
Learning Rust With Entirely Too Many Linked Lists