2024/09/13 - RustConf Chronicles Day 2

This is the second post of this mini-series, check out Day 1 if you haven't already.

Giving Tux a pair of pincers

Here we are, second day of RustConf underway, catered black coffee in hand and ready to turn on the neurons (maybe)! This day kicked itself off with a talk about the Rust For Linux project presented to us by Miguel Ojeda. The presentation revolved around the integration of Rust as a first tier citizen in the Linux kernel. Miguel walked us through the goals of this meta project as well as a bunch of other interesting facets such as: how documentation is asserted through tests, who is currently using Rust in the kernel, how safe wrappers are built around unsafe IO, etc.

Tiny computers, big reveals

The second talk of the day was showcasing an awesome project built by Jonathan Pallant. The Neotron-Pico is a custom board built with a Raspberry Pi Pico as its brain. Throughout his presentation, he taught us about the complexities of building an OS, BIOS, FileSystem, SDK, and API in Rust for small form factor compute and storage. The presentation had a great twist, I invite any reader to check it out once it is published. This was a flurry of pio_asm! grokking, program loading, .wav playing, exciting madness.

Compiler driven development

The following talk that I attended was given by Jacob Pratt. It was a good return to the basics to revisit how the Rust compiler can be your ally during development. We explored error examples and what they can teach us as well as different widely used Rust design patterns (eg. Builders, Newtype, etc.). The later portion of the talk had some great examples of leveraging trait bounds and where clauses for better compile time validation.

What's happening under the hood?

Upon our return from the lunch break, we were gifted with a deep dive by Michael Gattozzi from InfluxData. His talk "What happens when you run cargo build" ran us through how cargo handles building your program and its dependencies. His effective use of cargo build -v to explain the process step by step and how this is different when transitive dependencies are involved was a pleasure to follow along to. Although quick, he left us with just enough appetite to explore further!

Tracing at scale

This one was a gem, I learned so much. Marc-André Giroux is a local Montreal area resident who is currently employed at Netflix. His talk covered his experience with observability overhead for OpenTelemetry traces, logs, and metrics. He took us on an adventure from basic tracing crate concepts to practical considerations for minimizing runtime work. I found his presentation thrilling, he introduced me to a bunch of interesting ideas such as per layer filtering of observability, granular log levelling via allow-lists, dynamic call-site toggling with "Fast Properties". I definitely walked away with this one thinking of possible improvements to my day-to-day observability stack.

Wait frontend, really?

For anybody not familiar with Chris Biscardi, go check out his Youtube channel. Chris took us on a journey through history of the web in his talk "Web sites, web apps, web assembly". He started off from HTML/CSS and ran us chronologically through bundlers, runtimes, and meta frameworks. Although I'm less interested by this space, his later code examples featuring Leptos and WebAssembly made a real nice parallel with the React side of things that I am familiar with (with a bit of added syntactic sugar and typing).

Types, types everywhere

As everybody returned to the main track of the conference, I was truly surprised by the following talk, I had not expected to enjoy it so much. Joshua Liebow-Feeser blew my mind with his presentation "Safety in an unsafe world". The talk was focused on lessons learned from building the networking stack Netstack3 for Googles FuschiaOS. Joshua ran us through his framework for safety composed of Definition, Enforcement, and Consumption steps. Armed with a bunch of explicit code examples, he showed us how we could use typing to model out thread safety and deadlock prevention. This was a great example of modelling your domain space to make undesireable states impossible. He also added in various quotes which I will be adding to my arsenal.

Rust project roadmap

To cap off the final day of talks, Nicholas Matsakis presented the new format of Rust Project Goals. He highlighted some of the larger goals for the language, such as: the coming of a 2024 Rust Edition, the feature parity between asynchronous and synchronous Rust, and the effort to get the Linux kernel on stable Rust. The best news to my ears involved that second goal. It is super exciting to know that we will soon have async closures! This is something I have felt the pain of personally and I wouldn't mind a bit of quality of life improvements on that front. In the end, it was also nice to see that there was a drive to make the language simpler and more approachable (maybe some influence from Go here?).