Last week I had the opportunity to attend Rust Nation UK, a conference about the Rust programming language. In the cloud native world most of our technology is written in Go, and the parts that aren’t tend to be C++ (such as the Envoy Proxy that powers most service meshes). The notable exception is Linkerd with their data plane proxy being written in Rust. They’re not alone of course, a few other cloud native projects leverage Rust too, but it’s not as adopted as other languages.
My own journey with Rust is a strange one. I’ve never built or maintained a serious project with it. However I’ve somehow dabbled with it many times over the years, starting back in the pre-1.0 days. So I’ve both seen the language and ecosystem evolve, whilst never going too deep on the language. Lately I’ve been using it more, including more directly with Kubernetes.
The conference had a day of tutorials that I couldn’t attend, but I was there for the talks on the Friday. What struck me is not how the talks broke new ground, or proposed novel approaches, but how they spoke of gaining adoption and maintaining projects. The presumption is that Rust is already ready for prime time — and now it’s just a case of adoption, teaching, and advocacy.
The conference itself was amazing fun. The venue, The Brewery in a central London location made it easy to travel to (and find a hotel for). The talks were split across three tracks, with a tutorials track, and a game jam too. They also gave one of the cutest bits of conference merch I’ve ever seen — an adorable plush of Ferris, Rust’s mascot. Mine, pictured at the top of the page, now sits proudly on my desk.
I had many great moments at the conference. I couldn’t see everything, or talk to everyone, but I valued every conversation I had over the conference. The speakers were also fantasticly approachable, with many of them indulging my many questions on their work. This post would end up far too long if I tried to recount the entire conference, but to give a few stand-out moments:
Conrad Ludgate’s talk “Let’s write async rust from the ground up!” gave a deep-dive into the implementation of async in Rust.
A relatively recent addition to the language,
await are now a big part of modern Rust.
These ideas also power the hugely popular Tokio framework.
Conrad’s talk really helped me to understand what these systems do, and why languages like to implement their own task handling instead of only relying on operating system threads.
The most interesting part to me was an early segment where Conrad discussed different models of async tasks. Rust, with
await uses a cooperative model where tasks
await to “give back” execution to the runtime and allow other tasks to run.
Other languages, interestingly including Go’s goroutines, instead allow the runtime to chose when to interrupt (or “preempt”) the task.
Conrad discussed the tradeoffs with both approaches in detail in his talk, and I highly suggest it to anyone who wants to know more about the fine detail of Rust async.
Tim McNamara’s talk “Spreading Rust to the rest of the company: moving past the proof of concept” was less of a technical deep dive, and more of a discussion of people and ideas. He poised the idea that gaining adoption of Rust in a workplace is task that involves far more about the people than anything else.
Rust has a notoriously hard learning curve, so it can help to build a group of experts to turn to internally.
Even to answer “simple” questions such as the difference between
&str, and when to use them.
This can help to foster a learning culture, eventually enabling a team to understand and adopt Rust.
Tim also talked about the imporance of selecting a project to trial Rust with, with two broad approaches. Either picking off small, non-critical components to write with Rust. Building the team’s experience, skills, and confidence along the way. Or, selecting the hardest and most complex part first and using that for Rust.
This topic resonated with me in many ways.
When I was younger and in school I naturally gravitated towards mathematics and computing as it involved far less talking to people. I also avoided topics that required long-form writing, preferring short-form questions and answers. This path led me to software engineering as a career. Now, ironically, as a Staff-level engineer I spend most of my time talking to people and producing long form writing. Go figure.
The Rustacean Cycle
Nell Shamrell-Harrington gave the conference’s opening keynote. Her talk focused on the community around Rust, and the kindness it embodies between contributors. Asserting that everyone there, no matter how they feel, is a member of that community — a Rustacean.
Nell went on to speak about how the community can help others learn. How knowledge can be passed on, and how anyone can learn. Indeed, her talk directly called for people to write blog posts about the conference — like this one.
In many ways her talk resonated with me the strongest of any at Rust Nation UK. For several years I’ve been humbled to be a part of the Kubernetes community (I don’t think we’ve got a name for “Kubernetes” person as good as “Rustacean”, my wife just calls us “Wheel People” on account of the logo). The communities are different, but I can draw the parallels. Ultimately while I am a relative outsider to the Rust community, I have felt nothing but welcomed by it.
Follow me on Mastodon at @[email protected]!