Learn Rust: an ordered reading path from ownership to shipping real programs
This curriculum takes you from zero Rust knowledge to writing safe, concurrent, production-grade systems software across four tightly sequenced stages. Each stage builds directly on the mental models of the last — ownership and borrowing first, then idiomatic patterns, then systems-level depth, and finally concurrency and async — so no concept is introduced before you have the vocabulary to absorb it.
Foundations: Syntax, Ownership & Borrowing
BeginnerRead and write basic Rust programs with confidence; fully internalize the ownership, borrowing, and lifetimes model that underpins everything else in the language.
▸ Study plan for this stage
Pace: 4–5 weeks, ~40–50 pages/day. Start with "The Rust Programming Language" Chapters 1–10 (2.5–3 weeks), then move to "Rust in Action" Chapters 1–3 (1.5–2 weeks) for practical reinforcement.
- Rust's ownership system: move semantics, the three rules of ownership, and why Rust enforces them at compile time
- Borrowing and references: immutable vs. mutable borrows, the borrow checker, and how Rust prevents data races
- Lifetimes: explicit lifetime annotations, lifetime elision rules, and how they ensure references are always valid
- Pattern matching and destructuring as core language features for safe data handling
- Memory safety without garbage collection: stack vs. heap allocation, and how ownership eliminates entire classes of bugs
- The relationship between ownership, borrowing, and the type system as a unified safety model
- Practical error handling with Result and Option types as alternatives to exceptions
- Explain the three rules of ownership in Rust and why each one is necessary for memory safety.
- What is the difference between moving a value and borrowing it? When does each occur?
- Describe the borrow checker's rules: how many immutable borrows can exist at once? How many mutable borrows? Can they coexist?
- What is a lifetime, and why does Rust require explicit lifetime annotations in some function signatures but not others?
- How does Rust's ownership model prevent data races and use-after-free bugs at compile time?
- Write a function that takes both an immutable and mutable reference and explain why the borrow checker accepts or rejects it.
- Work through all code examples in TRPL Chapters 4–10, typing them out manually and running them; modify examples to trigger borrow checker errors, then fix them.
- Implement a simple stack-based calculator in Rust that uses ownership to manage operand storage; ensure no cloning is used unnecessarily.
- Create a function that borrows a String, modifies it in place (mutable borrow), and returns it; write tests that verify the borrow checker prevents simultaneous mutable and immutable borrows.
- Implement a struct representing a simple linked list node with lifetime annotations; practice writing functions that return references with explicit lifetimes.
- Complete the hands-on projects in 'Rust in Action' Chapters 1–3 (e.g., the CPU simulator or file I/O examples); pay close attention to how ownership flows through the code.
- Write a program that intentionally violates ownership rules (e.g., use-after-free, double-free), document what the compiler error says, and fix it; repeat for 5–10 different violations.
Next up: This stage establishes the mental model and compile-time guarantees that make Rust's advanced features—traits, generics, error handling patterns, and concurrency—both possible and safe; without internalizing ownership and borrowing, later stages will feel arbitrary rather than elegant.
The official, community-vetted introduction to Rust — universally called 'the Book'. It is the single best starting point for syntax, ownership, and borrowing, and every later resource assumes you have read it.
Reinforces foundational concepts through hands-on, systems-flavored projects (files, networking, clocks), giving beginners concrete programs to anchor the abstract ownership rules they just learned.
Idiomatic Rust: Patterns, Error Handling & APIs
IntermediateWrite idiomatic, expressive Rust using traits, generics, iterators, and robust error-handling strategies; understand how to design clean, reusable APIs.
▸ Study plan for this stage
Pace: 8–10 weeks, ~40–50 pages/day (Programming Rust: 5–6 weeks; Rust for Rustaceans: 3–4 weeks)
- Trait design and implementation: defining abstractions, trait bounds, and polymorphism
- Generic programming: type parameters, lifetime parameters, and trait-based generics for code reuse
- Iterator patterns and adapters: lazy evaluation, chaining, and functional composition
- Error handling strategies: Result types, custom error types, and the ? operator for ergonomic error propagation
- API design principles: zero-cost abstractions, builder patterns, and designing for composability
- Ownership and borrowing in complex scenarios: lifetime elision, higher-ranked trait bounds, and variance
- Performance optimization: inlining, monomorphization, and avoiding unnecessary allocations
- Testing and documentation: writing testable code, doc tests, and API contracts
- How do you design a trait that balances expressiveness with ease of implementation for downstream users?
- When should you use associated types vs. generic type parameters in a trait, and what are the trade-offs?
- Explain the difference between Iterator::map() and Iterator::filter() in terms of lazy evaluation and when each is appropriate.
- How do you create a custom error type that integrates with the standard library's error handling ecosystem?
- What is the ? operator doing under the hood, and how does it relate to the From trait?
- How can you use lifetime parameters to express borrowing constraints in an API without over-constraining callers?
- Implement a generic trait-based data structure (e.g., a simple cache or repository) that works with multiple types and includes trait bounds.
- Refactor an existing Result-based error handling approach to use a custom error enum with From implementations for multiple error sources.
- Build an iterator adapter chain that performs multiple transformations (map, filter, fold) and verify it only evaluates when consumed.
- Design and implement a builder pattern API for a complex configuration struct; document the API with doc comments and examples.
- Write a generic function with multiple trait bounds and lifetime parameters; test edge cases where lifetimes interact.
- Create a small library with public traits and types; write comprehensive doc tests demonstrating idiomatic usage patterns.
Next up: This stage equips you with the language features and design patterns to write expressive, maintainable Rust; the next stage will likely deepen your ability to apply these patterns at scale—whether through concurrency, systems programming, or advanced type-system techniques.
The most thorough treatment of Rust's type system, traits, and generics available; reading it after the Book transforms a beginner into someone who truly understands why Rust is designed the way it is.
Bridges intermediate and advanced Rust by diving into lifetimes, trait objects, API design, and the subtleties of the type system — exactly the knowledge needed before tackling systems or async work.
Systems Depth: Unsafe, FFI & Performance
ExpertUnderstand unsafe Rust, memory layout, FFI, and performance tuning well enough to write and audit low-level systems code with confidence.
▸ Study plan for this stage
Pace: 4–5 weeks, ~40–50 pages/day with code walkthroughs
- Production-grade error handling patterns and Result/Option composition in real systems
- Structured logging, observability, and instrumentation for debugging production code
- Database integration, connection pooling, and transaction safety in async contexts
- Async/await runtime behavior, task spawning, and concurrency patterns for systems code
- Configuration management, environment-driven behavior, and secrets handling in production
- Testing strategies for async systems including integration tests and property-based testing
- Performance profiling, bottleneck identification, and optimization in real applications
- Memory efficiency and resource cleanup in long-running systems
- How do you design error types and implement custom error handling that provides actionable context in production systems?
- What are the key differences between structured logging and println debugging, and why does observability matter for systems code?
- How do you safely manage database connections in async Rust, and what role does connection pooling play in production?
- Explain the relationship between async runtimes, task scheduling, and potential performance bottlenecks in concurrent systems.
- What strategies ensure that configuration and secrets are handled securely without hardcoding sensitive values?
- How do you test async code effectively, and what are the trade-offs between unit, integration, and end-to-end tests?
- Build a custom error type with context-rich error messages; implement From traits for error conversion and test error propagation chains
- Integrate structured logging (tracing/log crate) into a small async application; configure different log levels and observe output
- Set up a PostgreSQL connection pool using sqlx or tokio-postgres; write queries and measure connection reuse efficiency
- Refactor blocking code into async tasks; profile task spawning overhead and identify where async provides real benefits
- Create a configuration system using environment variables and a config file; implement validation and secret masking
- Write integration tests for an async HTTP service with a test database; measure test execution time and reliability
- Profile a simple async application using flamegraph or perf; identify the top CPU consumers and optimize one bottleneck
- Implement graceful shutdown for a long-running service; verify resource cleanup (database connections, file handles) on exit
Next up: This stage grounds you in production-quality Rust patterns and observability practices, preparing you to move into lower-level systems work where you'll apply these reliability principles to unsafe code, FFI boundaries, and performance-critical sections.
Grounds all the advanced theory in a real-world web service project, covering error handling at scale, telemetry, and production deployment patterns that solidify professional-grade Rust habits.
Concurrency & Async: Safe Parallelism
ExpertDesign and implement correct concurrent and asynchronous Rust programs using threads, channels, async/await, and the Tokio runtime — the capstone of production-ready systems software.
▸ Study plan for this stage
Pace: 8–10 weeks, ~40–50 pages/day (with code examples and exercises interspersed)
- Memory ordering and atomic operations: relaxed, release, acquire, and sequentially consistent semantics for lock-free programming
- Mutex, RwLock, and Condvar: interior mutability patterns and synchronization primitives for safe shared state
- Channels and message passing: designing producer–consumer systems and decoupling concurrent components
- Building custom locks and synchronization primitives: understanding the foundations beneath std::sync abstractions
- Race conditions, data races, and deadlocks: identifying, preventing, and reasoning about correctness in concurrent code
- Parking and thread parking: efficient waiting mechanisms and the foundations of higher-level synchronization
- Async/await and futures: cooperative multitasking and non-blocking I/O patterns for scalable systems
- Tokio runtime integration: spawning tasks, managing executors, and bridging sync and async code
- What is the difference between relaxed, acquire, release, and sequentially consistent memory ordering, and when should you use each in atomic operations?
- How do Mutex, RwLock, and Condvar work internally, and what are the trade-offs between them for protecting shared state?
- How can you design a correct producer–consumer system using channels, and what guarantees do Rust's channel types provide?
- What are the root causes of race conditions, data races, and deadlocks, and how does Rust's type system prevent data races at compile time?
- How do you implement a custom lock or synchronization primitive, and what invariants must you maintain?
- What is the difference between blocking and async I/O, and when should you use async/await with Tokio versus synchronous code?
- Implement a simple spinlock using std::sync::atomic::AtomicBool with different memory orderings; measure performance differences
- Build a thread-safe counter using Mutex<i32> and spawn 10 threads that increment it concurrently; verify the final count
- Create a producer–consumer pipeline using mpsc channels: producers generate work, consumers process it, and measure throughput
- Implement a custom RwLock from scratch using AtomicUsize and Condvar; test with concurrent readers and exclusive writers
- Write a program that intentionally creates a deadlock scenario (e.g., lock ordering violation), then refactor to prevent it
- Build a simple thread pool using channels and Arc<Mutex<T>>; submit tasks and verify they execute on worker threads
- Implement a parking-lot-style lock using thread::park() and AtomicBool; compare with std::sync::Mutex
- Convert a synchronous I/O program (e.g., TCP server) to async using Tokio; measure latency and throughput improvements
Next up: This stage equips you with the low-level concurrency primitives and async foundations needed to architect production systems; the next stage will apply these patterns to real-world domains like network services, distributed systems, or high-performance data processing.
The definitive guide to Rust's concurrency primitives — atomics, mutexes, and memory ordering — written by a member of the Rust library team; builds the mental model for safe shared-state concurrency from first principles.
Discussion
Keep reading
Paths that share books, cover the same subject, or open a related topic.
