はてなブックマーク

There’s been some discussion about arenas in Rust recently, and I thought I’d write about them. Arenas aren’t something you would typically reach for in Rust so fewer people know about them; you only really see them in applications for various niche use cases. Usually you can use an arena by pulling in a crate and not using additional unsafe, so there’s no need to be particularly skittish around t

This post was originally drafted in August 2018, but I never got around to finishing it. As such, parts of its framing (e.g. the focus on bindgen) are outdated, given the relative infancy of the interop space at the time. I was recently told that the post is still useful in this form so I decided to finish and publish it anyway, while attempting to mark outdated things as such when I notice them.

We’ve recently been making lots of progress on future plans for clippy and I thought I’d post an update. For some background, Clippy is the linter for Rust. We have more than 250 lints, and are steadily growing. Clippy and Nightly Sadly, Clippy has been nightly-only for a very long time. The reason behind this is that to perform its analyses it hooks into the compiler so that it doesn’t have to re

The Rust community lately has been focusing a lot on “async I/O” through the tokio project. This is pretty great! But for many in the community who haven’t worked with web servers and related things it’s pretty confusing as to what we’re trying to achieve there. When this stuff was being discussed around 1.0, I was pretty lost as well, having never worked with this stuff before. What’s all this As

Recently Julia Evans wrote an excellent post about debugging a segfault in Rust. (Go read it, it’s good) One thing it mentioned was I think “undefined” and “unsafe” are considered to be synonyms. This is … incorrect. However, we in the Rust community have never really explicitly outlined the distinction, so that confusion is on us! This blog post is an attempt to clarify the difference of terminol

font-size is the worst. It’s a CSS property probably everyone who writes CSS has used at some point. It’s pretty ubiquitous. And it’s super complicated. “But it’s just a number”, you say. “How can that be complicated?” I too felt that way one time. And then I worked on implementing it for stylo. Stylo is the project to integrate Servo’s styling system into Firefox. The styling system handles parsi

Update: This post got a sequel, Breaking our latin-1 assumptions. I’ve seen misconceptions about Unicode crop up regularly in posts discussing it. One very common misconception I’ve seen is that code points have cross-language intrinsic meaning. It usually comes up when people are comparing UTF8 and UTF32. Folks start implying that code points mean something, and that O(1) indexing or slicing at c

Rust is not a simple language. As with any such language, it has many little tidbits of complexity that most folks aren’t aware of. Many of these tidbits are ones which may not practically matter much for everyday Rust programming, but are interesting to know. Others may be more useful. I’ve found that a lot of these aren’t documented anywhere (not that they always should be), and sometimes depend

Recently we (Felix, Niko, and I) have been working on getting compiler-level GC support for Rust. The plan is to provide a base set of APIs and intrinsics on which GCs can be built, without including an actual GC itself. This blog post serves as status update and a pre-pre- rfc on the designs. I’m also going to walk through the process of coming up with the current design. We’ll soon be posting mo

For a while I’ve been working on a garbage collector for Rust with Nika Layzell. I thought this would be a good time to talk of our design and progress so far. Motivation “Wait”, you ask, “why does Rust need a garbage collector”? Rust is supposed to work without a GC, that’s one of its main selling points! True. Rust does work pretty well without a GC. It’s managed to do without one so far, and we

In every talk I have given till now, the question “how does Rust achieve thread safety?” has invariably come up1. I usually just give an overview, but this provides a more comprehensive explanation for those who are interested See also: Huon’s blog post on the same topic In my previous post I touched a bit on the Copy trait. There are other such “marker” traits in the standard library, and the one

This post is now a part of the official rust book In my previous post I talked a bit about why the RWlock pattern is important for accessing data, which is why Rust enforces this pattern either at compile time or runtime depending on the abstractions used. It occurred to me that there are many such abstractions in Rust, each with their unique guarantees. The programmer once again has the choice be

Edit (Jan 2017): I re-discovered Niko’s post which touches on this and reaches for the same realization. I suspect I subconsciously got the idea for this from that post, at least in part. This is a post that I’ve been meaning to write for a while now; and the release of Rust 1.0 gives me the perfect impetus to go ahead and do it. Whilst this post discusses a choice made in the design of Rust; and

Yesterday I was working on a small feature for the Rust compiler, and came across a situation which really showcased Rust’s awesomeness as a language. There was a struct which was exposed to an API, and I wished to give it access to a list of things known as “attributes”, where the list was a heap-allocated vector. Now, I have two ways of actually giving the struct access to a vector. I can either