Without boats, dreams dry up

In July, I described a way to make pinning more ergonomic by integrating it more fully into the language.

A variation on my previous design for pinned places has occurred to me that would be more consistent with Rust’s existing feature set.

In the previous post, I described the goal of Rust’s Pin type and the history of how it came to exist.

The Pin type (and the concept of pinning in general) is a foundational building block on which the rest of the the Rust async ecosystem stands.

This post is meant as an explainer about how substructural type theory can be applied in programming language design.

In a high-level language, the programmer is deprived of the dangerous power to update his own program while it is running.

For the past few months I’ve been mulling over some things that Russell Johnston made me realize about the relationship between effect systems and coroutines.

This is a brief note about the definition of iterator.

One problem with the design of async Rust is what do about async clean-up code.

In my previous post, I wrote about the distinction between “multi-task” and “intra-task” concurrency in async Rust.

In the early-to-mid 2010s, there was a renaissance in languages exploring new ways of doing concurrency.

Last week, Tyler Mandry published an interesting post about a problem that the Rust project calls “Barbara battles buffered streams.”

When we developed the Pin API, our vision was that “ordinary users” - that is, users using the “high-level” registers of Rust, would never have to interact with it.

I wanted to follow up my previous post with a small note elaborating on the use of coroutines for asynchrony and iteration from a more abstract perspective.

In my previous post, I said that the single best thing the Rust project could do for users is stabilize AsyncIterator.

Four years ago today, the Rust async/await feature was released in version 1.39.0.

Async/await syntax in Rust was initially released to much fanfare and excitement.

I want to address a controversy that has gripped the Rust community for the past year or so: the choice by the prominent async “runtimes” to default to multi-threaded executors that perform work-stealing to balance work dynamically among their many tasks.

I want to wrap up my consideration of the idea of adding new auto traits to Rust with some notes from a conversation I had with Ariel Ben-Yehuda.

In my previous post, I described the idea of using an edition mechanism to introduce a new auto trait.

In Rust, there are certain API decisions about what is and isn’t sound that impact all Rust code.

One of the most famous anecdotes that forms the basis of the United States’ political self-identity is the story of an interaction between Benjamin Franklin and Elizabeth Willing Powel after the Constitutional Convention of 1787, which established the Uni…

I have been devoting a lot of my free time in the past month to thinking about structured concurrency, and a blog post about that is coming soon, but first I want to revisit iterators and generators.

This is the first post in a series of posts about concurrency in Rust, and the different APIs that can exist to support it.

One of the main emphases of my recent posts has been that I believe shipping generators would solve a lot of user problems by making it easy to write imperative iterative code, and especially to make that iterative code interact well with asynchrony and f…

In a previous post, I established the notion of “registers” - code in Rust can be written in different registers, and it’s important to adequately support all registers.

The previous two posts in this series tried to discuss the design of Rust through the lens of some higher level language concepts: First, the notion that programming languages have different registers Second, the idea that not all patterns should be made…

This is the second post in an informal series commenting on the design of async Rust in 2023.

It’s been nearly two and half years since I was an active contributor to the Rust project.

In the previous post in this series, I wrote about how the core state machine of ringbahn is implemented.

A bit over a year ago, I wrote some notes on a “smaller Rust” - a higher level language that would take inspiration from some of Rust’s type system innovations, but would be simpler by virtue of targeting a domain with less stringent requirements for user…

Today I made a new release of the iou library, which contains idiomatic Rust bindings to the liburing library.

I’ve just released a new crate called propane, which is a library for writing generator functions.

It’s hard to believe that its been more than 3 years since I opened RFC 2000, which defined the const generics for Rust.

Last time I wrote about ringbahn, a safe API for using io-uring from Rust.

While implementing ringbahn, I introduced at least two bugs that caused memory safety errors, resulting in segfaults, allocator aborts, and bizarre undefined behavior.

This is just a note on getting the best performance out of an async program.

In my previous post, I discussed the new io-uring interface for Linux, and how to create a safe API for using io-uring from Rust.

Last fall I was working on a library to make a safe API for driving futures on top of an an io-uring instance.

In a previous post, I shortly discussed the concept of “effects” and the parallels between them.

I’ve long been a proponent of having some sort of syntax in Rust for writing functions which return results which “ok-wrap” the happy path.

About two and a half years ago I wrote a Rust library called failure, which quickly became one of the most popular error handling libraries in Rust.

This is just a post about something that grinds my gears a bit more than it reasonably should: I think the habit of applying for CVEs for Rust (and Rust ecosystem libraries) is silly at best and harmful at worst.

I’ve just released a new crate called waitmap.

One of the big sources of difficulty on the async ecosystem is spawning tasks.

Today I’m releasing a library called iou.

The first version of async/await syntax is in the beta release, set to be shipped to stable in 1.39 on November 7, next month.

Many people who use Rust for a bit - especially those who like the language but do not fall in love with it - feel a sense that there must be a smaller, simpler variation on the same theme which would maybe be a little less powerful, but would also be much

In my previous post I said that the lang team would be making our final decision about the syntax of the await operator in the May 23 meeting.

The idea of a zero cost abstraction is very important to certain programming languages, like Rust and C++, which intend to enable users to write programs with excellent performance profiles with relatively little effort.