Without boats, dreams dry up

This is an announcement regarding the resolution of the syntax for the await operator in Rust.

The biggest unresolved question regarding the async/await syntax is the final syntax for the await operator.

This is my second post on the design of generators.

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.

In the previous post, I provided a lot of background on what the waker API is trying to solve.

Work on supporting async/await in Rust continues to progress rapidly.

We all know that classic aphorism: Year comes to an end, Rust blog post press send.

This blog post is about a project called Romio that I’ve been working on over the past two or three weeks.

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.

Rust 2018 is almost out the door, but there is one big decision the language team has yet to make.

The post before this one covered how shifgrethor handles rooting: how we track for the garbage collector that this object is alive.

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.

In the previous post I said that in the second post in the series we’d talk about how rooting works.

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’m really excited to share with you an experiment that I’ve been working on for the past 5 or 6 weeks.

Today I realized a new crate called pin-cell.

There are 2 hard problems in computer science: cache invalidation, naming things, and off-by-1 errors.

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.

Recently, I wrote a little a side project to sign git commits without gpg.

Unlike most git users, I try to sign my commits.

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 to a different, anonymous future type for each implementati…

Async/await continues to move along swimmingly.

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.

It’s hard to believe its been almost 6 weeks since the last post I made about async/await in Rust.

I’m planning to release a 1.0.0 version of failure on March 15.

Two posts ago I proposed a particular interface for shipping self-referential generators this year.

I did not plan to write this blog post.

In the first post, we looked at the relationship between generators and a more general notion of self-references.

Last time we talked about the broader problem that generators with references across yield points represent: self-referential structs.

This is the first in a series of blog posts about generators, async & await in Rust.

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.

The Rust project has requested blog posts about the project’s goals for 2018.

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).

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.”

I’ve just published failure 0.1.1 to crates.io.

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.

cargo gained a new feature this week!

Previously, I attempted to maintain a blog using GitHub Pages.

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 which implements trait Omega… That is, if Foo and Bar are both Al…

A while ago I was considering an idea, so I wrote a tweet to ask what folks thought about it.