Roadmap

This roadmap describes the long-term knowledge graph for Senior Rust interviews.

The study order is designed to build from machine-level fundamentals toward Rust internals, async runtimes, backend systems, and distributed infrastructure.

Computer Fundamentals
        ↓
Operating Systems
        ↓
Compiler Fundamentals
        ↓
Memory Model
        ↓
Rust Core
        ↓
Tokio Ecosystem
        ↓
Systems Programming
        ↓
Distributed Systems

1. Computer Fundamentals

Foundation for reasoning about execution, data representation, and performance.

Modules:

• CPU execution model
• Stack and heap basics
• Pointers and addresses
• Cache locality
• Atomic operations
• Integer and floating-point representation

Depends on: none.

Used by: memory, ownership, unsafe, performance, concurrency.

2. Operating Systems

Foundation for understanding processes, threads, IO, scheduling, and kernel boundaries.

Modules:

• Processes and threads
• Virtual memory
• System calls
• File descriptors
• Blocking vs non-blocking IO
• Scheduling
• Signals
• Memory mapping

Depends on: computer fundamentals.

Used by: async, Tokio, networking, FFI, performance.

3. Compiler Fundamentals

Foundation for understanding what Rust checks at compile time and what exists at runtime.

Modules:

• Parsing and type checking
• Borrow checking
• Monomorphization
• MIR
• LLVM basics
• Optimizations
• Linkage

Depends on: computer fundamentals, memory basics.

Used by: ownership, lifetimes, traits, generics, performance.

4. Memory Model

Foundation for Rust's safety guarantees and low-level programming model.

Modules:

• Stack vs heap
• Ownership and allocation
• Moves and copies
• Drop semantics
• Aliasing
• Lifetimes
• Interior mutability
• Atomics and memory ordering

Depends on: computer fundamentals, compiler fundamentals, operating systems.

Used by: Rust core, unsafe, concurrency, async.

5. Rust Core

The central layer of the knowledge base.

Modules:

• Ownership
• Borrowing
• Lifetimes
• Type system
• Traits
• Generics
• Smart pointers
• Error handling
• Standard library
• Unsafe Rust
• Macros
• FFI

Depends on: compiler fundamentals, memory model.

Used by: every higher-level module.

6. Concurrency and Async Rust

Foundation for writing correct concurrent and asynchronous Rust services.

Modules:

• Threads
• Send and Sync
• Mutexes and channels
• Atomics
• Futures
• async/await
• Pinning
• Wakers
• Executors
• Cancellation

Depends on: Rust core, operating systems, memory model.

Used by: Tokio, networking, backend systems.

7. Tokio Ecosystem

Foundation for production async Rust backend development.

Modules:

• Tokio runtime
• Tasks
• Timers
• Async IO
• TCP and UDP
• Backpressure
• select!
• Channels
• Graceful shutdown
• Tracing

Depends on: async Rust, operating systems, networking basics.

Used by: backend, trading infrastructure, Web3 services.

8. Systems Programming

Applies Rust to low-level and performance-sensitive infrastructure.

Modules:

• Networking
• Protocols
• Serialization
• Memory allocation
• Profiling
• Latency
• FFI boundaries
• Kernel interfaces
• Observability

Depends on: Rust core, Tokio, operating systems, performance.

Used by: trading infrastructure, infrastructure services, Web3 nodes.

9. Distributed Systems

Foundation for senior backend and infrastructure interviews.

Modules:

• Replication
• Consensus
• Consistency models
• Fault tolerance
• Idempotency
• Ordering
• Sharding
• Backpressure
• Queues
• Time and clocks

Depends on: systems programming, networking, concurrency.

Used by: backend platforms, trading systems, Web3 infrastructure.

Priority Path

For the first 1-2 months, prioritize:

1. Ownership, borrowing, lifetimes.
2. Memory, smart pointers, Drop, Copy, Clone.
3. Traits, generics, type system.
4. Error handling and standard library.
5. Unsafe fundamentals.
6. Concurrency and Send/Sync.
7. Async Rust, Future, Pin, executors.
8. Tokio runtime, tasks, channels, IO.
9. Networking and performance.