Summary of Why Rust is different, with Alice Ryhl

Overview of Why Rust is different, with Alice Ryhl

In this episode, Gergely Orosz speaks with Alice Ryhl—software engineer on Google’s Android Rust team, Tokio maintainer, and Rust language team advisor—about what makes Rust unusual among modern languages. The conversation focuses on Rust’s reliability and performance story, its core safety mechanisms, how its community and governance work, and why it’s gaining traction in backends, systems programming, and the Linux kernel.

Why Rust stands out

Rust’s central appeal is the combination of:

• High performance without a garbage collector
• Memory safety by default
• Strong compile-time guarantees that catch many bugs before runtime
• Explicit error handling that makes failures harder to ignore

Alice’s shorthand pitch is that Rust helps developers write code that is much more likely to “compile and work” correctly—especially compared with languages where nulls, exceptions, or memory bugs can cause production issues or security vulnerabilities.

Core Rust concepts explained

Ownership and moves

• Every value has a clear owner.
• Assigning a value often moves it rather than copies it.
• After a move, the original variable can’t be used again unless it was explicitly cloned.

Borrow checker and references

• References are temporary “borrows” of values.
• The compiler ensures references never outlive the data they point to.
• Rust enforces rules like:
  • many readers or one writer
  • no use-after-free
  • no mutable access while shared references are active

unsafe

• unsafe is an escape hatch, not a way to disable Rust’s safety system.
• It allows operations that the compiler can’t fully verify, such as low-level pointer work or calling unsafe functions.
• It’s typically used to:
  • build core abstractions in libraries
  • interface with C
  • implement performance-critical or low-level internals
• A well-designed safe API can contain unsafe code internally while remaining safe to use from the outside.

Why Rust is attractive for reliability

Alice highlights several language features that reduce common bugs:

• No null by default: optional values must be explicit
• Errors as values: Result and ? force error handling
• Exhaustive matching: missing enum cases become compiler errors
• Documentation tests: code examples in docs are run as tests
• Serde-style deserialization: structured input like JSON is checked against types
• Compile-time refactor help: the compiler points out all the places that need updating

The overall theme is that Rust tries to catch whole categories of mistakes early—often at compile time.

Rust vs. TypeScript and C++

From TypeScript

Rust is a strong fit for:

• backends
• API servers
• command-line tools
• systems code where reliability matters

The pitch here is: if you don’t want to wake up at 3 a.m. because of a server bug, Rust’s guardrails are valuable.

From C++

The pitch is even stronger:

• many C++ mistakes become security vulnerabilities
• Rust’s memory safety eliminates a large class of these bugs
• this matters especially in kernels, infrastructure, and security-sensitive systems

Tokio, async, and the Rust ecosystem

Alice explains Tokio as Rust’s core asynchronous runtime:

• similar in spirit to the browser event loop in JavaScript
• manages queued tasks that can pause and resume
• supports multithreading, unlike the single-threaded browser model

Tokio is a major part of the modern Rust ecosystem, especially for async backends.

Where Rust is mature today

Strongest areas

• Backend services
• CLI tools
• Linux kernel work
• Embedded / firmware
• Performance-sensitive infrastructure

Less mature area

• Frontend web development
  • There have been WebAssembly efforts, but Alice does not see Rust replacing TypeScript on the frontend anytime soon.

How Rust is governed

Rust is not run by a single “benevolent dictator” like some other projects. Instead, it is managed by teams:

• language team
• library API team
• compiler/dev tools groups
• Rust Foundation support

Decision-making process

For major changes, Rust uses RFCs and a structured approval workflow:

1. Write an RFC with motivation, design, rationale, alternatives, and future possibilities
2. Discuss it in the RFC repository or in chat
3. If accepted, implement behind a feature flag on nightly
4. Gather feedback and write a stabilization report
5. Run a final approval process before making it stable

This process is designed to make decisions transparent, collaborative, and hard to rush.

Editions and compatibility

Rust uses editions rather than major version breaks:

• examples: 2015, 2018, 2021, 2024
• different crates can use different editions simultaneously
• old code is expected to keep working for a very long time

This lets Rust evolve syntax and ergonomics without forcing ecosystem-wide breaking changes.

Rust in the Linux kernel

Alice describes Rust’s role in Linux as increasingly accepted and more mature than before:

• Rust is no longer treated as experimental in the kernel
• more subsystems are adopting it
• attitudes have softened significantly over the last few years

The kernel community sees Rust as useful for reducing memory-safety bugs in critical code.

AI and Rust

Alice says she has experimented with AI tools, including the Gemini CLI, and sees practical value in them for:

• generating code
• writing or updating benchmarks
• assisting with reviews
• helping agents get compiler feedback during refactors

But she also emphasizes the risk:

• AI can produce code that compiles but subtly misses important intent
• human review is still essential, especially in Rust and kernel work

Best resources for learning Rust

Alice recommends:

• The Rust Book — the official, free online introduction
• Rustlings — interactive exercises with unfinished Rust code
• an intermediate Rust book by Jens/John Gjens (likely a reference to a well-known Rust author; the transcript is unclear)

Her advice for getting good at Rust:

• build a real project
• expect the hardest part to be data modeling
• learn to think in terms of Rust-friendly structures rather than forcing familiar patterns from other languages

Key takeaways

• Rust is different because it combines speed, safety, and strong compile-time enforcement.
• Its most distinctive ideas—ownership, borrowing, and exhaustive checking—push many bugs into compiler errors.
• The language is designed around preventing the kinds of mistakes developers repeatedly make in other languages.
• Rust’s governance is highly structured and collaborative, with RFCs and staged stabilization.
• The language is increasingly relevant in backends, systems, and the Linux kernel, while frontend adoption remains limited.
• Rust’s growing popularity likely comes from occupying a new niche: a language that is both reliable and performant.