Table of contents · Rust

Part 0 — Start here

0.1 Setup: rustup, cargo, rust-analyzer, clippy
0.2 The series: OS → networking → security → HTTPS → Go → C → Rust
0.3 The Go ↔ C ↔ Rust phrasebook
0.4 The Rust labs: what you build for each guide in the series

Part I — Foundations: the Rust way

What Rust is, and why it exists
The toolchain: cargo, crates, editions, and what cargo build really does
Variables, mutability, shadowing, and scalar types
Control flow: everything is an expression
Functions, statements, and the unit and never types
Ownership: moves, copies, and drop
Borrowing: shared XOR mutable
Slices and strings: fat pointers and UTF-8
Structs, enums, and pattern matching
Error handling: Result, ?, and panics
Collections: Vec, HashMap, and friends
Modules, crates, and visibility
🔎 Checkpoint: ownership and borrowing
Terminal project: a word-frequency counter
Terminal project: a /etc/hosts-style config parser with real errors

Part II — Intermediate: traits, lifetimes, and the standard library 16. Traits and generics: shared behavior without inheritance 17. Trait objects: dyn Trait and dynamic dispatch 18. The standard traits you will implement every week 19. Lifetimes: naming how long a borrow is valid 20. Closures: Fn, FnMut, FnOnce 21. Iterators: lazy, composable, zero-cost 22. Smart pointers: Box, Rc, Arc, Cell, RefCell, Weak 23. Testing: unit, integration, doc tests, and property tests 24. I/O, files, processes, and application errors 25. 🔎 Checkpoint: traits and lifetimes 26. Terminal project: rgrep, a tested grep clone 27. Terminal project: an LRU cache, and why linked lists are hard in Rust

Part III — Advanced: concurrency, async, unsafe 28. Threads, and why data races do not compile 29. Shared state: Mutex, RwLock, atomics, Condvar, channels 30. Async Rust: futures, poll, and why async exists 31. Tokio in practice: tasks, select!, timeouts, cancellation, shutdown 32. Networking with std and Tokio: TCP, UDP, and framing 33. unsafe Rust: the five superpowers and the contract they carry 34. FFI: calling C from Rust and Rust from C 35. Macros: macro_rules! and what derive macros do 36. Performance: release profiles, benchmarks, profiling, allocations 37. Project: a thread pool from scratch 38. Project: a multi-room chat server with Tokio

Part IV — Systems Rust: the OS guide in Rust 39. Syscalls from Rust: std, libc, and nix 40. Processes, exit codes, and signals 41. Files that survive crashes: fsync and atomic replacement 42. Reading /proc: build your own ps 43. Memory: mmap and a counting global allocator 44. A container in 100 lines: namespaces with nix

Part V — Network and HTTP services: the networking and HTTPS guides in Rust 45. A DNS client from raw bytes 46. HTTP/1.1 from a bare TcpListener 47. A production HTTP server with Axum: limits, timeouts, tracing, shutdown 48. Outbound requests: timeouts, retries, idempotency, and an SSRF guard 49. TLS and mutual TLS with rustls 50. A reverse proxy with Hyper, and request-smuggling defenses

Part VI — Security-focused Rust 51. What Rust prevents, and what it does not 52. Cryptography done right: AEAD, password hashing, HMAC, constant-time, zeroize 53. Parsing untrusted input: newtypes, "parse, don't validate", resource bounds 54. Fuzzing and property testing 55. Supply chain: Cargo.lock, cargo audit, cargo deny, build.rs 56. Project: an auth service with Argon2 and JWTs

Part VII — Expert: internals and design 57. Memory layout: size, alignment, niches, repr(C), fat pointers 58. Inside Vec, String, Box, and trait objects 59. How async compiles: state machines, Pin, and a tiny executor 60. Variance, PhantomData, and drop check 61. Memory ordering: Relaxed, Acquire/Release, SeqCst, and a spinlock 62. API design: newtypes, typestate, builders, errors, and semver 63. Capstone: a Redis-compatible key-value server with persistence 64. Capstone: one HTTPS request, every layer, every guide, in Rust

Part VIII — Professional Rust 65. Debugging: backtraces, lldb/gdb, tokio-console, Miri 66. Workspaces, CI quality gates, release builds, and cross-compilation 67. Running Rust in containers and Kubernetes 68. How not to write Rust: an anti-pattern catalog

Appendices

A. Compiler-error decoder: the 15 errors you will actually see
B. Cargo and tooling cheat sheet
C. Glossary
D. A 90-day plan
E. Further reading and codebases worth reading