Steve Klabnik

“The most violent element in society is ignorance.” - Emma Goldman

Read this first

I’m joining Cloudflare

Cloudflare logo.png

Yesterday, I signed an offer letter from Cloudflare. I’ll be the product manager of Storage, which is the part of the company that’s working on data storage products for the Cloudflare Workers platform. I’ll be starting at the end of the month.

I think a lot of you will say “that makes perfect sense,” but many more will say “wait, what?”. I hope this post will make things a bit more clear.

Before we start, I also want to say that I’ll still be continuing my work on Rust, though obviously in a more limited capacity. I’ll still be working on revisions to The Rust Programming Language, and doing core team work, for example.


Before I worked on Rust, I worked on and with Ruby on Rails. When I got out of the web application game, the hot topic was this new “platform as a service” stuff. I’ve been watching all of the latest changes from afar, and they’ve been quite interesting. I’ve...

Continue reading →


What comes after “open source”

In a previous post, I discussed the history of open source, and ended with this claim:

Today’s developers have never learned about this history, or don’t care about it, or actively think it’s irrelevant. … For the same reasons that “open source” came up with a new name, I think the movement that will arise from today’s developers will also need a new name.

We talked about the ideological history of open source, but that’s not what developers object to, really. I don’t think developers are moving back towards a world of making source code private. Instead, it’s something related to a very old discussion in free software. To quote the FSF:

“Free software” means software that respects users’ freedom and community. Roughly, it means that the users have the freedom to run, copy, distribute, study, change and improve the software. Thus, “free software” is a matter of liberty, not price. To...

Continue reading →


Rust has finally outgrown me

Today is a very interesting day. It’s giving me a lot of feels. Today is Rust Latam, a Rust conference in Montevideo.

And I’m not there.

This is significant because, as far as we know, I’m the only person who has been to every Rust conference in existence so far. I went to RustCamp, all three RustConfs, all five RustFests so far, all three Rust Belt Rusts. One RustRush. Am I forgetting any? Thirteen Rust conferences in the past four years.

I really wanted to attend Rust Latam. The main organizer, Santiago, has been a friend for a very long time. It’s amazing that we’re getting a new conference in this part of the world. There’s been a lot of energy with Rust there for quite a while. It would have been nice to meet all those people whose tweets I’ve seen.

But in the end, I’m still between jobs (news on that soon, hopefully!), and spending that money would be irresponsible. I’m just...

Continue reading →


Learning Ada

I decided to try and learn Ada. I love programming languages. This post documents my attempt, and explains what I learned. This is pretty stream of consciousness and basically is a bunch of random notes, so if you hate that, better close the tab. I typed my thoughts up pretty raw, so I may be incorrect in places too. Let me know if you know the answer to something I don’t!


The first step, of course, is to google:

ada.png

Great! I know that Adacore are sort of the stewards of Ada? Vaguely, that might be wrong. Let’s look at all three of those.

Learn.adacore.com is an interactive learning platform designed to teach the Ada and SPARK programming languages.

Ah, that’s awesome! No installation needed.

The second one looks extremely like spam. It does have a page of learning materials that look legit enough. I wonder if this is a low-effort attempt to make money through ads. Or maybe it’s...

Continue reading →


The culture war at the heart of open source

There’s a war going on. When isn’t there a war going on? But I’m not talking about a physical war here: I’m talking about a war over meaning. This particular war is a fight over what “open source” means.

Let’s take a few steps back.

The Free Software Foundation

People organize into groups for many reasons. This story starts with the story of an organization called the “GNU Project.” It was started in 1983, and here’s the initial announcement on USENET. I’ve pulled out four important paragraphs:

Starting this Thanksgiving I am going to write a complete
Unix-compatible software system called GNU (for Gnu’s Not Unix), and
give it away free to everyone who can use it. Contributions of time,
money, programs and equipment are greatly needed.

I consider that the golden rule requires that if I like a program I
must share it with other people who like it. I cannot in good
conscience sign a...

Continue reading →


What’s next for SemVer

On December 18, 20091, the Semantic Versioning specification was announced. More commonly known as SemVer, it provided guidance for developers regarding software versions:

I propose a simple set of rules and requirements that dictate how version numbers are assigned and incremented. For this system to work, you first need to declare a public API. This may consist of documentation or be enforced by the code itself. Regardless, it is important that this API be clear and precise. Once you identify your public API, you communicate changes to it with specific increments to your version number. Consider a version format of X.Y.Z (Major.Minor.Patch). Bug fixes not affecting the API increment the patch version, backwards compatible API additions/changes increment the minor version, and backwards incompatible API changes increment the major version.

I call this system “Semantic Versioning.”...

Continue reading →


thank u, next

I started working at 15, when I took a job as a pizza cook. Over the next seven years, I moved up the ranks, to a driver, shift manager, and then as part of the “new store opening team.” The franchise was growing, and we needed to help new franchisees open their new stores. I’d travel to where the new store was a week before they would open, help train the new staff, and then work their opening weekend. It was really fulfilling work; if pizza paid as well as tech, I’d seriously consider doing it forever.

One time, somewhere in Maryland, I got a bit ill. It wasn’t a good idea for me to work the rest of the week, but the company’s top brass would usually visit to cut the ribbon on the store. It was about a four hour drive back to home, and our COO graciously agreed to let me come back to the ‘burgh with him, so I could recover at home. On the drive, I asked him what he did before working...

Continue reading →


Thoughts on Rust in 2019

Each year, we ask the community to write blog posts about what they want to see on Rust’s roadmap for the next year. This is my post for Rust in 2019.

Rust 2021: Maturity

This year is also a bit special; in 2018, we introduced “editions” to Rust, on a roughly three-year schedule. So now is not just a good time to think about 2019, but about 2020 and 2021 as well. Rust 2015 was about “stability”. Rust 2018 was about “productivity.” I’d like Rust 2021 to be about “maturity.”

In order to get there, here’s what we need in 2019.

No new features

Emphasis on “new” here. What do I mean by this? Well, there are a few features that are in the pipeline that I do think should land:

  • async/await
  • GATs
  • const generics

And possibly

  • Specialization

None of these features are new; we’ve got their basic designs in place. These features are also significant and foundational; we need async/await...

Continue reading →


Six years with Rust

Today is six years since I first heard of Rust. I wrote a post last year about it.

This past year was… intense. Rust 1.31 was basically Rust 2.0, at least in the marketing sense. I burned myself out getting the first edition of the book together for Rust 1.0, and I burned myself out getting the edition shipped.

Let’s talk about the bad and the good. Bad first so we end on the high notes.

The Bad

This year, the docs team sort of… died. Not entirely, but it’s… different now. We used to have a single docs team that handled most everything docs related. The core of that for the past few years has been me and two others. But early this year, we split the sub-teams into fewer individual teams. The old docs team became the docs team, the rustdoc team, the Rust By Example team, and the Reference team. But we didn’t really attract many more people. We did to some degree! The reference team...

Continue reading →


Clojure’s stability: lessons learned

There’s been some Programming Language Discourse lately, and I have some thoughts. It’s mostly centered around a comment on the orange website:

I would put it simply: Clojure was designed by a thinker, who creates when he is away from the keyboard, not in front of it. When one releases and breaks the code in his head first, very few breaking changes are left for the public releases.

I think, regardless of this person being right or wrong, there’s an interesting question here. Let’s look at the comment this is ultimately responding to:

From the perspective of a (fairly large-scale at this point) app developer: I find it great that Clojure places such emphasis on backwards compatibility. In general, migration to newer Clojure versions is completely painless.

The language has been designed by experienced and mature people and doesn’t go through “let’s throw everything out and start...

Continue reading →