Why Rust is different, with Alice Ryhl

This episode of The Pragmatic Engineer Podcast features Alice Ryhl, a software engineer on Google’s Android Rust team, and a core maintainer of Tokio. The discussion centers around what makes Rust unique among programming languages, its safety and performance features, governance model, ecosystem, and real-world applications such as its integration into the Linux kernel. The episode also explores how developers from various backgrounds can adopt Rust and the future potential of the language.

Alice explains Tokio as a foundational async runtime for Rust that is comparable to JavaScript's event loop but with multi-threading capabilities. She emphasizes Rust’s appeal due to the principle 'when it compiles, it works,' highlighting the importance of strong type systems, null safety, and error handling. The conversation discusses Rust’s prominence and rapid growth, as evidenced by its overtaking PHP and Go in usage indexes, and its expanding adoption in high-performance systems and the Linux kernel.

The host and Alice delve into Rust’s memory safety mechanisms, ownership model, borrowing, and the borrow checker, illustrating how these features prevent common bugs such as use-after-free and null dereferences. Alice points out the role of unsafe Rust as an escape hatch for performance-critical code, but stresses that unsafe code must adhere to strict rules to avoid safety violations. Memory safety’s significance for security vulnerabilities is linked to Rust’s reliability in critical software.

The podcast explores how Rust's development is driven through a transparent RFC process, where features undergo rigorous discussion, design, and community feedback before stabilization. The governance model involves self-organizing teams rather than a benevolent dictator, and decisions are made collectively and through formal review periods. The process ensures high-quality, community-vetted language evolution.

Rust introduces editions as a way to handle breaking changes, allowing coexistence of code written in different iterations of the language without disrupting existing projects. This system enables innovation while maintaining backward compatibility, with new features like async/await being introduced in later editions.

Alice discusses opportunities for contributing to Rust—ranging from fixing bugs, adding features, to participating in RFCs—and mentions that many contributors are supported by their employers. The Rust Foundation also offers grants, especially targeting students and new contributors, fostering a vibrant community of both volunteer and funded developers.

The conversation highlights Rust’s growing role in the Linux kernel, where it’s moved from experimental to officially supported status. The Linux community’s shifting attitude toward Rust is portrayed as increasingly positive, recognizing Rust’s memory safety and security benefits. Alice shares insights into regulatory pressures for memory safety in critical systems and the potential for Rust to replace unsafe languages like C++ in sensitive environments.

Alice shares her experiences with AI assisting in coding tasks, such as generating code snippets and automating tests, emphasizing that AI can help reduce toil and improve safety in critical codebases. The discussion anticipates AI’s role in enhancing code review, edge case detection, and overall software quality, particularly in safety-critical systems like the Linux kernel.

The episode concludes with advice for newcomers: starting with the official Rust book, practicing by building projects, and engaging with community tools like rustlings. Alice warns about the potential for AI to create a false sense of mastery, stressing the importance of understanding core concepts such as ownership, borrowing, and unsafe code. She shares her enthusiasm for ongoing language features and upcoming enhancements.