In July, I described a way to make pinning more ergonomic by integrating it more| without.boats
A variation on my previous design for pinned places has occurred to me that would| without.boats
In a high-level language, the programmer is deprived of the dangerous power to update his own program while it is running. Even more valuable, he has the power to split his machine into a number of separate variables, arrays, files, etc.; when he wishes to update any of these he must quote its name explicitly on the left of the assignment, so that the identity of the part of the machine subject to change is immediately apparent; and, finally, a high-level language can guarantee that all varia...| Without boats, dreams dry up
Last week, Tyler Mandry published an interesting post about a problem that the Rust project calls “Barbara battles buffered streams.” Tyler does a good job explaining the issue, but briefly the problem is that the buffering adapters from the futures library (Buffered and BufferUnordered) do not interact well with for await if the processing in the body is asynchronous (i.e. if it contains any await expressions). I think we can better understand the problem if we examine it visually. First...| Without boats, dreams dry up
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. We intended that only users implementing Futures by hand, in the “low-level” register, would have to deal with that additional complexity. And the benefit that would accrue to all users is that futures, being immovable while polling, could store self-references in their state. Things haven’t gone perfectly according ...| Without boats, dreams dry up
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. I realized the point I made about AsyncIterator being the product of Iterator and Future makes a bit more sense if you also consider the “base case” - a block of code that is neither asynchronous nor iterative. It’s also an excuse to draw another fun ASCII diagram, and I’ve got to put that Berkeley Mono license to good use.| Without boats, dreams dry up
I want to wrap up my consideration of the idea of adding new auto traits to Rust with some notes| without.boats
In my previous post, I described the idea of using an edition mechanism to introduce a new auto trait. I wrote that the compiler would need to create an “unbreakable firewall” to prevent using !Leak types from the new edition with code from the old edition that assumes values of all types can be leaked. The response has been pretty optimistic that ensuring this would be possible, even though I wrote in the post myself that I “despair” over how difficult it was. I’ve received a great...| Without boats, dreams dry up
In Rust, there are certain API decisions about what is and isn’t sound that impact all Rust code.| without.boats
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. In a previous post, I wrote about one of the hardest problems for generators: self-referential generators. Unlike the Future trait when we were designing async functions, the Iterator trait is already stable, and it does not take a pinned reference to itself. This means an Iterator cannot be self...| Without boats, dreams dry up
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 into abstractions This post does not introduce any such high-minded concept. It is entirely down in the weeds. That’s partly because it is based on content I removed from the previous post so that post could focus on the higher point.| Without boats, dreams dry up
I’ve just published failure 0.1.1 to crates.io. It’s mostly some incremental improvements to failure that have been suggested since the first release two weeks ago. Improvements to the derive A big change in version 0.1.1 is that the derive can be used without depending on the failure_derive crate separately. All that needs to be done is tagging the extern crate statement with #[macro_use]: // No direct dependency on `failure_derive` #[macro_use] extern crate failure; #[derive(Fail, Debug...| Without boats, dreams dry up
…In that Empire, the Art of Cartography attained such Perfection that the map of a single Province occupied the entirety of a City, and the map of the Empire, the entirety of a Province. In time, those Unconscionable Maps no longer satisfied, and the Cartographers Guilds struck a Map of the Empire whose size was that of the Empire, and which coincided point for point with it. The following Generations, who were not so fond of the Study of Cartography as their Forebears had been, saw that th...| Without boats, dreams dry up
I want to address a controversy that has gripped the Rust community for the past year or so: the| without.boats
In the previous post, I described the goal of Rust’s Pin type and the history of how it| without.boats
The Pin type (and the concept of pinning in general) is a foundational building block on which| without.boats
This post is meant as an explainer about how substructural type theory can be applied in programming| without.boats
For the past few months I’ve been mulling over some things that Russell Johnston made me realize| without.boats
This is a brief note about the definition of iterator.| without.boats
One problem with the design of async Rust is what do about async clean-up code. Consider that you| without.boats
In my previous post, I wrote about the distinction between “multi-task”| without.boats
In the early-to-mid 2010s, there was a renaissance in languages exploring new ways of doing| without.boats
In my previous post, I said that the single best thing the Rust project could do for| without.boats
Four years ago today, the Rust async/await feature was released in version 1.39.0. The announcement| without.boats
Async/await syntax in Rust was initially released to much fanfare and excitement. To quote Hacker| without.boats
One of the most famous anecdotes that forms the basis of the United States’ political self-identity| without.boats
One of the main emphases of my recent posts has been that I believe shipping generators would solve| without.boats
In a previous post, I established the notion of “registers” - code in Rust can be| without.boats
This is the first post in a series of posts about concurrency in Rust, and the different APIs that| without.boats
This is the second post in an informal series commenting on the design of async Rust in 2023. In my| without.boats
It’s been nearly two and half years since I was an active contributor to the Rust project. There are| without.boats
In the previous post in this series, I wrote about how the core state machine of| without.boats
A bit over a year ago, I wrote some notes on a “smaller Rust” - a higher level language| without.boats
Today I made a new release of the iou library, which contains idiomatic Rust bindings to the| without.boats
I’ve just released a new crate called propane, which is a library for writing generator functions. It can only run on nightly:| without.boats
It’s hard to believe that its been more than 3 years since I opened RFC 2000, which defined| without.boats
Last time I wrote about ringbahn, a safe API for using io-uring from Rust.| without.boats
While implementing ringbahn, I introduced at least two bugs that caused memory safety| without.boats
This is just a note on getting the best performance out of an async program.| without.boats
In my previous post, I discussed the new io-uring interface for Linux, and how to create| without.boats
Last fall I was working on a library to make a safe API for driving futures on top of an an io-uring| without.boats
In a previous post, I shortly discussed the concept of “effects” and the parallels| without.boats
I’ve long been a proponent of having some sort of syntax in Rust for writing functions which| without.boats
About two and a half years ago I wrote a Rust library called failure, which quickly became one of| without.boats
This is just a post about something that grinds my gears a bit more than it reasonably should: I| without.boats
I’ve just released a new crate called waitmap. This is a concurrent hash map (built on| without.boats
One of the big sources of difficulty on the async ecosystem is spawning tasks.| without.boats
Today I’m releasing a library called iou. This library provides| without.boats
The first version of async/await syntax is in the beta release, set to be| without.boats
Many people who use Rust for a bit - especially those who like the language but| without.boats
In my previous post I said that the lang team would be making our| without.boats
The idea of a zero cost abstraction is very important to certain| without.boats
This is an announcement regarding the resolution of the syntax for the await| without.boats
The biggest unresolved question regarding the async/await syntax is the final| without.boats
This is my second post on the design of generators. In the first post,| without.boats
We’re still not finished with the design of async/await, but it’s already| without.boats
In the previous post, I provided a lot of background on what the| without.boats
Work on supporting async/await in Rust continues to progress rapidly. I’m| without.boats
We all know that classic aphorism: Year comes to an end, Rust blog post press| without.boats
This blog post is about a project called Romio that I’ve been| without.boats
One thing we’ve left as an unresolved question so far in the matter of| without.boats
Rust 2018 is almost out the door, but there is one big decision the language| without.boats
The post before this one covered how shifgrethor handles| without.boats
After the digression in the previous post, it’s time to get| without.boats
In the previous post I said that in the second post in the| without.boats
I’m really excited to share with you an experiment that I’ve been working on| without.boats
Evan Czaplicki, the creator and maintainer of the Elm project (a| without.boats
Today I realized a new crate called pin-cell. This crate contains a| without.boats
There are 2 hard problems in computer science: cache invalidation, naming| without.boats
A few months ago we introduced the concept of “pinned” references - pointers| without.boats
Recently, I wrote a little a side project to sign git commits without| without.boats
Unlike most git users, I try to sign my commits. Unfortunately, the only way| without.boats
Last time, we introduced the idea of async methods, and| without.boats
Async/await continues to move along swimmingly. We’ve accepted an RFC| without.boats
I’m really excited to announce the culmination of much of our work over the| without.boats
It’s hard to believe its been almost 6 weeks since the last post I| without.boats
I’m planning to release a 1.0.0 version of failure on March 15. Once| without.boats
Two posts ago I proposed a particular interface for shipping| without.boats
I did not plan to write this blog post. I thought that the fourth post in my| without.boats
In the first post, we looked at the relationship between generators| without.boats
Last time we talked about the broader problem that generators with| without.boats
This is the first in a series of blog posts about generators, async & await in| without.boats
Hi :) I’ve been working on a project called configure, which is intended to| without.boats
The Rust project has requested blog posts about the project’s| without.boats
Unsafety in Rust is often discussed in terms the primitive operations that can| without.boats
Oftentimes when I am conversing about the design of Rust with other users - as| without.boats
I’m really excited to announce a new crate I’ve been working on, called| without.boats
cargo gained a new feature this week! You can now download dependencies from| without.boats
Previously, I attempted to maintain a blog using GitHub Pages. I was very| without.boats
The problem: defining a ‘handshake’ protocol between two traits| without.boats
A while ago I was considering an idea, so I wrote a tweet to ask what folks thought about it.| without.boats