Skip to content

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.

text
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.