Mutable Closure

My Experience Attending Rust Nation and Rust Global

Last week was very busy for the Rust community in London, hosting not one but two amazing back-to-back conferences: Rust Nation and Rust Global. As a Londoner and Rust enthusiast, I couldn’t miss any of it and was excited to join the Rust community in real life.

Talks I Attended (at Rust Nation)

Obligatory disclaimer. These are my thoughts from memory, so please don’t take these as the speakers’ exact words. They are far from exhaustive summaries. If a topic interests you, the recordings should soon be available on the conferences' YouTube channels.

Ensuring Rust Safety: Strategies for Managing Unsafe Rust

by Celina Val (Principal Engineer at AWS)

A solid introduction to unsafe Rust. While we should avoid unsafe as much as possible, there are legitimate cases for its use (most notably for performance).

(As someone who likes to write interpreters, an example that stuck with me is transmuting u8 values to valid enum variants in place.)

When we do resort to unsafe code, we should limit it to the absolute minimum and provide safe APIs for external use. Thorough documentation of the unsafe code’s expectations is essential and, beyond that, there is a wide range of tools and techniques available for automatic validation.

Parallel Programming in Rust: Techniques for Blazing Speed

by Evgenii Seliverstov (Senior Software Engineer at Bloomberg)

(Very popular choice — having made the unfortunate timing mistake of stepping out for a quick break, I ended up standing in the room. It was worth it.)

A comprehensive collection of practical techniques for unleashing parallel execution—from high-level libraries to low-level details. It’s a great reference for anything parallel.

The speaker clearly drew on first-hand experience, making the talk both informative and accessible.

Note that parallel != async (parallel is always multi-core; async isn’t necessarily, as threads and coroutines can run on the same core).

Rust Project Goals 2024: Stabilizing Rust in the Linux Kernel

by Alice Ryhl (Android Rust Team at Google)

An overview of changes implemented or planned to improve interoperability between Rust and the Linux kernel.

Interesting, as it's not something I usually follow beyond the mainstream news (and the recent drama).

Main takeaway: there seems to be deep collaboration between Linux and Rust folk (including at big tech companies), so hopefully this partnership is here to stay.

Techniques Learned from Five Years Finding the Way for Rust in Python

by David Hewitt (Staff Software Engineer at Pydantic and Lead Maintainer of PyO3)

Although I can’t consider myself a Python person, this instantly became my favourite talk of Rust Nation.

Outstanding delivery, perfect pace, deeply insightful content — an absolute joy to watch.

The speaker beautifully articulated some advantages of Rust that I completely agree with:

The basics are covered excellently

And, this: thanks to Rust's backwards compatibility, PyO3 supports all Rust versions dating back to Aug 2022! As a humble Swift person, I was blown away.

The rest of the talk is a declaration of love for crafting a great developer experience as a library author. With PyO3 as a case study, the speaker shares techniques ranging from providing great custom compiler error messages to designing a deprecation journey for a core type in the library, as well as working around edge cases in the Rust compiler.

But don’t just take my word — go watch it when it becomes available. Thanks, David!

David Hewitt speaking

ABI Resilience

by Victor Ciura (Principal Engineer on the Rust Team in Microsoft DevDiv)

ABI stability is controversial because of the trade-off between implementation flexibility and inter-version (and inter-language) compatibility.

As the speaker joked, if you wait until you're happy to freeze your language’s ABI, that time will never come — you need to actively work towards it.

This talk is a fascinating exploration of how other languages, notably Swift and C++, have approached ABI stability.

While Swift was designed for it from the early days and eventually reached the milestone in the fifth revision of the language, C++ took a peculiar equidistant approach: while they haven't committed to ABI stability, they are de facto rejecting any proposal that breaks the ABI.

As the speaker put it, indecision prevents taking full advantage of either approach — a sentiment I can relate to.

And Rust? Only time will tell, but the point is clear: it’s better to make a conscious decision than to keep postponing until you risk falling into C++ territory.

(As we know from David Hewitt's talk, Rust is already quite good at backwards compatibility, so why do we care? Mostly for dynamic linking and interoperability with other languages, which currently must rely on the C ABI.)

While remaining true to an initial oath of neutrality, the speaker hinted at the possibility of having multiple ABI stability milestones over Rust’s history — perhaps a compelling compromise.

(This talk won my personal award for most mentions of Swift.)

Microsoft is Getting Rusty: A Review of Successes and Challenges

by Mark Russinovich (CTO, Deputy CISO, and Technical Fellow for Microsoft Azure)

A legend in the Windows world, Mark Russinovich is also famous for an old tweet urging the industry to "declare [C and C++] as deprecated" in favour of Rust when a non-GC language is required — a point reiterated on stage.

While I can only admire the boldness of a tech CTO — and I still love C — the argument is persuasive. If a language can catch many memory and safety issues at compile time while being a joy to use, why write mission-critical code with anything else? (Reality, of course, is more nuanced.)

The talk detailed how extensively Rust is used at Microsoft, especially in Azure — spoiler, it’s in a lot of places. There was even a demo of using LLMs to automatically translate a complete ncurses-based game from C (or maybe it was C++) to Rust, all without compiler errors.

In essence, Microsoft is keen to showcase its deep commitment to Rust and its community.

Empowering.

Developer, developers, developers

Talks I Would Have Liked To Attend

With multiple tracks running simultaneously, I couldn’t catch every talk. There were sessions on WebAssembly (a topic I'm passionate about), Rust on microcontrollers, and more. I’m eager to catch up when the recordings are released.

Beyond The Talks

Conferences are as much about networking as they are about the talks. As my first venture into the Rust community, I found the atmosphere extremely welcoming and met some cool people from all over the world.

Unlike iOS/macOS conferences, where backgrounds are often similar, Rust events bring together a diverse range of technical perspectives. While it can feel a little overwhelming coming from a very specific area like iOS, the experience was deeply enriching — and I can’t wait to attend more Rust events.

My Personal Highlight

JetBrains had a booth to promote RustRover, their Rust IDE. They hosted a Rust-themed quiz, and I was both curious and a little nervous to test my self-taught Rust knowledge in public. To my great surprise, I won!

I could choose between a 1-Year licence for JetBrains' All Products Pack or a voucher for Rust training. Not expecting the win, I panicked and quickly chose the software licence, as it seemed the most valuable prize.

My go-to Rust editor is currently Zed, though I occasionally reach out to RustRover when I need a debugger — which I find rarer with Rust, as the compiler catches most debug-worthy issues!

While I love Zed, I’m intrigued to try out the JetBrains suite. Since I don’t work with a large Rust team (yet?), I might be missing out on some advanced IDE features that benefit large-scale projects.

Rust Global

The day after Rust Nation, it was already time for Rust Global! Directly sponsored by the Rust Foundation, it featured four more great talks.

Using Rust to Interact with an SAP System Using OData V2

by Chris Whealy, long-time member of the Rust London Community

What immediately stood out was the speaker's exceptional ability to communicate complex technical details.

Beyond the relatively niche topic, the talk provided valuable insights into building ergonomic and type-safe Rust APIs to interface with old systems. The ingenious two-stage approach — first reading metadata to statically generate Rust types, then using them at runtime — is particularly noteworthy.

Building Rust Communities, At Home and At Work

by Ciara Rowlan-Simms, Software Engineer at Esri and long-time Rust meetup organiser

An inspiring meta-talk on kickstarting and nurturing Rust meet-ups and communities, both locally and online. A must-watch if you’re considering starting your own meet-up or have always enjoyed joining many meet-ups and conferences and want to understand why.

Rebuilding Prime Video UI with Rust and WebAssembly

by Alex Ene (Principal Engineer at Prime Video)

An intriguing behind-the-scenes look at how Amazon re-built its Prime Video client using Rust and WebAssembly.

While Wasm decouples iterative releases from elaborate firmware updates on a plethora of USB sticks and set-top boxes, Rust on the frontend simplifies building complex animated UIs.

Amazon is among the pioneers of this approach, which looks extremely promising in terms of wider adoption.

Serverless Rust: Your Low-Risk Entry Point to Rust in Production (and the benefits are huge)

by Luciano Mamino (Senior Architect at fourTheorem) and James Eastham (Serverless Developer Advocate at Datadog)

A great mix of theory and hands-on tutorial.

In the first part, James advocates for serverless setups as a low-risk way to experiment with new technologies in production. Specifically regarding Rust, there are some interesting figures showing how it can help reduce costs by lowering running times.

In the second part, Luciano demonstrated how to build a Rust Lambda function on AWS — from scratch to deployment. Although I’m not a backend person, the talk was very accessible and left me curious to try things out. (The speakers are even writing a book on the topic.)

Bonus Track

If you thought Rust Nation and Rust Global were the only Rust events in London last week, you’d be wrong: there was also a meet-up before the conferences!

That was actually my first appearance in the Rust community in London — a great chance to connect with fellow Rustaceans. There were also two interesting talks:

Main Takeaway of the Week

The Rust community is ready for prime time. It’s exciting, though sometimes frustrating, that Rust seems on the brink of a breakthrough without being fully there yet. Many conversations focused on how to convince companies to adopt it.

It reminded me of the early Macintosh days: when you discover a tool infinitely superior to the status quo, you want to tell as many people as possible — not for personal gain, but because you genuinely want more people to have a good experience.

Hero of the Week

I can’t close this post without giving a big shout — or, as Ernest would say, a massive hand — to Ernest Kissiedu, who not only tirelessly organised all three events last week but also magnificently MC'ed them! Even as a newcomer, I immediately recognised Ernest as a fantastic host and a genuinely lovely human being. Thank you, Ernest — I can’t wait to join more events in the future.