roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for Rust interviews on the language and the toolchain around it. Covers ownership and borrowing, traits and generics, concurrency and unsafe code, and building, testing and debugging with Cargo.
555 of 555 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 555 new. 0 cut, outside your plan.
Rust comes up in interviews at teams that chose it on purpose: network services and infrastructure built on an async runtime, blockchain node clients and contract platforms, embedded firmware, and the occasional game or engine team. Most loops give it a dedicated language conversation, and many let you take the coding round in Rust too, where the interviewer watches how you work with the borrow checker rather than whether you can recite its rules. The conversation is built from snippets and compiler errors. Why does a loop fail with E0502 when its body pushes onto the vector it iterates? What does a move leave behind in the variable it came from? Why will a multi-threaded runtime refuse to spawn a future that holds an `Rc` across an `.await`? What does `Box<dyn Error>` cost a library's callers that a dedicated error enum does not? Which integer operation panics in a debug build and wraps in release? Junior candidates are expected to read those errors and repair the code. From middle level up the questions ask for the rule behind the repair and the trade-off it carries: static dispatch against a trait object, a clone against a borrow that has to outlive the function, a lock held across an await point. Senior loops add the decisions a codebase lives with: when `unsafe` is justified and how its invariants are written down, how a public crate changes without breaking its users, and which lints and checks should gate a merge.
The plan opens on the parts of the language every snippet uses: [expressions and blocks that yield values](/topics/lang-rust-syntax), and the structs and enums that [`match` takes apart](/topics/lang-rust-types). Ownership follows at once, because nearly every later question turns on it. [Moves and borrows](/topics/lang-rust-ownership-borrowing) come first, [lifetimes](/topics/lang-rust-lifetimes) then name how long a borrow lasts, and [smart pointers](/topics/lang-rust-smart-pointers) close the stretch as the sanctioned ways to bend single ownership when a design needs shared or interior-mutable state. Failure comes before abstraction. `Result`, the `?` operator and the line between a [recoverable error and a panic](/topics/lang-rust-error-handling) shape the signature of almost every function written after them. [Traits and generics](/topics/lang-rust-traits-generics) then supply the abstraction tools, with the standard library's own traits beside them, and the collections and [iterator chains](/topics/lang-rust-iterators) put both to work, since an adapter chain is generic code and closures applied to owned or borrowed data. The middle of the plan widens from one function to a project: [modules, visibility and SemVer](/topics/lang-rust-cargo-ecosystem), the serialization and logging crates most services pull in, and then [testing](/topics/lang-rust-testing) inside and outside the crate. Concurrency waits for that groundwork on purpose. [Threads](/topics/lang-rust-threads) make `Send` and `Sync` concrete before [async code](/topics/lang-rust-async-concurrency) asks why a future is a state machine that may need pinning, and why it must be `Send` before a multi-threaded runtime will take it. The advanced stretch is about what the compiler cannot check for you: [macros](/topics/lang-rust-macros) that generate code, [`unsafe` and FFI](/topics/lang-rust-unsafe), and [targets with no operating system](/topics/lang-rust-targets) or inside a WebAssembly sandbox. [Editions and the release train](/topics/lang-rust-editions) end the language part, once there is enough language to date. The plan closes on the toolchain: [Cargo](/topics/dev-cargo), from manifests and feature resolution to profiles and publishing, and the [rust-gdb](/topics/dev-rust-gdb) and rust-lldb wrappers that make a Rust binary readable in a debugger.
Developers who reach Rust from C++ bring the right fears, of dangling references, invalidated iterators and data races, and mostly need the names the compiler gives them, so study order can stay at by frequency while they spend extra time on lifetimes in signatures, trait objects, and `unsafe` as a contract they document. Readers from Java, Python or Go should switch study order to by topics before the first session: none of those languages asks who owns a value, and an async question that arrives before the ownership stretch is a question about a rule not yet learned. A loop booked for next week is no time to meet the borrow checker for the first time. Raise importance to must know and keep the ownership, error and trait questions in front, because Rust conversations at every level tend to start there. Embedded candidates are the exception: a firmware loop can open on `no_std` and on state shared with an interrupt handler, which the bare-metal part of the plan covers. The plan teaches the language and its toolchain, not the frameworks a job builds on. For a contract or node-client role, the [Blockchain Developer roadmap](/roadmaps/blockchain) puts protocol, consensus and smart-contract security around this plan, and the [Game Developer roadmap](/roadmaps/game-developer) does the same with engines, rendering and frame budgets.
Rust comes up in interviews at teams that chose it on purpose: network services and infrastructure built on an async runtime, blockchain node clients and contract platforms, embedded firmware, and the occasional game or engine team. Most loops give it a dedicated language conversation, and many let you take the coding round in Rust too, where the interviewer watches how you work with the borrow checker rather than whether you can recite its rules.
The conversation is built from snippets and compiler errors. Why does a loop fail with E0502 when its body pushes onto the vector it iterates? What does a move leave behind in the variable it came from? Why will a multi-threaded runtime refuse to spawn a future that holds an Rc across an .await? What does Box<dyn Error> cost a library's callers that a dedicated error enum does not? Which integer operation panics in a debug build and wraps in release?
Junior candidates are expected to read those errors and repair the code. From middle level up the questions ask for the rule behind the repair and the trade-off it carries: static dispatch against a trait object, a clone against a borrow that has to outlive the function, a lock held across an await point. Senior loops add the decisions a codebase lives with: when unsafe is justified and how its invariants are written down, how a public crate changes without breaking its users, and which lints and checks should gate a merge.
The plan opens on the parts of the language every snippet uses: expressions and blocks that yield values, and the structs and enums that match takes apart. Ownership follows at once, because nearly every later question turns on it. Moves and borrows come first, lifetimes then name how long a borrow lasts, and smart pointers close the stretch as the sanctioned ways to bend single ownership when a design needs shared or interior-mutable state.
Failure comes before abstraction. Result, the ? operator and the line between a recoverable error and a panic shape the signature of almost every function written after them. Traits and generics then supply the abstraction tools, with the standard library's own traits beside them, and the collections and iterator chains put both to work, since an adapter chain is generic code and closures applied to owned or borrowed data.
The middle of the plan widens from one function to a project: modules, visibility and SemVer, the serialization and logging crates most services pull in, and then testing inside and outside the crate. Concurrency waits for that groundwork on purpose. Threads make Send and Sync concrete before async code asks why a future is a state machine that may need pinning, and why it must be Send before a multi-threaded runtime will take it.
The advanced stretch is about what the compiler cannot check for you: macros that generate code, unsafe and FFI, and targets with no operating system or inside a WebAssembly sandbox. Editions and the release train end the language part, once there is enough language to date. The plan closes on the toolchain: Cargo, from manifests and feature resolution to profiles and publishing, and the rust-gdb and rust-lldb wrappers that make a Rust binary readable in a debugger.
Developers who reach Rust from C++ bring the right fears, of dangling references, invalidated iterators and data races, and mostly need the names the compiler gives them, so study order can stay at by frequency while they spend extra time on lifetimes in signatures, trait objects, and unsafe as a contract they document. Readers from Java, Python or Go should switch study order to by topics before the first session: none of those languages asks who owns a value, and an async question that arrives before the ownership stretch is a question about a rule not yet learned.
A loop booked for next week is no time to meet the borrow checker for the first time. Raise importance to must know and keep the ownership, error and trait questions in front, because Rust conversations at every level tend to start there. Embedded candidates are the exception: a firmware loop can open on no_std and on state shared with an interrupt handler, which the bare-metal part of the plan covers.
The plan teaches the language and its toolchain, not the frameworks a job builds on. For a contract or node-client role, the Blockchain Developer roadmap puts protocol, consensus and smart-contract security around this plan, and the Game Developer roadmap does the same with engines, rendering and frame budgets.