- feeds
- popular
- recent
- reader
- about
- story
- technologies
- what is rss
- connect
- dmca
- contact
- Feed Preview withoutblogs
My content has moved
My content has moved permanently to https://without.boats/blog
Ringbahn: a safe, ergonomic API for io-uring in Rust
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. In the time since that post, I have implemented a prototype of su...
Notes on io-uring
Last fall I was working on a library to make a safe API for driving futures on top of an an io-uring instance. Though I released bindings to liburing called iou, the futures integration, called o...
The problem of effects in Rust
In a previous post, I shortly discussed the concept of “effects” and the parallels between them. In an unrelated post since then, Yosh Wuyts writes about the problem of trying to write fallib...
A brief apology of Ok-Wrapping
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. This is has also always been a feature with very ...
From failure to Fehler
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 week, its current maintainer decided to d...
What constitutes a vulnerability?
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 ...
waitmap - an async awaitable map
I’ve just released a new crate called waitmap. This is a concurrent hash map (built on top of dashmap) intended for use as a concurrency primitive with async/await. It extends the API of dashma...
Global Executors
One of the big sources of difficulty on the async ecosystem is spawning tasks. Because there is no API in std for spawning tasks, library authors who want their library to spawn tasks have to dep...
iou: Rust bindings for liburing
Today I’m releasing a library called iou. This library provides idiomatic Rust bindings to the C library called liburing, which itself is a higher interface for interacting with the io_uring Li...
Asynchronous Destructors
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. There are a wide variety of additional features we could add to asyn...
Notes on a smaller Rust
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 ...
Update on await syntax
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. That was last Thursday, and we did reach a decision....
Zero Cost Abstractions
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 ...
A final proposal for await syntax
This is an announcement regarding the resolution of the syntax for the await operator in Rust. This is one of the last major unresolved questions blocking the stabilization of the async/await fea...
for await loops (Part I)
The biggest unresolved question regarding the async/await syntax is the final syntax for the await operator. There’s been an enormous amount of discussion on this question so far; a summary of ...
Generators II: The Question Mark Problem
This is my second post on the design of generators. In the first post, I outlined what an MVP of the feature would look like. In this post, I want to take a look at the first design issue for the...
Generators I: Toward a minimum viable product
We’re still not finished with the design of async/await, but it’s already become clear that it’s time to get the next phases of the feature into the pipeline. There are two extensions to th...
The Waker API II: waking across threads
In the previous post, I provided a lot of background on what the waker API is trying to solve. Toward the end, I touched on one of the tricky problems the waker API has: how do we handle thread s...
The Waker API I: what does a waker do?
Work on supporting async/await in Rust continues to progress rapidly. I’m hoping to write a retrospective on everything that happened in 2018 in a few weeks. Right now we’re closing in on an ...
Organizational Debt
We all know that classic aphorism: Year comes to an end, Rust blog post press send. This is mine. There are lots of cool technical improvements to Rust that I want the project to achieve this yea...
Wherefore art thou Romio?
This blog post is about a project called Romio that I’ve been working on over the past two or three weeks. Romio is a port of a small part of the Tokio project to the newer futures APIs. I star...
Making progress in await syntax
One thing we’ve left as an unresolved question so far in the matter of async/await syntax is the exact final syntax for the await operation. In the current implementation, awaits are written us...
Anchored and Uniform Paths
Rust 2018 is almost out the door, but there is one big decision the language team has yet to make. It has to do with the modules and paths system, so of course it is a very easy decision that no ...
Shifgrethor IV: Tracing
The post before this one covered how shifgrethor handles rooting: how we track for the garbage collector that this object is alive. That isn’t sufficient for implementing a tracing garbage coll...
Shifgrethor III: Rooting
After the digression in the previous post, it’s time to get back to what I promised in the first post: a look at how shifgrethor handles rooting. Shifgrethor’s solution is somewhat novel and ...
Shifgrethor II: Notes on tracing garbage collectors
In the previous post I said that in the second post in the series we’d talk about how rooting works. However, as I sat down to write that post, I realized that it would be a good idea to back u...
The hard parts of talking about open source
Evan Czaplicki, the creator and maintainer of the Elm project (a project that I love by the way) gave a great talk at Strange Loop last month called “The Hard Parts of Open Source.” I really ...
https://boats.gitlab.io/blog/post/the-hard-part-of-open-source/
Shifgrethor I: Garbage collection as a Rust library
I’m really excited to share with you an experiment that I’ve been working on for the past 5 or 6 weeks. It’s a Rust library called shifgrethor. shifgrethor implements a garbage collector in...
New crate: pin-cell
Today I realized a new crate called pin-cell. This crate contains a type called PinCell, which is a kind of cell that is similar to RefCell, but only can allow pinned mutable references into its ...
Thinking about names, as well as scuba diving
There are 2 hard problems in computer science: cache invalidation, naming things, and off-by-1 errors. Naming a project, tool, or concept that you want other people to use is a very hard problem....
Another look at the pinning API
A few months ago we introduced the concept of “pinned” references - pointers which “pin” the data they refer to in a particular memory location, guaranteeing that it will never move again...
My experience with the Rust 2018 preview
Recently, I wrote a little a side project to sign git commits without gpg. When I did this, I decided to use the Rust 2018 edition. I also transitioned an existing library from Rust 2015 to Rust ...
https://boats.gitlab.io/blog/post/my-experience-with-rust-2018/
Signing my git commits without GPG
Unlike most git users, I try to sign my commits. Unfortunately, the only way to do this right now is to use PGP signatures, because that is all that git is able to integrate with. This has meant ...
https://boats.gitlab.io/blog/post/signing-commits-without-gpg/
Async Methods II: object safety
Last time, we introduced the idea of async methods, and talked about how they would be implemented: as a kind of anonymous associated type on the trait that declares the method, which corresponds...
Async Methods I: generic associated types
Async/await continues to move along swimmingly. We’ve accepted an RFC describing how the async/await syntax will work in Rust, and work is underway on implementing support for it in the compile...
Async & Await in Rust: a full proposal
I’m really excited to announce the culmination of much of our work over the last four months: a pair of RFCs for supporting async & await notation in Rust. This will be very impactful for Rust ...
https://boats.gitlab.io/blog/post/2018-04-06-async-await-final/
Async/Await VI: 6 weeks of great progress
It’s hard to believe its been almost 6 weeks since the last post I made about async/await in Rust. So much has happened that these last several weeks have flown by. We’ve made exceptionally g...
Failure 1.0.0 on March 15
I’m planning to release a 1.0.0 version of failure on March 15. Once this happens, I don’t plan to release any further breaking changes to the failure crate (though maybe someday in the dista...
Async/Await V: Getting back to the futures
Two posts ago I proposed a particular interface for shipping self-referential generators this year. Immediately after that, eddyb showed me a better interface, which I described in the next post....
https://boats.gitlab.io/blog/post/2018-02-08-async-v-getting-back-to-the-futures/
Async/Await IV: An Even Better Proposal
I did not plan to write this blog post. I thought that the fourth post in my series would explain how we could go from the generator API in my previous post to a futures API in which you don’t ...
https://boats.gitlab.io/blog/post/2018-02-07-async-iv-an-even-better-proposal/
Async/Await III: Moving Forward with Something Shippable
In the first post, we looked at the relationship between generators and a more general notion of self-references. In the second post, we narrowed down exactly what problem we need to solve to mak...
https://boats.gitlab.io/blog/post/2018-01-30-async-iii-moving-forward/
Async/Await II: Narrowing the Scope of the Problem
Last time we talked about the broader problem that generators with references across yield points represent: self-referential structs. This time, I want to narrow in on the specific problem that ...
https://boats.gitlab.io/blog/post/2018-01-30-async-ii-narrowing-the-scope/
Async/Await I: Self-Referential Structs
This is the first in a series of blog posts about generators, async & await in Rust. By the end of this series, I will have a proposal for how we could expediently (within the next 12 months) bri...
https://boats.gitlab.io/blog/post/2018-01-25-async-i-self-referential-structs/
Announcing a new project: configure
Hi :) I’ve been working on a project called configure, which is intended to create a uniform way to load configuration variables from the environment of the program. Specifically, the goal is t...
My Goals for Rust in 2018
The Rust project has requested blog posts about the project’s goals for 2018. I found myself in pretty much complete agreement with Nick Cameron’s post, so I thought instead I would write abo...
https://boats.gitlab.io/blog/post/2018-01-08-goals-for-rust/
Unsafe Abstractions
Unsafety in Rust is often discussed in terms the primitive operations that can only be performed inside of unsafe blocks (such as dereferencing raw pointers and accessing mutable statics). I want...
https://boats.gitlab.io/blog/post/2018-01-04-unsafe-abstractions/
Not Explicit
Oftentimes when I am conversing about the design of Rust with other users - as on RFCs or the internals forum - I witness a peculiar remark about “explicitness.” It usually goes something lik...
https://boats.gitlab.io/blog/post/2017-12-27-things-explicit-is-not/
Failure 0.1.1 released
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...
Announcing Failure
I’m really excited to announce a new crate I’ve been working on, called failure, and which I’ve just released to crates.io. Failure is a Rust library intended to make it easier to manage yo...
https://boats.gitlab.io/blog/post/2017-11-16-announcing-failure/
Alternative Registries
cargo gained a new feature this week! You can now download dependencies from alternative registries, alongside the dependencies you download from crates.io. This is an important step in enabling ...
https://boats.gitlab.io/blog/post/2017-10-28-alternative-registries/
Blogging With GitLab and Hugo
Previously, I attempted to maintain a blog using GitHub Pages. I was very unsuccessful at actually producing blog posts, though. I don’t care a lot about the appearance or maintenance of my blo...
https://boats.gitlab.io/blog/post/2017-09-28-blogging-with-gitlab-and-hugo/
Handshake Patterns
The problem: defining a ‘handshake’ protocol between two traits You have a problem that decomposes in this way: you want any type which implements trait Alpha to be composable with any type w...
https://boats.gitlab.io/blog/post/2017-01-21-handshake-patterns/
The Rust module system is too confusing
A while ago I was considering an idea, so I wrote a tweet to ask what folks thought about it. A very spirited discussion followed about the Rust module system and what the pain points with it wer...
https://boats.gitlab.io/blog/post/2017-01-04-the-rust-module-system-is-too-confusing/
About me
This is the blog of withoutboats, a Rust contributor and a stack of labrador puppies in an overcoat.