Rust Mastery Curriculum

Cargo — Fri, 24 Oct 2025 21:24:12 +0000

Deep Rust Mastery Curriculum (Free Resources Edition)

Philosophy & Approach

This curriculum prioritizes understanding over memorization. You'll build mental models of how Rust works at a fundamental level, enabling you to reason about complex problems rather than pattern-match solutions.

Phase 1: Foundation & Mental Models (4-6 weeks)

Week 1-2: The Ownership Revolution

Goal: Internalize why ownership exists, not just how it works

Resources:

📚 The Rust Programming Language - Chapters 1-6
📚 Rust By Example - Parallel reading for hands-on practice
🎥 Let's Get Rusty - Ownership playlist - Visual explanations
🎓 Rustlings - Exercises on ownership, move semantics

Deep Dive Activities:

Trace memory allocation/deallocation manually on paper for simple programs
Compare Rust's approach to C++ RAII, garbage collection, and manual memory management
Read this article on ownership multiple times

Exercise:

Complete all ownership-related Rustlings exercises
Build a simple vector-like type from scratch
Learn Rust With Entirely Too Many Linked Lists - Start with "A Bad Stack"

Reflection: Write explanations of ownership as if teaching a 10-year-old, then a C programmer, then a Python developer

Week 3-4: Borrowing & Lifetimes—The Hard Parts

Goal: Develop intuition for the borrow checker

Resources:

📚 The Book - Chapters 7-11
📚 Too Many Linked Lists - Continue through all chapters
📝 Common Rust Lifetime Misconceptions - Essential reading!
🎥 Jon Gjengset - Crust of Rust: Lifetime Annotations
🎥 Jon Gjengset - Crust of Rust: Subtyping and Variance

Deep Dive:

Manually desugar lifetime elision rules
Study the borrowing flowchart: when is &T sufficient vs &mut T vs owned T?
Work through Rust by Practice - Ownership section

Projects:

Build a simple text editor buffer with efficient insertions
Implement a graph structure with multiple ownership patterns (Rc, RefCell)
Create a custom iterator that borrows from its parent structure
Complete Exercism - Rust Track exercises: Clock, Circular Buffer, Doubly Linked List

Week 5-6: Type System Mastery

Goal: Think in types, not just code

Resources:

📚 The Book - Chapters 10, 17, 19
📝 Rust Design Patterns - All patterns
🎥 Jon Gjengset - Crust of Rust: Iterators
🎥 Jon Gjengset - Crust of Rust: Smart Pointers and Interior Mutability
📝 Rust API Guidelines - Design principles
📝 Abstraction without overhead: traits in Rust

Deep Dive:

Trait objects vs generics: monomorphization costs and tradeoffs
Marker traits (Send, Sync, Copy, Sized) and their implications
Associated types vs generic parameters—when to use each
Read the std::iter module docs completely

Projects:

Implement a small serialization library using traits (inspired by serde)
Build a plugin system using trait objects
Create your own Result-like type with custom error handling
Study Serde's source code to understand trait magic

Phase 2: Concurrency & Async (6-8 weeks)

Week 7-9: Fearless Concurrency Foundations

Goal: Understand why Rust makes concurrency safe

Resources:

📚 The Book Chapter 16 - Fearless Concurrency
📚 Rust Atomics and Locks by Mara Bos - FREE ONLINE! Read chapters 1-6
🎥 Jon Gjengset - Crust of Rust: Channels
🎥 Jon Gjengset - Crust of Rust: Atomics and Memory Ordering
📝 The Rustonomicon - Concurrency

Deep Dive:

How Send and Sync prevent data races at compile time
Memory ordering: Relaxed, Acquire, Release, SeqCst
Interior mutability pattern: Cell, RefCell, Mutex, RwLock
Read std::sync module docs thoroughly

Projects:

Build a thread pool from scratch (follow along with Rust Book Chapter 20)
Implement a concurrent hash map using RwLock
Create a work-stealing scheduler (study rayon's approach)
Complete exercises from Rust Atomics and Locks

Week 10-12: Async Rust—The Complete Picture

Goal: Understand async from first principles

Resources:

📚 Asynchronous Programming in Rust - Official async book
📚 Tokio Tutorial - Build mini-Redis (DO THIS!)
🎥 Jon Gjengset - Crust of Rust: Async/Await
🎥 Jon Gjengset - The What and How of Futures and async/await in Rust
📝 Tokio internals: Understanding Rust's async runtime
📝 Pin, Unpin, and why Rust needs them

Deep Dive:

What is a Future? Implement your own simple future following this guide
How polling works: Poll::Ready vs Poll::Pending
The Waker API and how runtimes schedule tasks
Pin and why it exists (this is hard—spend time here)
Read futures crate docs

Critical Understanding:

Async is about I/O concurrency, not parallelism
The "function coloring" problem and its implications
Structured concurrency with select! and join!

Required Reading:

📝 What Color is Your Function? - Understanding async limitations
📝 Async: What is blocking?

Week 13-14: Async Ecosystems & Patterns

Goal: Master practical async programming

Resources:

📚 Tokio Topics - All advanced topics
📝 Tokio's tracing documentation
🎥 Jon Gjengset - Implementing TCP in Rust - Deep async networking
📝 Alice Ryhl's Tokio blog posts - All of them!
📚 async-std book - Compare with Tokio

Study:

Tokio vs async-std vs smol: architectural differences
Channels: mpsc, broadcast, watch, oneshot
Async traits and why they're challenging
Read tokio source code - start with tokio::time

Projects:

Complete the Tokio mini-Redis tutorial fully
Build an async HTTP server from scratch (without frameworks) - follow Jon Gjengset's stream
Implement a connection pool with timeouts and backpressure
Create a pub-sub system using Tokio's broadcast channels
Build a rate limiter using async semaphores

Phase 3: Advanced Patterns & Systems (8-12 weeks)

Week 15-17: Zero-Cost Abstractions

Goal: Write high-level code that compiles to optimal machine code

Resources:

📚 The Rust Performance Book - Entire book
🎥 Jon Gjengset - Crust of Rust: Sorting Algorithms - Performance patterns
📝 Cheap tricks for high-performance Rust
📝 The Rust Performance Book - Profiling
📝 Optimization - Rust Language Reference

Deep Dive:

Understanding LLVM IR: use Compiler Explorer (Godbolt) with Rust
Inlining, devirtualization, and constant folding
Profile-guided optimization
Reading assembly output with cargo asm (install with cargo install cargo-show-asm)
Study criterion.rs for benchmarking

Projects:

Benchmark different iterator patterns (.map().filter() vs manual loops)
Optimize hot paths using profiling tools (install cargo-flamegraph)
Write a zero-allocation parser
Study serde_json performance and try to beat it
Complete Exercism Performance-focused exercises

Week 18-20: Unsafe Rust & FFI

Goal: Know when and how to break the rules safely

Resources:

📚 The Rustonomicon - Read cover-to-cover (seriously!)
🎥 Jon Gjengset - Crust of Rust: Unsafe Code
🎥 Jon Gjengset - Crust of Rust: Lifetime Annotations (revisit)
📝 Learn Rust the Dangerous Way - LWN articles
📝 Unsafe Code Guidelines

Deep Dive:

Undefined behavior and how to avoid it
Raw pointers and their limitations
Writing sound unsafe abstractions
FFI with C libraries
Study std library unsafe usage - search for unsafe

Projects:

Implement a custom allocator (use std::alloc::GlobalAlloc)
Create Rust bindings for a C library using bindgen
Build a simple arena allocator
Study crossbeam's lock-free structures - careful unsafe usage
Contribute to Miri test cases (undefined behavior detector)

Week 21-23: Macros—Metaprogramming Mastery

Goal: Generate code at compile time elegantly

Resources:

📚 The Little Book of Rust Macros - Complete guide
📚 The Rust Reference - Macros
🎥 Jon Gjengset - Crust of Rust: Declarative Macros
🎥 Jon Gjengset - Crust of Rust: Procedural Macros
📝 Procedural Macros Workshop - Hands-on exercises

Deep Dive:

Declarative macros: pattern matching on syntax
Procedural macros: derive, attribute, function-like
Hygiene and macro expansion order
Use cargo expand to see macro output
Study syn and quote crates

Projects:

Complete dtolnay's proc-macro-workshop - All 5 projects
Write a custom derive macro for serialization
Build a builder pattern generator (study derive_builder)
Create a DSL using macros (e.g., SQL query builder)
Study serde_derive source

Week 24-26: Error Handling & Observability

Goal: Build production-ready error handling

Resources:

📚 Rust Book - Error Handling
📝 Error Handling in Rust - Andrew Gallant's guide
📝 Rust Error Handling - Modern patterns
📚 Read docs for: anyhow, thiserror, eyre
📚 Tracing documentation - Structured logging
🎥 Jon Gjengset - Error Handling in Rust

Study:

Error trait design: std::error::Error
When to use anyhow vs thiserror
Structured logging with tracing
Distributed tracing concepts

Projects:

Design a comprehensive error type for a multi-layer application
Instrument async code with tracing spans
Build a metrics collection system using tracing-subscriber
Study tokio-tracing examples
Create error report with full context chain (study eyre and color-eyre)

Phase 4: Real-World Systems (Ongoing)

Domain-Specific Mastery

Systems Programming:
Resources:

📚 Writing an OS in Rust - Complete tutorial series
📚 Embedded Rust Book
🎥 Jon Gjengset - Implementing TCP
Study redox-os source - OS written in Rust

Projects:

Follow Writing an OS in Rust completely
Implement a file system in userspace (FUSE)
Build a network protocol from scratch
Contribute to rust-lang std library

Web & Backend:
Resources:

📚 Actix Web Documentation
📚 Axum Documentation
📚 Rocket Guide
🎥 Let's build a web server from scratch - Jon Gjengset
📝 Command Line Apps in Rust

Projects:

Build a complete REST API with Axum
Implement WebSocket server with state management
Create a simple database driver from scratch (study tokio-postgres)
Build a web scraper with reqwest and scraper
Study rustls source - TLS implementation

Blockchain/DeFi:
Resources:

📚 Solana Cookbook - Free comprehensive guide
📚 Anchor Book - Framework documentation
📚 Solana Program Library - Study source code
📝 Understanding Solana's Account Model
📝 Borsh Specification

Projects:

Deep dive into Solana's runtime and BPF
Study Anchor framework internals (read source)
Implement AMM math from scratch (constant product, stable swap)
Build cross-program invocation patterns
Study successful programs: Serum DEX, Mango Markets
Understand account rent and program derived addresses

Performance Engineering:
Resources:

📚 The Rust Performance Book (revisit)
📝 Rust SIMD Guide
📝 Cache-Friendly Code
📝 Study ripgrep source - peak Rust performance

Projects:

Profile real applications with perf, cargo flamegraph
Optimize memory allocations using heaptrack
Study cache-friendly data structures
Learn SIMD programming with std::simd
Contribute performance improvements to open-source Rust projects

Continuous Learning Practices

Daily Habits (Pick 2-3)

Read source code (30 min): Study well-written Rust projects
- Essential repos to study:
  - tokio - Async runtime
  - serde - Serialization
  - clap - CLI parser
  - axum - Web framework
  - ripgrep - Fast grep
  - bat - Better cat
  - fd - Better find
Write code (1-2 hours): Build small experiments
- Rustlings daily
- Implement algorithms in Rust
- Recreate crates you use to understand them
Teach others:
- Answer questions on Rust Users Forum
- Write blog posts (host free on GitHub Pages)
- Contribute to Rust by Example

Weekly Activities

Code review: Review Rust PRs on GitHub
- Find projects with "good first issue" label
- Study how maintainers review code
Deep dive: Pick one concept and understand it completely
- Use The Book, Rustonomicon, or Reference
Build something: Work on a meaningful project
- Ideas: CLI apps, web services, games

Monthly Goals

Read papers:
- Rust papers/talks
- Distributed systems papers from Papers We Love
Contribute to OSS:
- Find Rust projects needing help on GitHub
- Start with documentation improvements
Write:
- Blog posts (free: dev.to, Medium, GitHub Pages)
- Share learnings on r/rust

Essential Free Resources Summary

📚 Must-Read Books (All Free!)

🎥 Video Series

Jon Gjengset - Crust of Rust - THE best advanced content
Let's Get Rusty - Great for beginners
No Boilerplate - Energizing short videos

DEV Community: Cargo

Rust Mastery Curriculum

Deep Rust Mastery Curriculum (Free Resources Edition)

Philosophy & Approach

Phase 1: Foundation & Mental Models (4-6 weeks)

Week 1-2: The Ownership Revolution

Week 3-4: Borrowing & Lifetimes—The Hard Parts

Week 5-6: Type System Mastery

Phase 2: Concurrency & Async (6-8 weeks)

Week 7-9: Fearless Concurrency Foundations

Week 10-12: Async Rust—The Complete Picture

Week 13-14: Async Ecosystems & Patterns

Phase 3: Advanced Patterns & Systems (8-12 weeks)

Week 15-17: Zero-Cost Abstractions

Week 18-20: Unsafe Rust & FFI

Week 21-23: Macros—Metaprogramming Mastery

Week 24-26: Error Handling & Observability

Phase 4: Real-World Systems (Ongoing)

Domain-Specific Mastery

Continuous Learning Practices

Daily Habits (Pick 2-3)

Weekly Activities

Monthly Goals

Essential Free Resources Summary

📚 Must-Read Books (All Free!)

🎥 Video Series