Student Guide: Rust Programming Study Path

Rust has a reputation for being hard to learn. This guide's job is to make that reputation wrong for you — but only if you work through it, not skim it like a slide deck. If a topic is already familiar, don't slow down for it. Fast-read what you know and spend your real time on what you don't.

That's also why this isn't run as a class. A room full of people at different starting points and paces can't all be taught the same lecture at the same speed — someone is always bored, someone else is always lost. Self-study gets everyone to the same destination on their own schedule, and this guide exists to make that self-study efficient instead of a maze: what to read, in what order, and where to practice it.

Per module, do the Exercism exercises first if a topic feels foreign — in-browser editor, immediate feedback, before you touch anything real. Keep Rust Playground open in a tab the whole time; paste in anything you're unsure about and run it. Reach for Rustlings too — it hands you broken programs to fix, one of the most hands-on ways to actually learn a concept instead of just reading about it. hightechmind.io/rust/ rounds it out with more advanced worked examples per module — you don't need to reproduce these, just read and understand them. Don't worry about having the "best" or most current Rust toolchain — none of this requires it.

There's a real industry credential waiting down the road, at the end of Phase 2: the Ardan Labs Rust Certification exam. Treat it as a checkpoint, not the finish line. One real purpose of this program is to make you a reliable AI user — success with AI-assisted coding tracks your own programming knowledge, not the tool's. If you can't tell what the AI just did to your codebase, it's using you, not the other way around. Once you can read and judge the code it hands you, working with one becomes genuinely enjoyable instead of a gamble.

Here's why self-study specifically matters. Imagine I talked to you for an hour about writing business letters in French. Would you learn French? No — you'd walk away with a template you could reuse once and couldn't adapt, because you never learned the language, only the shape of one letter. I've watched that exact thing play out in cohort classes for two years, hitting the same wall every time. On-the-job learning fails the same way: you can't work out what to study against real job requirements while you're mid-deadline, and deadline stress is not a study environment.

Self-study, by contrast, is efficient. A class might get you through 50 pages in a year. You can read 50 pages in a weekend, on your own, at the depth you actually need.

This isn't about learning "just enough" Rust to script a few business tasks — we're well past that. The idea that you can get by with less has been sold for years, often by people billing for the gap it leaves, and it has never held up. You have the capacity for the real material — use it. Learn it properly so we can spend our time on more interesting problems than syntax, and so the wider open-source Rust ecosystem opens up to you instead of staying locked behind code you can't read.

Concretely, that means working through roughly a module every two weeks — one at a time, faster through what you already know, slower through the heavy ones like ownership or lifetimes — and letting that rhythm carry you through all 15. That's the whole system. No cohort, no deadline, no wasted motion.

This guide navigates our internal Comprehensive Rust Programming Curriculum. Each module lists all related study material from the sources below.

Source	What it covers	Modules
💪 Exercism ⭐	Start here for practice — 2–6 exercises per module with in-browser code editor and optional human mentor feedback (exercism.org/tracks/rust)	1–15
🖥️ Rust Playground	Official online Rust editor — run, share, test any snippet instantly in your browser, no install needed (play.rust-lang.org)	1–15
🦀 hightechmind.io/rust/	5–12 curated live working programs per module, matched to the specific topics taught in that module (1,128+ examples)	1–15
🏋️ Rustlings	Fix broken programs in your terminal — immediate feedback loop, 94 exercises (github.com/rust-lang/rustlings)	1–13
📖 Book chapters	Exact chapter + section links into The Rust Programming Language (free online · paperback/eBook $39.95)	1–15
📗 Programming Rust, 2nd ed. (O'Reilly $59.99)	Deeper treatment of every topic — excellent second text alongside the official book	2–15
📘 Rust for Rustaceans (NoStarch $39.95)	Advanced ownership, traits, macros, async — Jon Gjengset's book	8–15
🌐 Rust by Example	Browser-based: see any concept running instantly, then edit and re-run in-browser (doc.rust-lang.org/rust-by-example)	1–10
🎓 Comprehensive Rust (Google)	Google's structured 4-day course — alternative path through Rust foundations (google.github.io/comprehensive-rust)	1–5
📺 Jon Gjengset — Crust of Rust	Long-form video deep dives: smart pointers, channels, atomics, proc macros (YouTube playlist)	11–15
📙 The Little Book of Rust Macros	The definitive reference for `macro_rules!` and procedural macros (veykril.github.io/tlborm)	13
📊 Polars User Guide	Official documentation for the Polars DataFrame library (docs.pola.rs)	14
📰 Serde Documentation	Serialization framework — essential for CSV and data processing (serde.rs)	14

How to use this guide: For each module — do the Exercism exercises first (in-browser, no install). Then study the live hightechmind.io examples. Then read the book chapters. Use Rustlings for extra drilling. For quick experiments, paste any code snippet into play.rust-lang.org instantly. Watch Jon Gjengset for M11–15 when you feel stuck on a concept.

Course: Two-semester · ~33 weeks · designed for working professionals studying part-time.
Timeline: Start August 2026 → finish March 2027 (7.5 months).

	Phase	Weeks	Modules
Phase 1	The Foundation	1–10	Modules 1–5 · Chapters 1–7
Phase 2	Core Proficiency & Certification	11–27	Modules 6–12 · Chapters 8–16
Phase 3	Advanced Specialization	28–33	Modules 13–15

Phase 1 — The Foundation (Weeks 1–10)

Module 1 — Introduction & Environment Setup · rustup · cargo · Hello World
Module 2 — Common Programming Concepts · types · functions · control flow
Module 3 — Ownership, Borrowing, and Slices · move · borrow · references
Module 4 — Structs and Enums · impl · Option · match
Module 5 — Modules and Project Structure · mod · use · crates

Phase 2 — Core Proficiency & Certification (Weeks 11–27)

Module 6 — Common Collections · Vec · String · HashMap
Module 7 — Error Handling · Result · ? · custom errors
Module 8 — Generic Types, Traits, and Lifetimes · generics · traits · lifetimes
Module 9 — Automated Tests · unit tests · integration tests
Module 10 — Functional Features: Iterators and Closures · closures · Iterator · map/filter
Module 11 — Smart Pointers · Box · Rc · RefCell · Deref
Module 12 — Concurrency · threads · channels · Mutex · async/await
🎯 Certification Milestone — Rust Certification Exam · Ardan Labs · Week 27 · $99 · (Quick Reference at end ↓)

🎯 → Certification Milestone — Ardan Labs Rust Certification · Week 27 · $99 · online-proctored · Quick Reference ↓

Phase 3 — Advanced Specialization (Weeks 28–33)

Module 13 — Advanced Rust (Macros) · macro_rules! · proc macros · syn/quote
Module 14 — Data Processing with Polars and CSV · csv crate · Polars · DataFrame
Module 15 — Final Capstone Project · CLI · web server · data pipeline · TUI

📚 Reference Resources Guide — all books, tools, courses, certifications at a glance

Phase 1: The Foundation (Weeks 1–10)

Modules 1–5 · Book Chapters 1–7

Module 1: Introduction & Environment Setup

Goal: Get comfortable with the Rust toolchain and write the first program.

Topics: What is Rust · rustup / rustc / cargo · VS Code + rust-analyzer · cargo new/build/run/check · Hello World anatomy

Exercises: Install Rust and verify version · Create a new project using Cargo · Modify "Hello, World!" to print your name.

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapters 1–3 · Print/eBook — the primary course text
Ch 1 — Getting Started	Full chapter
Ch 1.1 — Installation	`rustup`, `rustc`, toolchain management
Ch 1.2 — Hello, World!	First program, anatomy of `main`
Ch 1.3 — Hello, Cargo!	`cargo new`, `cargo build`, `cargo run`, `cargo check`
Appendix D — Useful Dev Tools	`rustfmt`, `clippy`, IDE setup

🦀 hightechmind.io/rust/

Example	What it shows
006-palindrome-check	Short readable function — good first "real" program to study

💪 Exercism

Exercise	Focus
hello-world	The canonical first Rust exercise — run, modify, submit

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`intro1`	Fix a `println!` call — your first Rust compile-fix cycle
`intro2`	Print with format arguments `{}`
`clippy1`	Clippy: unnecessary floating-point operation — run `cargo clippy` for the first time
`clippy2`	Clippy: prefer `.is_none()` over `== None`
`clippy3`	Clippy: type cast that clippy warns about
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Comprehensive Rust	google.github.io/comprehensive-rust	Google's structured course — alternative path through foundations
Rust by Example	doc.rust-lang.org/rust-by-example	Browser-based examples — see any concept running instantly

Module 2: Common Programming Concepts

Goal: Learn the basic building blocks of Rust syntax.

Topics: Variables & mutability (let, mut, const) · Scalar types (integers, floats, booleans, chars) · Compound types (tuples, arrays) · Functions & return values · Control flow (if, loop, while, for) · cargo fmt

Exercises: Temperature converter (F→C) · Generate the n-th Fibonacci number.

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapter 3 — Variables, Types, Functions, Control Flow
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 3 — Basic Types · Chapter 6 — Expressions
Ch 3 — Common Programming Concepts	Full chapter
Ch 3.1 — Variables and Mutability	`let`, `mut`, `const`, shadowing
Ch 3.2 — Data Types	Integers, floats, booleans, chars, tuples, arrays
Ch 3.3 — Functions	Parameters, return values, statements vs. expressions
Ch 3.4 — Comments	`//` and `///` doc comments
Ch 3.5 — Control Flow	`if`, `loop`, `while`, `for`, ranges
Appendix B — Operators and Symbols	Complete operator reference

🦀 hightechmind.io/rust/

Example	What it shows
003-pattern-matching	`match` — the primary control flow construct
010-run-length-encoding	Loop logic, tuple return values, variable shadowing
022-range	Range expressions and `for` loops
069-sieve-eratosthenes	Boolean arrays, nested loops, algorithm in Rust
071-collatz-conjecture	`while` loop, integer arithmetic, mutability
071-gcd-lcm	Functions, recursion, integer types
824-sieve-of-eratosthenes	Full sieve with idiomatic Rust
826-gcd-lcm-euclid	Euclidean algorithm — clean recursive form

💪 Exercism

Exercise	Focus
lucians-luscious-lasagna	Variables, mutability, functions, const
raindrops	`if` / `else if` chains, string building
grains	Integer types, overflow, `Result` for invalid input
fizzbuzz	`for` loop + modulo — classic control flow
collatz-conjecture	`while` loop, integer arithmetic, `Option` result
leap	Boolean expressions, multiple conditions
gigasecond	Basic arithmetic on types
hamming	Loops, comparison, counting — simple algorithm

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`variables1`	Make an immutable variable compile
`variables2`	Add `mut` to allow reassignment
`variables3`	Declare variable before initializing it
`variables4`	Fix shadowing
`variables5`	Add the correct type annotation
`variables6`	`const` — name and annotate a constant
`functions1`	Call a function that doesn't exist yet
`functions2`	Fix a missing return type
`functions3`	Fix a function body (expression vs statement)
`functions4`	Make a function return a value implicitly
`functions5`	Return from nested block
`if1`	Simple `if/else` expression
`if2`	`if` as an expression with two branches returning values
`if3`	Chained `if/else if/else`
`primitive_types1`	Boolean operations
`primitive_types2`	Character literals
`primitive_types3`	Array declaration and access
`primitive_types4`	Array slices `&[T]`
`primitive_types5`	Tuple unpacking
`primitive_types6`	Index into a tuple `.0`, `.1`
`quiz1`	Quiz 1: variables + functions + if — all three together
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Comprehensive Rust	google.github.io/comprehensive-rust	Day 1 morning content — types, expressions, control flow
Rust by Example	doc.rust-lang.org/rust-by-example	primitives, flow_control, functions chapters

Module 3: Ownership, Borrowing, and Slices

Goal: Understand Rust's unique approach to memory management without a garbage collector.

Topics: Stack and heap · Ownership rules · Variable scope and drop · Move semantics vs. Copy · References and borrowing (&, &mut) · Rules of references · Slice type

Exercises: Fix ownership errors in provided code snippets · Write a function that takes a string and returns the first word.

⚠️ Take your time here. Ownership is the hardest part of the curriculum — and the most important. Everything else builds on it.

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapter 4 — Ownership, Borrowing, Slices
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 4 — Ownership · Chapter 5 — References
Ch 4 — Understanding Ownership	Full chapter — do not skip any section
Ch 4.1 — What is Ownership?	Stack, heap, move semantics, drop
Ch 4.2 — References and Borrowing	`&`, `&mut`, the one-writer rule
Ch 4.3 — The Slice Type	String slices, array slices

🦀 hightechmind.io/rust/

Example	What it shows
101-move-semantics	Move — values transferred, not copied
102-clone-copy	When `.clone()` is needed vs. `Copy` types
103-borrowing-shared	`&` references — read-only, many at once
104-borrowing-mutable	`&mut` — exclusive mutable access
113-string-str	`String` vs `&str` — the most common beginner confusion
114-slice-patterns	Slices as views into collections
115-vec-patterns	Vec slice patterns — destructuring collections
471-string-vs-str	Ownership of strings — `String` vs `&str` full breakdown
472-string-slices	String slice rules, `&str` in function signatures

💪 Exercism

Exercise	Focus
reverse-string	`&str` vs `String` — ownership across function boundaries
bob	Borrowing strings, `.trim()`, immutable references
run-length-encoding	Both sides: borrowing `&str` input, building owned `String`
two-fer	`Option<&str>` — optional borrowed string
phone-number	Iterating over `&str`, returning `Option<String>`
beer-song	Building strings, borrowing vs. owning
hamming	`Result` with borrowed string slices

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`move_semantics1`	Fix a move error — can't use moved value
`move_semantics2`	Pass by reference instead of moving
`move_semantics3`	Mutable reference — only one at a time
`move_semantics4`	Restructure code to avoid double-move
`move_semantics5`	Borrow and reborrow — tricky lifetime situation
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Comprehensive Rust	google.github.io/comprehensive-rust	Day 1 afternoon — ownership, borrowing, lifetimes
Rust by Example	doc.rust-lang.org/rust-by-example	scope, borrowing chapters

Module 4: Structs and Enums

Goal: Structure related data and define custom types.

Topics: Defining and instantiating structs · Tuple structs and unit-like structs · Methods and associated functions (impl) · Enums · Option<T> · match · if let

Exercises: Rectangle struct with area and perimeter methods · IpAddr enum for V4 and V6 addresses.

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapters 5–6 — Structs, Enums, Pattern Matching
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 9 — Structs · Chapter 10 — Enums and Patterns
Ch 5 — Using Structs	Full chapter
Ch 5.1 — Defining and Instantiating Structs	Struct syntax, field init shorthand, update syntax
Ch 5.2 — Example Program Using Structs	Worked Rectangle example — mirrors the exercise exactly
Ch 5.3 — Method Syntax	`impl` blocks, methods, associated functions
Ch 6 — Enums and Pattern Matching	Full chapter
Ch 6.1 — Defining an Enum	Enum variants, data in variants, `Option<T>`
Ch 6.2 — The match Control Flow	Patterns, exhaustiveness, catch-all arms
Ch 6.3 — if let	Concise single-pattern matching

🦀 hightechmind.io/rust/

Option and enums:

Example	What it shows
004-option-result	`Option` and `Result` side by side
041-option-basics	`Option<T>` — Rust's null-safety mechanism
042-option-map	`.map()` on `Option`
043-option-bind	`.and_then()` — chaining optional operations
044-option-filter	`.filter()` on `Option`
058-variants-days	Enum variants — modeling days of the week
060-option-safe-max	Safe maximum with `Option` return
062-records	Struct with named fields — record-style data

Pattern matching (full series):

Example	What it shows
561-pattern-or	`
562-pattern-guards	`if` guards in match arms
563-pattern-struct-destructuring	Destructuring struct fields
564-pattern-enum-variants	Matching enum variants with data
565-pattern-tuple-struct	Tuple struct patterns
566-pattern-nested	Nested patterns
567-pattern-binding-modes	`ref`, `ref mut`, binding modes
568-pattern-at-bindings	`@` bindings — match and capture
569-pattern-range	Range patterns (`1..=5`)
570-pattern-slice	Slice patterns `[head, tail @ ..]`
571-pattern-dotdot-wildcard	`..` to ignore remaining fields
572-pattern-ref-patterns	Reference patterns in match
573-pattern-let-else	`let ... else` — diverging on non-match
574-pattern-if-let	`if let` — concise single-pattern match
575-pattern-let-chains	`if let` chaining
576-pattern-matches-macro	`matches!` macro
577-pattern-irrefutable	Irrefutable vs. refutable patterns
578-pattern-exhaustiveness	The compiler's exhaustiveness check
579-pattern-string-matching	Matching on string slices
580-pattern-option-some-none	`Some(x)` / `None` patterns
582-pattern-tuple-matching	Matching on tuples
583-pattern-const-patterns	Constants as patterns
586-pattern-multiple-arms	Multiple patterns per arm
587-pattern-visitor-match	Visitor pattern via match
588-pattern-state-automata	State machines with enum + match
589-pattern-command-dispatch	Command dispatch table using match

💪 Exercism

Exercise	Focus
clock	Struct, `impl` block, `Display` trait, arithmetic
allergies	Enum + `match`, bitflag logic in struct
triangle	Struct + methods + boolean conditions
grade-school	Struct wrapping a HashMap, methods returning references
role-playing-game	Struct + `Option` fields + methods
beer-song	Enum + match for lyrics logic

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`structs1`	Classic C-style struct — field access
`structs2`	Struct update syntax `..other`
`structs3`	`impl` block with `is_bigger()` method
`enums1`	Enum variants — no data
`enums2`	Enum variants with data
`enums3`	`match` on enum — all arms must be handled
`options1`	`Option` — unwrap and handle `None`
`options2`	`if let Some(x)` — destructure an Option
`options3`	`while let Some(x)` — loop until None
`quiz2`	Quiz 2: strings + vecs + move semantics + modules + enums — broad combo
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Comprehensive Rust	google.github.io/comprehensive-rust	Day 2 morning — structs, enums, pattern matching
Rust by Example	doc.rust-lang.org/rust-by-example	custom_types, flow_control chapters

Module 5: Modules and Project Structure

Goal: Organize code into multiple files and modules.

Topics: Packages and crates · Defining modules (mod) · Paths (use, pub, super) · Separating modules into files

Exercises: Refactor a single-file program into a library crate and a binary crate.

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapter 7 — Packages, Crates, Modules
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 8 — Crates and Modules
Ch 7 — Managing Growing Projects	Full chapter
Ch 7.1 — Packages and Crates	What a package is, library vs. binary crate
Ch 7.2 — Defining Modules	`mod`, privacy rules, module tree
Ch 7.3 — Paths for Referring to Items	Absolute vs. relative paths, `super`
Ch 7.4 — Bringing Paths into Scope	`use`, `as`, re-exporting with `pub use`
Ch 7.5 — Separating Modules into Files	File layout for multi-file modules

🦀 hightechmind.io/rust/

Example	What it shows
063-stack-module	Complete module: private internals, public API surface
065-association-list	Encapsulated data structure with module boundary

💪 Exercism

Exercise	Focus
space-age	Clean struct — good project to refactor into lib/bin
magazine-cutout	HashMap ownership — natural multi-module candidate

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`modules1`	`mod` — bring an item into scope with `use`
`modules2`	`pub` — make an item visible outside its module
`modules3`	Multi-module: `use` across sibling modules
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Comprehensive Rust	google.github.io/comprehensive-rust	Modules and visibility section
Rust by Example	doc.rust-lang.org/rust-by-example	modules, crates chapters

Phase 1 Milestone: Write a CLI tool that accepts user input and processes it using structs and enums without fighting the borrow checker.

Phase 2: Core Proficiency & Certification (Weeks 11–27)

Modules 6–12 · Book Chapters 8–16

Module 6: Common Collections

Goal: Store data on the heap using standard library collections.

Topics: Vec<T> · String vs &str (UTF-8 text) · HashMap<K, V>

Exercises: Text interface to add employees to departments · Convert strings to Pig Latin.

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapter 8 — Vectors, Strings, Hash Maps
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 3 — Basic Types · Chapter 17 — Strings and Text
Ch 8 — Common Collections	Full chapter
Ch 8.1 — Storing Lists of Values with Vectors	`Vec<T>` creation, reading, updating, iteration
Ch 8.2 — Storing UTF-8 Encoded Text with Strings	Why you can't index strings — critical to understand
Ch 8.3 — Storing Keys with Associated Values in Hash Maps	`HashMap`, inserting, accessing, updating, entry API

🦀 hightechmind.io/rust/

Vec / list operations:

Example	What it shows
002-list-operations	Vec operations — push, pop, iterate
002-last-two	Last two elements — slice indexing
003-kth-element	Indexed access with `Option`
004-list-length	`.len()` and counting patterns
005-reverse-list	`.rev()` / reversing a Vec
007-flatten-nested-list	`Vec<Vec<T>>` — nested collections
008-eliminate-duplicates	Deduplication with `HashSet`
009-pack-consecutive	Grouping consecutive equal elements
014-duplicate-elements	Repeating elements in a Vec
015-replicate-n-times	`.repeat()` equivalent with Vec
016-drop-every-nth	Filtering by position
017-split-list	Splitting a list at a position
018-slice-list	Slicing with ranges
019-rotate-left	`.rotate_left()`
020-remove-kth	`.remove(i)` with bounds checking
021-insert-at	`.insert(i, val)`
115-vec-patterns	Pattern matching on Vec slices
351-btreemap-ordered	`BTreeMap` — sorted key-value storage
352-btreeset-sorted	`BTreeSet` — sorted unique values
353-vecdeque-deque	`VecDeque` — efficient front+back operations
354-binary-heap-priority	`BinaryHeap` — priority queue
370-small-vec-pattern	Small Vec optimization pattern

HashMap:

Example	What it shows
068-frequency-counter	`HashMap` for counting — the canonical use case
945-word-count	`HashMap<String, usize>` — string keys
082-nucleotide-count	Counting characters with `HashMap`
102-frequency-counter	Frequency table — ownership-aware version
356-hashmap-patterns	Common `HashMap` usage patterns
357-entry-api	The `entry()` API — insert-or-update idiom
359-multimap-pattern	`HashMap<K, Vec<V>>` — grouping multiple values per key

Strings:

Example	What it shows
113-string-str	`push_str`, `format!`, `chars()`
471-string-vs-str	Owned vs. borrowed — complete breakdown
472-string-slices	String slice rules
473-string-parsing-fromstr	`FromStr` / `.parse()`
474-string-formatting	`format!`, `write!`, padding, alignment
475-string-building	Building strings incrementally
476-string-splitting	`.split()`, `.splitn()`, `.split_whitespace()`
477-string-trimming	`.trim()`, `.trim_start()`, `.trim_end()`
478-string-searching	`.contains()`, `.find()`, `.rfind()`
479-string-replacing	`.replace()`, `.replacen()`
480-string-chars	`.chars()` — iterating over chars
481-string-bytes	`.bytes()` — iterating over bytes
482-string-unicode	Unicode awareness in Rust strings
483-string-encoding	Encoding / decoding
484-string-cow-usage	`Cow<str>` for avoiding unnecessary allocations
485-string-concatenation	`+` operator vs. `format!`
486-string-regex-pattern	Pattern-based string matching
487-string-interning	String interning patterns
488-string-owning-ref	Owning references to string data
489-string-arc	`Arc<str>` — shared string ownership
490-string-fixed-array	Fixed-size string buffers
492-osstr-handling	`OsStr` / `OsString` for system paths
494-string-number-conversion	`.parse()`, `.to_string()`
495-string-template-pattern	Template substitution patterns
496-string-diff-pattern	String diffing
497-string-case-conversion	`.to_lowercase()`, `.to_uppercase()`
498-string-truncation	Safe UTF-8 truncation
499-string-escape	Escape sequences
500-string-compression	Run-length compression on strings

💪 Exercism

Exercise	Focus
word-count	`HashMap` — counting word frequencies
anagram	`HashSet`, string comparison, `.chars()`
series	`Vec`, string slicing, `Option` for out-of-bounds
pangram	`HashSet` + char iteration
nucleotide-count	`HashMap` counting + error handling
custom-set	Building a generic collection type
matrix	`Vec<Vec<T>>` — 2D data access
etl	Transforming `HashMap` data
scrabble-score	`HashMap` lookup + char iteration
matching-brackets	`Vec` as a stack
tournament	`HashMap` aggregation, sorting
roman-numerals	Vec of tuples as a lookup table
magazine-cutout	`HashMap<&str, usize>` — borrowed keys

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`vecs1`	Create a Vec and push items
`vecs2`	Iterate over a Vec and map values
`strings1`	`&str` → `String` conversion
`strings2`	`.contains()`, `.replace()` methods
`strings3`	`.from()`, `.to_string()`, `.to_owned()`
`strings4`	Pass `&str` vs `&String` to functions
`hashmaps1`	Insert fruit counts into a HashMap
`hashmaps2`	`.entry().or_insert()` — avoid overwriting
`hashmaps3`	Build a score table — frequency counting pattern
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Rust by Example	doc.rust-lang.org/rust-by-example	std/vec, std/str, std/hash chapters

Module 7: Error Handling

Goal: Handle errors robustly using Rust's type system.

Topics: panic! · Result<T, E> · The ? operator · Custom error types

Exercises: Read a file and handle "file not found" vs "permission denied".

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapter 9 — Error Handling
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 7 — Error Handling
Ch 9 — Error Handling	Full chapter
Ch 9.1 — Unrecoverable Errors with panic!	When to panic, backtrace
Ch 9.2 — Recoverable Errors with Result	`match` on `Result`, `?`, chaining
Ch 9.3 — To panic! or Not to panic!	Decision guide — when each is appropriate

🦀 hightechmind.io/rust/

Option combinators:

Example	What it shows
041-option-basics	`Option<T>` fundamentals
042-option-map	`.map()` — transform the inner value
043-option-bind	`.and_then()` — chaining optional operations
044-option-filter	`.filter()` — conditionally discard the value
292-option-combinators	Full catalog of `Option` methods
302-option-transpose	`Option<Result<T,E>>` → `Result<Option<T>,E>`
305-unwrap-or-patterns	`.unwrap_or()`, `.unwrap_or_else()`, `.unwrap_or_default()`
306-ok-or-patterns	`.ok_or()` — converting `Option` to `Result`

Result and error handling:

Example	What it shows
045-result-basics	`Result<T, E>` — the foundation
046-result-map	`.map()` / `.map_err()`
047-result-bind	`.and_then()` — chaining fallible operations
048-error-propagation	The `?` operator
049-error-conversion	`From` trait — automatic error conversion
050-custom-error-types	Defining your own error enum
054-applicative-validation	Collecting multiple errors instead of short-circuiting
072-result-railway	Railway-oriented programming — clean chaining
072-error-accumulation	Collecting all errors from a sequence
073-validated-type	Validated type — errors accumulated in parallel
291-result-combinators	Full catalog of `Result` methods
293-question-mark-operator	`?` in depth — what it desugars to
294-custom-error-type	Custom error enum with `Display`
295-error-trait-impl	Implementing `std::error::Error`
296-from-trait-errors	`From` for error conversion — enabling `?` across types
297-thiserror-pattern	`thiserror` derive macro pattern
298-anyhow-pattern	`anyhow` for application-level errors
299-error-context	Adding context to errors
300-error-chaining	Chained error sources
301-result-transpose	`Result<Option<T>,E>` → `Option<Result<T,E>>`
303-collect-results	`collect::<Result<Vec<_>, _>>()` — fail-fast collection
304-partition-results	Separating `Ok` and `Err` values
307-error-propagation-closures	`?` inside closures — pitfalls
308-panic-vs-result	Decision table: panic vs. Result
310-infallible-conversions	`Infallible` error type
311-multiple-error-types	Unifying multiple error types with `Box<dyn Error>`
312-error-downcasting	`.downcast_ref::<T>()` on error traits
313-try-trait	The `Try` trait — what `?` uses
314-validated-accumulation	Accumulating errors without short-circuit
315-result-ok-err-methods	`.ok()`, `.err()`, `.is_ok()`, `.is_err()`
316-io-error-handling	`std::io::Error` — kind-based matching
317-parse-error-handling	`ParseIntError` and friends
318-error-display-debug	`Display` vs `Debug` for errors
319-error-in-tests	Errors in test functions — `-> Result<(), E>`
320-fallible-iterator	Iterating with `Result` items
581-pattern-result-ok-err	Pattern matching on `Ok(v)` / `Err(e)`
755-testing-error-paths	Testing that errors are returned correctly

💪 Exercism

Exercise	Focus
error-handling	Custom error types, `Result`, `From` — full workflow
nth-prime	Returning `Result` for invalid input
robot-name	Struct + `Result`, mutable state
wordy	Parsing user input — `Result` for malformed commands
custom-set	Generic collection with error-producing operations

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`errors1`	Return a `String` error instead of `panic!`
`errors2`	Propagate errors with `?` operator
`errors3`	Fix a `?` operator in a function returning `Option`
`errors4`	Custom error type with `Box<dyn Error>`
`errors5`	Multiple error types — `Box<dyn Error>` pattern
`errors6`	Implement `From` to convert between error types
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Rust by Example	doc.rust-lang.org/rust-by-example	error handling full chapter — `Result`, `?`, multiple error types

Module 8: Generic Types, Traits, and Lifetimes

Goal: Write flexible, reusable code and handle references correctly.

Topics: Generic functions & structs · Traits & default implementations · Trait bounds & impl Trait · Lifetimes ('a) · Elision rules · 'static

Exercises: Summary trait for NewsArticle and Tweet · longest function returning the longer of two string slices.

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapter 10 — Generics, Traits, Lifetimes
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 11 — Traits and Generics · Chapter 13 — Utility Traits
📘 Rust for Rustaceans (NoStarch, $39.95 · ISBN 978-1-7185-0185-0) by Jon Gjengset	Chapter 2 — Types · Chapter 3 — Designing Interfaces
Ch 10 — Generic Types, Traits, and Lifetimes	Full chapter — core reading
Ch 10.1 — Generic Data Types	`<T>` in functions, structs, enums
Ch 10.2 — Traits: Defining Shared Behavior	`trait`, `impl for`, default methods, bounds
Ch 10.3 — Validating References with Lifetimes	Annotation syntax, elision rules, `'static`
Ch 17.2 — Using Trait Objects	`dyn Trait` — runtime dispatch
Ch 19.3 — Advanced Traits	Associated types, newtype pattern, operator overloading
Ch 19.4 — Advanced Types	Type aliases, `!` type, DSTs

🦀 hightechmind.io/rust/

Core traits:

Example	What it shows
076-trait-objects	`dyn Trait` — heterogeneous collections
077-generic-bounds	`<T: Trait>` — constraining type parameters
078-where-clauses	`where` — readable complex bounds
079-associated-types	Associated types — cleaner than extra generics
081-newtype-pattern	Newtype — wrapping for type safety
082-type-aliases	`type` aliases — readable complex signatures
083-display-trait	`Display` — custom printing
084-from-into-traits	`From` / `Into` — type conversion
085-iterator-trait	`Iterator` — the most important trait to implement
123-impl-trait	`impl Trait` in argument and return position
124-dyn-trait	`dyn Trait` — when types vary at runtime
125-send-sync	`Send` + `Sync` — the thread safety traits
119-zero-cost-abs	Zero-cost abstractions — generics compile away, no runtime cost

Functional trait theory (category-theoretic traits):

Example	What it shows

Advanced trait patterns:

Example	What it shows
381-blanket-implementations	`impl<T: Trait> OtherTrait for T`
382-associated-types-advanced	Associated type defaults, multiple `impl`
384-trait-objects-dyn	`dyn Trait` — vtable dispatch
385-trait-objects-any	`dyn Any` — type erasure
386-object-safe-traits	Object safety rules
387-sealed-trait-pattern	Sealed traits — preventing external implementation
388-extension-trait-pattern	Extension traits — adding methods to foreign types
389-newtype-pattern	Newtype for orphan rule workaround
390-type-alias-impl-trait	TAIT — `type Foo = impl Trait`
391-impl-trait-return	`impl Trait` in return position
392-impl-trait-argument	`impl Trait` in argument position
393-trait-bounds-where	Complex `where` clauses
394-supertrait-pattern	Supertraits — requiring another trait
395-default-methods	Default method implementations
397-marker-traits	Zero-method marker traits
398-auto-traits	Auto-implemented traits
399-coherence-orphan-rules	Orphan rule — why `impl` has restrictions
400-trait-dispatch	Static vs. dynamic dispatch compared
401-deref-coercion	Deref coercions via the `Deref` trait
403-display-debug-traits	`Display` + `Debug` side by side
404-from-into-as	`From`, `Into`, `TryFrom`, `TryInto`
405-iterator-trait-deep	Deep dive into `Iterator` internals
406-hash-eq-ord-traits	`Hash`, `Eq`, `Ord`, `PartialOrd`
407-default-trait	`Default` — zero value for your type
408-clone-copy-traits	`Clone` vs `Copy` — semantic difference
409-drop-trait	`Drop` — custom cleanup logic
410-arithmetic-operator-overload	`Add`, `Sub`, `Mul` operator traits
309-never-type-errors	`!` (never type) — see Ch 19.4 Advanced Types above

Const generics:

Example	What it shows
126-const-generics	`<const N: usize>` — compile-time constant generics
127-const-functions	`const fn` — functions evaluated at compile time
774-const-generics-basics	`[T; N]` generic arrays
775-const-array-size	Fixed-size arrays parameterized by const
776-const-fn-basics	Compile-time computation
777-const-assert-patterns	`const_assert!` — compile-time guarantees
778-const-fibonacci	Fibonacci at compile time
779-const-lookup-table	Static lookup tables via const eval
780-const-generic-struct	Structs parameterized by constants
781-const-where-bounds	`where` on const generics
782-const-eval-patterns	Patterns for const evaluation
783-const-type-arithmetic	Type-level arithmetic with const generics

Lifetimes:

Example	What it shows
105-lifetime-basics	`'a` annotations — why the compiler needs them
106-lifetime-elision	When you do NOT write annotations
107-lifetime-structs	Structs holding references
531-lifetime-basics	Extended: multiple parameters
532-lifetime-multiple	Multiple lifetime parameters
533-lifetime-struct	Lifetime in struct definition
534-lifetime-impl	Lifetime in `impl` blocks
535-lifetime-enum	Lifetime in enum variants
536-lifetime-static	`'static` lifetime
537-lifetime-coercion	Lifetime coercions
538-lifetime-variance	Covariance / contravariance
539-lifetime-nll	Non-lexical lifetimes
540-lifetime-borrow-checker	Borrow checker reasoning
541-lifetime-elision	The three elision rules
542-lifetime-higher-ranked	HRTB — `for<'a>`
543-lifetime-trait-objects	`dyn Trait + 'a`
544-lifetime-closures	Lifetimes and closures
545-lifetime-split-borrow	Split borrows — borrowing different fields
546-lifetime-reborrow	Reborrowing `&mut`
548-lifetime-named-return	Named return lifetimes
549-lifetime-phantom	Phantom data lifetimes
557-lifetime-output-lifetime	Output lifetime annotation
558-lifetime-input-lifetime	Input lifetime annotation
560-lifetime-cheatsheet	All lifetime patterns in one reference

💪 Exercism

Exercise	Focus
accumulate	Generic function + trait bounds — re-implement `map`
dot-dsl	Builder pattern with generics and traits
role-playing-game	Traits + `Option` — shared behavior
space-age	Generic struct + trait implementation
clock	`Display` + `Add` trait implementation

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`generics1`	Generic function — add type parameter `<T>`
`generics2`	Generic struct — `struct Wrapper<T>`
`traits1`	Define and implement a trait
`traits2`	Default method implementation
`traits3`	Trait objects `Box<dyn Trait>` — dynamic dispatch
`traits4`	Trait bounds `where T: Trait`
`traits5`	`impl Trait` in function signatures
`lifetimes1`	Add `'a` annotation to a function returning a reference
`lifetimes2`	Struct with a lifetime-annotated reference field
`lifetimes3`	Fix the `'static` lifetime annotation
`conversions1`	`as` casting — numeric type conversion
`conversions2`	`From` and `Into` traits — type conversion
`conversions3`	`FromStr` — parse a string into a custom type
`conversions5`	`AsRef` and `AsMut` — cheap reference conversion
`conversions4`	`TryFrom`/`TryInto` — fallible conversion
`quiz3`	Quiz 3: generics + traits — `ReportCard` with generic grade type
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Rust by Example	doc.rust-lang.org/rust-by-example	generics, traits, lifetimes chapters

Module 9: Automated Tests

Goal: Ensure code correctness.

Topics: #[test] · assert!, assert_eq!, assert_ne! · #[should_panic] · Integration tests (tests/ directory)

Exercises: Comprehensive tests for the Rectangle struct.

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapter 11 — Automated Tests
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 11 — Testing
Ch 11 — Writing Automated Tests	Full chapter
Ch 11.1 — How to Write Tests	`#[test]`, assertions, `#[should_panic]`
Ch 11.2 — Controlling How Tests Are Run	Test filters, `--nocapture`, parallelism
Ch 11.3 — Test Organization	Unit vs. integration tests, `tests/` directory

🦀 hightechmind.io/rust/

Example	What it shows
744-unit-test-patterns	`#[test]`, `assert_eq!`, test module organization
745-integration-test-setup	`tests/` directory structure
746-doc-test-patterns	`///` doc-tests — documentation that compiles
747-test-fixtures	Shared setup across multiple tests
748-property-based-testing	Property-based tests — invariants not cases
749-fuzzing-concepts	Fuzzing with `cargo-fuzz`
750-snapshot-testing	Snapshot / golden file tests
751-mock-trait-pattern	Mocking with traits — testable design
752-test-doubles-taxonomy	Stubs, mocks, fakes, spies
753-bench-harness-pattern	`#[bench]` — micro-benchmarks
754-testing-async-code	Testing async functions
755-testing-error-paths	Testing error returns
756-tempfile-testing	Temporary files in tests
757-golden-file-tests	Comparing output against golden files
758-test-isolation-patterns	Keeping tests independent

💪 Exercism

Exercise	Focus
sieve	Tests provided — write code that makes them pass
perfect-numbers	`#[should_panic]`, `Result` returns in tests
grade-school	Multiple assertions per test, test organization
prime-sieve	Red-green-refactor cycle practice

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`tests1`	Write a test with `assert!`
`tests2`	`assert_eq!` and `assert_ne!`
`tests3`	`#[should_panic]` — test that code panics
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Rust by Example	doc.rust-lang.org/rust-by-example	testing chapter

Module 10: Functional Features: Iterators and Closures

Goal: Use functional programming patterns.

Topics: Closures (anonymous functions, environment capture) · Iterator trait and next · Consuming adapters (sum, collect) · Producing adapters (map, filter)

Exercises: Re-implement the IO Project (grep clone) using iterators and closures.

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapter 13 — Closures and Iterators
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 14 — Closures · Chapter 15 — Iterators
Ch 13 — Functional Language Features	Full chapter
Ch 13.1 — Closures: Anonymous Functions	`Fn`, `FnMut`, `FnOnce`, capture by reference/move
Ch 13.2 — Processing a Series of Items with Iterators	`Iterator` trait, adapters, consumers
Ch 12 — I/O Project (refactor section)	Applying iterators to the grep clone — the exercise itself

🦀 hightechmind.io/rust/

Closures — core:

Example	What it shows
005-currying	Partial application via closures
006-function-composition	Composing `f(g(x))`
051-applying-function-twice	Higher-order functions — apply f twice
001-higher-order-functions	Functions as values — the foundation of iterator chains
002-function-composition	Function composition operator
003-pipeline-operator	Pipeline `
074-currying-partial	Currying and partial application
120-closure-types	`Fn`, `FnMut`, `FnOnce` — the three traits
121-closure-capture	Capture by reference vs. move
122-higher-order-fn	Functions that accept and return functions
518-function-pointers	`fn` pointer vs closure

Closure series (501–530):

Example	What it shows
501-closure-capture-rules	Capture rules with ownership
502-fn-fnmut-fnonce	When to use each closure trait
503-closure-as-argument	Passing closures to functions
504-closure-as-return	Returning closures from functions
505-boxing-closures	`Box<dyn Fn(...)>` for dynamic closures
506-closure-move-semantics	`move` closures
507-closure-memoization	Caching closure results
508-closure-partial-application	Building specialized functions
509-closure-composition	Composing closures at runtime
510-closure-currying	Currying via closures
511-closure-recursive	Recursive closures
512-closure-state-machine	State machine using closure state
513-closure-strategy-pattern	Strategy pattern with closures
514-closure-observer-pattern	Observer pattern with closures
515-closure-once-cell	`FnOnce` + `OnceCell` lazy init
516-closure-environment	Closures as environments
517-closure-coercion	Closure coercion to `fn` pointers
519-closure-type-inference	Type inference in closures
520-closure-higher-order	Higher-order closure combinators
521-closure-map-reduce	Map-reduce via closures
522-closure-predicate	Predicate closures
523-closure-event-handler	Event handlers as closures
524-closure-builder-closures	Builder pattern with closures
525-closure-tap-pattern	`.tap()` — side effects in chains
526-closure-pipe-operator	Pipe operator via closures
527-closure-once-consumer	`FnOnce` consumer pattern
528-closure-lifetime-capture	Lifetime annotations with captured references
529-closure-async	Async closures
530-closure-benchmark-idioms	Benchmark idioms using closures

Iterators — core:

Example	What it shows
004-list-map-from-scratch	Building `map` from scratch
005-list-filter-from-scratch	Building `filter` from scratch
056-fold-right	Right fold
057-fold-left	Left fold — the basis of `reduce`
056-monad-result	`Result` as a computational context — chaining like `.map()`/`.and_then()` on iterators
068-tail-recursive-accumulator	Accumulator pattern — tail-recursive fold
069-unfold	`unfold` — generate sequences
070-scan-left	`.scan()` — accumulate and emit each step
085-iterator-trait	`Iterator` — `next()` and lazy evaluation
086-custom-iterator	Writing your own iterator type
087-iterator-adapters	`.map()`, `.filter()`, `.chain()`
088-iterator-consumers	`.collect()`, `.sum()`, `.fold()`
089-lazy-sequences	Lazy evaluation — nothing runs until consumed
090-infinite-iterators	Infinite iterators with `.take()`
091-zip-unzip	`.zip()` and `.unzip()`
092-scan-accumulate	`.scan()` — stateful iteration
093-windows-chunks	`.windows(n)` and `.chunks(n)`
094-peekable-iterator	`.peekable()` — look ahead
095-double-ended	`DoubleEndedIterator` — `.rev()`
096-exact-size	`ExactSizeIterator` — `.len()` on iterators
097-flatten-iterator	`.flatten()` / `.flat_map()`
098-partition-iterator	`.partition()` — split by predicate
099-group-by-iter	Group consecutive equal elements
100-step-by	`.step_by(n)`
101-lazy-sequences	Lazy sequence generation
103-unfold	`iter::from_fn()`
104-scan-left	`.scan()` left fold variant

Extended iterator series (256–290):

Example	What it shows
256-iterator-chain	`.chain()`
257-iterator-zip	`.zip()`
258-iterator-enumerate	`.enumerate()`
259-iterator-flat-map	`.flat_map()`
260-iterator-scan	`.scan()` with accumulator
261-iterator-peekable	`.peekable()` — parser lookahead
262-iterator-windows	`.windows(n)`
263-iterator-chunks	`.chunks(n)`
264-iterator-take-while	`.take_while()`
265-iterator-skip-while	`.skip_while()`
266-iterator-step-by	`.step_by(n)`
267-iterator-cycle	`.cycle()`
268-iterator-unzip	`.unzip()`
269-iterator-partition	`.partition()`
270-iterator-position	`.position()`
271-iterator-find-map	`.find_map()`
272-iterator-flatten	`.flatten()`
273-iterator-inspect	`.inspect()` — debug side effects
274-iterator-sum-product	`.sum()`, `.product()`
275-iterator-min-max	`.min()`, `.max()`
276-iterator-min-by-max-by	`.min_by()`, `.max_by()`
277-iterator-count	`.count()`
278-iterator-last	`.last()`
279-iterator-nth	`.nth(n)`
280-iterator-any-all	`.any()`, `.all()`
281-custom-iterator	Custom iterator — alternative approach
282-double-ended-iterator	`DoubleEndedIterator`
283-exact-size-iterator	`ExactSizeIterator`
284-fused-iterator	`FusedIterator` — always returns `None` after first `None`
285-iterator-adapter-pattern	Building custom iterator adapters
286-iterator-from-fn	`std::iter::from_fn()`
287-iterator-successors	`std::iter::successors()`
288-iterator-collect-into	`collect()` into different containers
289-iterator-extend	`Extend` trait
290-iterator-unzip-partition	Combined unzip + partition

💪 Exercism

Exercise	Focus
nucleotide-count	`.filter().count()`, `HashMap`
isbn-verifier	`.chars()`, `.enumerate()`, `.filter()`, `.fold()`
difference-of-squares	`.map()`, `.sum()`
all-your-base	Iterators + error handling combined
accumulate	Implement `map` without the standard library
sublist	`.windows()` — sliding window search
flatten-array	`.flatten()` / `.flat_map()`
pascals-triangle	`.zip()` + accumulated builds
minesweeper	2D iteration with closures
luhn	`.chars()`, `.rev()`, `.enumerate()`, `.fold()`
scrabble-score	`.chars()`, `.map()`, `.sum()`
pangram	`.collect::<HashSet<_>>()`
roman-numerals	Iterator fold over lookup table

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`iterators1`	Create an iterator with `.iter()` and `next()`
`iterators2`	`.map()` — transform each element
`iterators3`	`.filter()` and `.chain()` — compose iterators
`iterators4`	`.fold()` / `.sum()` — consuming iterators
`iterators5`	Complex iterator chain — `.flat_map()`, `.zip()`
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Rust by Example	doc.rust-lang.org/rust-by-example	closures, iterators chapters

Module 11: Smart Pointers

Goal: Advanced memory management capabilities.

Topics: Box<T> · Deref trait · Drop trait · Rc<T> (multiple ownership) · RefCell<T> (interior mutability) · Reference cycles

Exercises: Cons list using Box and Rc · Mock object using RefCell.

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapter 15 — Smart Pointers
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 5 — References · Chapter 22 — Unsafe Code
📘 Rust for Rustaceans (NoStarch, $39.95 · ISBN 978-1-7185-0185-0) by Jon Gjengset	Chapter 1 — Foundations (ownership, Box, Rc, RefCell)
Ch 15 — Smart Pointers	Full chapter
Ch 15.1 — Box<T>	Heap allocation, recursive types
Ch 15.2 — Deref Trait	`*`, deref coercions
Ch 15.3 — Drop Trait	Custom cleanup, `std::mem::drop`
Ch 15.4 — Rc<T>	Shared ownership, reference counting
Ch 15.5 — RefCell<T> and Interior Mutability	Runtime borrow checking
Ch 15.6 — Reference Cycles and Memory Leaks	`Weak<T>`, avoiding cycles

🦀 hightechmind.io/rust/

Example	What it shows
116-box-heap	`Box<T>` — heap allocation and indirection
117-recursive-types	`Box` for recursive data structures
118-deref-coercions	`Deref` trait — transparent pointer behaviour
108-rc-shared	`Rc<T>` — shared ownership, single thread
110-cell-interior	`Cell<T>` — interior mutability for `Copy` types
111-refcell-runtime	`RefCell<T>` — borrow checking at runtime
112-cow-clone-on-write	`Cow<T>` — clone only when needed
369-cow-clone-on-write	`Cow` in a data structure
355-linked-list-rust	Linked list in Rust — classic pointer challenge
361-rope-data-structure	Rope — `Arc<str>` chunks
363-arena-allocation	Arena allocator pattern
364-slab-allocator	Slab allocator pattern
368-persistent-data-structures	Immutable persistent structures via `Rc`
550-lifetime-cell-refcell	Lifetimes + `Cell`/`RefCell` interaction
551-lifetime-rc-weak	`Rc` with `Weak` to break cycles
552-lifetime-arena-pattern	Arena pattern with lifetimes
553-lifetime-self-referential	Self-referential structs — why they're hard

💪 Exercism

Exercise	Focus
simple-linked-list	`Box<T>` for recursive list structure
circular-buffer	Interior state — naturally uses `RefCell` patterns
doubly-linked-list	`Rc<RefCell<Node<T>>>` — the classic double-pointer problem
rpn-calculator	Stack using `Vec` — clean pointer management
paasio	Shared state with `Rc<RefCell<T>>`

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`smart_pointers1`	`Box<T>` — recursive enum (cons list) requires boxing
`smart_pointers2`	`Rc<T>` — multiple owners via reference counting
`smart_pointers3`	`Arc<T>` — thread-safe `Rc` with `Mutex`
`smart_pointers4`	`Cow<'a, T>` — clone-on-write: borrow or own
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Jon Gjengset — Crust of Rust	YouTube playlist	Smart Pointers episode — deep dive into `Box`, `Rc`, `RefCell`

Module 12: Concurrency

Goal: Write safe concurrent code.

Topics: spawn & join · Message passing (mpsc) · Shared state (Mutex<T> & Arc<T>) · Send & Sync traits

Exercises: Build a multi-threaded web server.

📖 Book

Chapter	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapters 16 + 20 — Concurrency + Web Server Project
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 19 — Concurrency · Chapter 20 — Asynchronous Programming
📙 Rust Atomics and Locks (O'Reilly, $54.99 · ISBN 978-1-098-11944-7) by Mara Bos — also free online	The definitive book on low-level concurrency in Rust
📘 Rust for Rustaceans (NoStarch, $39.95 · ISBN 978-1-7185-0185-0) by Jon Gjengset	Chapter 8 — Asynchronous Programming · Chapter 9 — Unsafe Code
Ch 16 — Fearless Concurrency	Full chapter
Ch 16.1 — Using Threads	`thread::spawn`, `join`, move closures
Ch 16.2 — Message Passing	`mpsc` channels, `send`, `recv`
Ch 16.3 — Shared-State Concurrency	`Mutex<T>`, `Arc<T>`, the canonical pattern
Ch 16.4 — Extensible Concurrency: Sync and Send	`Send`, `Sync` — compile-time thread safety
Ch 20 — Final Project: Web Server	Full multi-threaded server — the Module 12 exercise

🦀 hightechmind.io/rust/

Thread basics:

Example	What it shows
125-send-sync	`Send` and `Sync` traits explained
441-thread-basics	`thread::spawn`, `join`, move closures
442-thread-scoped	Scoped threads — borrow stack data in threads
443-arc-mutex-pattern	`Arc<Mutex<T>>` pattern in full
444-arc-rwlock-pattern	`Arc<RwLock<T>>` — read-many, write-exclusive
445-mpsc-channel	`mpsc` channel — send/recv
446-thread-pool-pattern	Thread pool — reuse threads
447-work-stealing	Work-stealing scheduler pattern
448-rayon-parallel	`rayon` — parallel iterators
449-rayon-join	`rayon::join()` — fork-join parallelism
450-crossbeam-channel	`crossbeam` channels — multi-producer multi-consumer
451-crossbeam-select	`crossbeam::select!` — wait on multiple channels
452-atomic-types	`AtomicBool`, `AtomicUsize`, `AtomicPtr`
453-memory-ordering	`Relaxed`, `Acquire`, `Release`, `SeqCst`
454-compare-exchange	CAS operations
455-lock-free-stack	Lock-free stack using atomics
456-once-cell-sync	`OnceCell` / `OnceLock` — lazy global state
457-condvar-pattern	`Condvar` — condition variables
458-barrier-sync	`Barrier` — wait for all threads
459-thread-local-storage	`thread_local!` — per-thread data
460-send-sync-bounds	`Send` + `Sync` bound constraints in practice
461-producer-consumer	Producer-consumer with channels
462-pipeline-concurrency	Pipeline stages connected by channels
463-fan-out-fan-in	Fan-out / fan-in work distribution
464-actor-pattern	Actor model with message passing
465-message-passing	Message passing patterns
466-concurrent-hashmap	Concurrent HashMap patterns
467-epoch-gc	Epoch-based garbage collection
468-lock-free-queue	Lock-free queue
469-parallel-reduce	Parallel reduce / fold
470-concurrent-btree	Concurrent B-tree

Async/await (related to concurrency):

Example	What it shows
321-async-basics	`async fn`, `.await`
322-future-trait	`Future` trait
323-async-block	`async { }` blocks
324-join-futures	`join!` — concurrent futures
325-select-futures	`select!` — first future wins
326-async-move-closure	`async move` closures
327-spawn-tasks	`tokio::spawn` task spawning
328-channel-async	Async channels
329-async-stream	Async streams
330-async-sink	Async sinks
331-timeout-async	Timeout on async operations
332-retry-async	Retry logic
333-async-recursion	Recursive async functions
334-pin-unpin	`Pin<T>` — why self-referential futures need pinning
335-waker-context	`Waker` — how executors wake tasks
336-executor-basics	Building a minimal executor
337-async-mutex	Async-aware `Mutex`
338-async-rwlock	Async `RwLock`
339-semaphore-async	Async semaphore
340-async-trait-pattern	`async-trait` crate pattern
341-buffered-stream	Buffered async streams
342-async-io	Async I/O operations
343-cancellation-token	Cancellation tokens
344-structured-concurrency	Structured concurrency pattern
345-async-drop	Cleanup in async contexts
346-runtime-context	Runtime context propagation
347-blocking-in-async	`spawn_blocking` for CPU-bound work
348-async-generator-pattern	Async generators
349-broadcast-channel	Broadcast channels
350-oneshot-channel	One-shot channels

💪 Exercism

Exercise	Focus
parallel-letter-frequency	`thread::spawn`, `Arc`, joining handles
bank-account	`Mutex` for shared mutable state

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`threads1`	`thread::spawn` + `.join()` — basic thread creation
`threads2`	`Arc<Mutex<T>>` — shared mutable state across threads
`threads3`	`mpsc` channels — send messages between threads
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Jon Gjengset — Crust of Rust	YouTube playlist	Channels episode, Atomics episode

Certification Milestone: Rust Certification Exam (End of Phase 2, Week 27)

You have completed Modules 1–12. This is the natural exam point.

Rust Certification (Ardan Labs)


Provider	Ardan Labs (Miami, FL — US-based)
Exam page	ardanlabs.training
Cost	$99 USD per attempt — no attempt limit, but each retake costs $99 again
Format	100 questions, foundational-to-intermediate level
Duration	90 minutes
Passing score	80%
Validity	2 years
Proctored	Yes — online, no scheduling required, take it on your own time
Last verified	2026-07-28 — re-check price/URL/format if it's been a while since this date

What the exam covers

Ardan Labs describes the exam as covering "the full range of Rust programming skills, from fundamentals to advanced topics," without publishing an official per-topic breakdown. The mapping below is this guide's own guess, not an Ardan Labs blueprint — if the real exam differs, that's expected, not a sign you studied wrong:

Likely topic area	Covered in
Syntax, types, control flow	Modules 1–2
Ownership, borrowing, lifetimes	Modules 3, 8
Structs, enums, pattern matching	Module 4
Modules and crates	Module 5
Collections, strings	Module 6
Error handling	Module 7
Traits and generics	Module 8
Testing	Module 9
Closures and iterators	Module 10
Smart pointers (`Box`, `Rc`, `RefCell`)	Module 11
Concurrency (threads, channels, `async`)	Module 12

Modules 13–15 are NOT required for this exam. Macros, Polars/CSV data processing, and the capstone are advanced specializations beyond a foundational-to-intermediate exam's scope — that is why they come after.

How to register

⚠️ There's no free retake — each attempt costs $99. Since the topic mapping above is our guess and not Ardan Labs' official syllabus, budget for the possibility that the real exam doesn't line up perfectly with it before you pay.

Go to ardanlabs.training
Purchase the Rust Certification exam ($99)
No scheduling needed — it's online-proctored and available on your own time
There is no attempt limit, but each attempt (including retakes) costs the full $99

Secondary certification options

Ardan Labs isn't the only real, verifiable Rust credential. If you want a second opinion or a different format, these held up under scrutiny:

Option	Provider	Format	Cost	Best for
Rust Programming Professional Certificate	Pragmatic AI Labs (edX)	5 self-paced courses (fundamentals → data engineering → DevOps → CLI tools → LLMOps)	~€420 (individual courses auditable free)	Learners who prefer build-and-submit over a timed exam, with coverage closer to Module 14's data-processing territory
Rust Certification Exam	W3Schools	60-question multiple choice, 60 min, 75% to pass, 3 attempts included	$95 (often discounted)	A cheaper, earlier checkpoint — it's explicitly "Foundational" level, so treat it as a Phase 1 confidence check, not a Week 27 substitute
Rust skill certification	CodinGame	Live coding assessment — write real code, not multiple choice	Free for individuals	Practical proof-of-work to complement Ardan Labs' knowledge-based format

None of these are Rust Foundation–accredited. As of 2026 the Foundation's RFTT program accredits training providers only, not individual certifications — despite some third-party listicles implying otherwise. If you see a "Rust Foundation Certified Developer" claim anywhere, it isn't real.

Final prep checklist (Week 26–27)

Complete all Rustlings exercises through Module 12
Solve 5+ Exercism exercises at the "hard" difficulty
Review Ardan Labs' own Rust training bundle if you want prep material aligned to the exam
Practice reading and reasoning about Rust code without IDE assistance
Time yourself: aim to solve a medium-difficulty exercise in under 15 minutes
Review unsafe, Pin, Send/Sync — these appear in Module 11–12 and trip up candidates

Phase 3: Advanced Specialization (Weeks 28–33)

Modules 13–15 — post-certification, not required for the Rust Certification exam

Module 13: Advanced Rust (Macros)

Goal: Metaprogramming — write code that writes code.

Topics:

Declarative Macros (macro_rules!) — syntax, matchers, transcribers, repetition, recursion, hygiene
Procedural Macros — custom derive, attribute-like, function-like · syn and quote

Exercises: my_vec! macro (like vec!) · Derive macro that implements Hello trait.

📖 Book & References

Resource	Section
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapter 19.5 — Macros
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 21 — Macros (declarative + procedural)
📘 Rust for Rustaceans (NoStarch, $39.95 · ISBN 978-1-7185-0185-0) by Jon Gjengset	Chapter 6 — Testing · Chapter 7 — Macros
Ch 19.5 — Macros	Declarative and procedural macros
The Little Book of Rust Macros	Full book — the definitive macro guide
Rust Reference — Macros	Official specification
Rust Reference — Procedural Macros	Derive, attribute, function-like proc macros

🦀 hightechmind.io/rust/

Declarative macros:

Example	What it shows
411-macro-rules-basics	`macro_rules!` — syntax and structure
412-macro-repetition	`$(...)*` — repetition patterns
413-macro-fragment-types	`expr`, `ty`, `ident`, `pat`, `tt` fragments
414-macro-recursive	Recursive macro expansion
415-macro-tt-munching	TT munching — consuming token trees
416-macro-builder-pattern	Builder pattern via macros
417-macro-vec-like	`vec!`-style macro — the exercise itself
418-macro-stringify	`stringify!` — compile-time to string
419-macro-cfg-attr	`#[cfg]` conditional compilation
420-macro-env	`env!` — compile-time environment variables
421-macro-include	`include!`, `include_str!`, `include_bytes!`
428-macro-hygiene	Macro hygiene — variable scoping rules
429-macro-scoping	Macro visibility and scoping
430-macro-debugging	Debugging macro expansion
431-macro-count-pattern	Counting repetitions in macros
432-macro-enum-dispatch	Enum dispatch via macro
433-macro-state-machine	State machine DSL via macros
434-macro-dsl	Domain-specific language in macros
435-macro-lazy-static	`lazy_static!` pattern
436-macro-newtype-derive	Newtype boilerplate via macro
437-macro-test-helpers	Test helper macros
438-macro-format-args	`format_args!` internals
439-macro-assert-variants	Custom assert macros
440-macro-log-pattern	Logging macros

Procedural macros:

Example	What it shows
422-derive-macro-concept	Derive macro concept
423-proc-macro-intro	Procedural macro basics
424-proc-macro-derive	Custom `#[derive(MyTrait)]`
425-proc-macro-attribute	Attribute-like macros `#[route(...)]`
426-proc-macro-function-like	Function-like proc macros `sql!(...)`
427-syn-quote-basics	`syn` and `quote` — parsing and generating tokens

Type-level patterns (macro-adjacent):

Example	What it shows
066-phantom-types	Phantom types — compile-time state
128-type-level-bool	Type-level booleans
129-type-level-nat	Type-level natural numbers
130-typestate-pattern	Typestate — state machines in types
131-builder-pattern	Builder pattern — types enforce valid construction
140-type-safe-printf	Type-safe format strings
734-typestate-basics	Typestate fundamentals
735-typestate-builder	Typestate builder — what derive macros enable
736-typestate-connection	Connection state: `Open`→`Authenticated`→`Closed`
737-typestate-file-handle	File handle with typestate safety
738-phantom-type-basics	`PhantomData` explained
739-phantom-units-of-measure	Units of measure via phantom types
740-phantom-variance-control	Variance control with `PhantomData`
741-parse-dont-validate	Parse-don't-validate — type-level guarantees
742-type-witnesses	Type witnesses
743-session-types	Session types — protocol enforcement

💪 Exercism

Exercise	Focus
macros	Direct `macro_rules!` practice

🏋️ Rustlings (fix broken programs: rustlings run <name>)

Exercise	What you fix
`macros1`	Call a macro that doesn't exist — understand the `!` call syntax
`macros2`	Write a `macro_rules!` that takes an argument
`macros3`	Macro with multiple patterns — `$(...)*` repetition
`macros4`	Macro export — `#[macro_export]` for crate-wide visibility
🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Jon Gjengset — Crust of Rust	YouTube playlist	Proc Macros episode — live coding a derive macro

Module 14: Data Processing with Polars and CSV

Goal: Efficiently handle and analyze large datasets using Rust.

Topics: CSV with the csv crate · Polars: Series and DataFrames · Filtering, selecting, sorting · Aggregations and GroupBy · Lazy vs. eager execution

Exercises: Read CSV weather data, calculate average temperature · Polars: load dataset, filter, export summary CSV.

📖 Books (Print / eBook)

Title	Chapters
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Chapter 17 — Strings and Text · Chapter 18 — Input and Output
📙 Zero To Production In Rust (self-published, $39.99 — also ebook) by Luca Palmieri	Chapter 5+ — data ingestion, serialization, production patterns

📖 Documentation & Guides

Resource	Section
Polars User Guide	Start with "Getting Started" then "Expressions"
Polars Rust API	Rust-specific API reference
csv crate docs	Reading, writing, serde integration
Serde documentation	Serialization framework — used by both csv and Polars
Serde JSON	JSON serialization/deserialization

🦀 hightechmind.io/rust/

Serialization:

Example	What it shows
759-manual-serialize-trait	`Serialize` by hand — understanding internals
760-serde-derive-concept	`#[derive(Serialize, Deserialize)]` — the standard path
761-custom-serialize-logic	Custom serialization for non-standard formats
762-custom-deserialize-logic	Custom deserialization with validation
763-json-format-from-scratch	JSON format implementation from scratch
764-binary-format-encoding	Binary formats — compact and fast
765-csv-parsing-pattern	CSV reading and writing
766-config-file-parsing	TOML/JSON config files
767-versioned-data-format	Handling versioned data schemas
768-zero-copy-deserialize	Zero-copy deserialization — no allocation
769-streaming-parser-pattern	Streaming parsers — files larger than RAM
773-serde-attributes-concept	`#[serde(rename)]`, `#[serde(default)]`, etc.

Parsers (data ingestion):

Example	What it shows
151-parser-intro	Parser combinator introduction
171-csv-parser	CSV parser from scratch
172-ini-parser	INI file parser
175-json-parser	JSON parser from scratch
770-recursive-descent-parser	Recursive descent parser
771-pratt-parser	Pratt parser — operator precedence
772-parser-combinator-pattern	Parser combinator composition

💪 Exercism (prerequisite data-processing skills — Exercism has no dedicated Polars exercises)

Exercise	Focus
saddle-points	2D data processing — grid filtering
largest-series-product	String parsing + numeric processing
matrix	Parsing text into 2D data structure
dominoes	Graph-style data manipulation
tournament	Parsing, aggregating, sorting tabular data — closest to Polars use case

🎓 Also in Curriculum (from Teacher Guide)

Resource	URL	What it adds
Polars User Guide	docs.pola.rs	Primary reference — start here before coding
Jon Gjengset — Crust of Rust	YouTube playlist	Serde / data processing episodes

Module 15: Final Capstone Project

Goal: Apply all learned concepts in a substantial, portfolio-ready application.

Options: CLI Tool (like ripgrep) · Web Server (multi-threaded, from scratch) · Data Pipeline (CSV/JSON → Polars → reports) · TUI Application (ratatui) · Embedded (microcontroller driver)

📖 Book & References

Resource	What to read
📕 The Rust Programming Language, 2nd ed. (NoStarch, $39.95 · ISBN 978-1-7185-0044-0)	Chapter 12 (grep project) · Chapter 20 (web server)
📗 Programming Rust, 2nd ed. (O'Reilly, $59.99 · ISBN 978-1-492-05259-5)	Full book — production-quality Rust reference
📙 Zero To Production In Rust (self-published, $39.99 — also ebook) by Luca Palmieri	Complete web service in production Rust — ideal Web Server capstone companion
📘 Rust for Rustaceans (NoStarch, $39.95 · ISBN 978-1-7185-0185-0) by Jon Gjengset	All chapters — write Rust like an expert
Ch 12 — I/O Project: grep	Full worked CLI tool — direct capstone blueprint
Ch 20 — Final Project: Web Server	Full multi-threaded server from scratch
ratatui docs	TUI framework for terminal dashboards
clap crate	CLI argument parsing — essential for CLI capstone
axum crate	Modern async web framework
tokio docs	Async runtime — the foundation for network services

🦀 hightechmind.io/rust/

Data structures for capstone projects:

Example	What it shows
029-binary-tree	Binary tree — fundamental structure
030-count-leaves	Tree traversal
035-layout-binary-tree	Tree layout algorithms
036-tree-string	Tree serialization to string
037-tree-preorder	Pre-order traversal
038-tree-inorder	In-order traversal
061-binary-tree	Binary tree — functional approach
105-trie	Trie data structure
251-quicksort	Quicksort
252-insertion-sort	Insertion sort
253-graph-bfs	BFS graph traversal
254-graph-dfs	DFS graph traversal
261-binary-search-tree	BST implementation
263-avl-tree	AVL self-balancing tree
362-trie-structure	Trie as a data structure
365-disjoint-set	Union-Find
366-segment-tree	Segment tree — range queries
367-fenwick-tree	Fenwick tree — prefix sums
375-lru-cache	LRU cache — important for real apps
376-bloom-filter	Bloom filter — probabilistic membership
377-graph-adjacency-list	Graph adjacency list
378-graph-adjacency-matrix	Graph adjacency matrix

Algorithms:

Example	What it shows
075-merge-sort	Merge sort
784-fibonacci-memo-tab	Dynamic programming: memoization + tabulation
785-knapsack-01	0/1 knapsack DP
786-longest-common-subsequence	LCS — string alignment
787-edit-distance-levenshtein	Edit distance
788-coin-change-dp	Coin change
798-kadane-max-subarray	Maximum subarray — Kadane's
799-bellman-ford	Shortest paths
800-floyd-warshall	All-pairs shortest paths
801-prims-mst	Prim's MST
802-kruskals-mst	Kruskal's MST
803-a-star-pathfinding	A* pathfinding
804-tarjan-scc	Tarjan's SCC
808-topological-sort-dfs	Topological sort
809-max-flow-ford-fulkerson	Maximum flow
814-kmp-pattern-matching	KMP string matching
821-trie-autocomplete	Trie autocomplete
834-convex-hull-graham	Convex hull
840-divide-and-conquer-pattern	Divide and conquer framework
841-backtracking-framework	Backtracking template
842-branch-and-bound	Branch and bound
843-memoization-generic	Generic memoization
844-greedy-algorithm-patterns	Greedy algorithm patterns
848-algorithm-complexity-guide	Big-O reference for all algorithms

Unsafe Rust / FFI / performance (advanced capstone):

Example	What it shows
699-raw-pointer-basics	Raw pointers
700-unsafe-block	`unsafe {}` blocks
701-unsafe-function	`unsafe fn`
710-extern-c-functions	FFI: calling C from Rust
712-ffi-string-conversion	`CString` / `CStr`
719-struct-of-arrays	SoA layout for cache performance
720-cache-friendly-iteration	Cache-friendly data access
722-memory-layout-repr	`#[repr(C)]`, `#[repr(packed)]`
724-zero-copy-parsing	Zero-copy parsing
728-inline-hints	`#[inline]`, `#[inline(always)]`
729-avoid-allocations	Allocation avoidance patterns
732-benchmarking-harness	Benchmarking — measure before optimizing

Learning paths — curated sequences:

The site organizes its 1,128 examples into topic-based learning paths on hightechmind.io/rust/by-learning-path.html (no per-path deep links — browse the page directly): List Operations & Basic Algorithms, Higher-Order Functions & Closures, Error Handling FP Style, Strings/Vectors & Data Types, Pattern Matching & Types, Data Structures & Collections, Iterators & Transformation.

💪 Exercism (final-stage challenges)

Exercise	Focus
poker	Complex domain: sorting, comparing, grouping
forth	Interpreter — stack machine, language design
react	Reactive event graph — dependency tracking, ownership
robot-simulator	State machine — structs + enums + methods combined
xorcism	Lifetime-heavy streaming XOR cipher
decimal	Arithmetic on custom types — operator overloading

Final Deliverable: A complete, tested, and documented Rust application to showcase in your portfolio.

Reference Resources Guide

Complete at-a-glance overview of every resource used in this curriculum. Use this page as your bookmark hub.

📖 Books

Title	URL	Cost	Format	Best For
The Rust Programming Language	doc.rust-lang.org/book	Free	Web / PDF	Modules 1–12 — the primary text
The Rust Programming Language (print)	nostarch.com	~$39.95	Paperback	Same content — desk reference
Rust by Example	doc.rust-lang.org/rust-by-example	Free	Web	Modules 1–12 — see every concept running in-browser
The Little Book of Rust Macros	veykril.github.io/tlborm	Free	Web	Module 13 — definitive macro reference
The Rustonomicon (Nomicon)	doc.rust-lang.org/nomicon	Free	Web	Module 15 (Unsafe) — unsafe Rust deep dive
The Async Book	rust-lang.github.io/async-book	Free	Web	Module 12 (Async) — async/await in depth
The Cargo Book	doc.rust-lang.org/cargo	Free	Web	Module 1 — build system and project management
The Rust Reference	doc.rust-lang.org/reference	Free	Web	All modules — language specification
Polars User Guide	docs.pola.rs	Free	Web	Module 14 — DataFrame library

🖥️ Interactive Practice & Online Playgrounds

Resource	URL	Cost	What You Do	Best For
Exercism — Rust Track	exercism.org/tracks/rust	Free (mentored)	Solve 100+ exercises with in-browser editor — no install needed. Optional human mentor feedback.	⭐ All modules — best hands-on practice
Rust Playground	play.rust-lang.org	Free	Official playground — run, share, format, Clippy-check any Rust snippet instantly. Shareable links.	All modules — paste any example, test immediately
Rust Explorer	godbolt.org/z/rust	Free	Compiler Explorer — see what your Rust compiles to (assembly, MIR, LLVM IR). Multiple Rust versions.	M3+ — understand what the compiler actually does
Rustlings	github.com/rust-lang/rustlings	Free	Fix 94 broken programs in your terminal — immediate red/green feedback loop	Modules 1–13 — fast syntax and concept drilling
Codewars — Rust	codewars.com/kata/search/rust	Free	Kata challenges in Rust with in-browser editor — community-rated difficulty	M5+ — algorithm practice beyond Exercism
LeetCode — Rust	leetcode.com	Free/Paid	2000+ algorithm problems — Rust is supported with in-browser editor	M8+ — interview prep in Rust
Rust Quiz	dtolnay.github.io/rust-quiz	Free	Tricky language questions with explanations	Modules 3–8 — deepen understanding
Replit	replit.com	Free/Paid	Full Rust project in browser — install crates, run `cargo` commands	M5+ — when you need a full project environment online

🎓 Courses

Resource	URL	Cost	Format	Best For
Comprehensive Rust (Google)	google.github.io/comprehensive-rust	Free	4-day course (self-paced)	Modules 1–5 — structured alternative to the book
Linux Foundation: Programming in Rust (LFD480)	training.linuxfoundation.org	Paid	Instructor-led	Modules 1–12 — deeper instructor-led alternative to self-study
Zero To Production In Rust	zero2prod.com	Paid book	Book + exercises	Module 15 (Web) — production web server in Rust

🎥 Video

Channel / Series	URL	Cost	Topics Covered	Best For
Jon Gjengset — Crust of Rust	youtube.com — playlist	Free	Smart pointers, concurrency, atomics, channels, proc macros	Modules 11–13 — deep dives
Jon Gjengset — Decrusted	youtube.com/@jonhoo	Free	Exploring popular crates (`tokio`, `serde`, `axum`)	Modules 12–15
Let's Get Rusty	youtube.com/@letsgetrusty	Free	Book chapters, ownership, traits	Modules 1–8 — accessible walkthroughs
Ryan Levick — Rust streams	youtube.com/@RyanLevicksVideos	Free	Rust in production, error handling	Modules 7–12

🦀 Live Examples Library

Resource	URL	Cost	Examples	Best For
hightechmind.io/rust/	hightechmind.io/rust	Free	1,128+ working programs	All modules — see every concept in working code
↳ by-learning-path.html	topic paths	—	List ops, HOFs/closures, error handling FP, strings/vectors, pattern matching, data structures, iterators	All modules

📜 Official Reference Docs

Resource	URL	What It Is
Standard Library Docs	doc.rust-lang.org/std	Full API reference — look up any type, trait, or function
Docs.rs	docs.rs	Docs for every crate on crates.io — essential for dependencies
Crates.io	crates.io	Package registry — find and choose crates
Lib.rs	lib.rs	Better crate search — categorised, ranked by quality
Rust API Guidelines	rust-lang.github.io/api-guidelines	How to design idiomatic APIs
Rust Forge	forge.rust-lang.org	Rust project processes
Are We Web Yet?	arewewebyet.org	Web framework status — which crates to use
Are We Async Yet?	areweasyncyet.rs	Async ecosystem status

🛠️ Tools

Tool	Install	What It Does
rustup	`curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs \| sh`	Toolchain manager — install Rust, switch versions
cargo	included with rustup	Build, test, run, publish
rust-analyzer	VS Code extension or rust-analyzer.github.io	IDE support — completions, errors, go-to-def
clippy	`rustup component add clippy` → `cargo clippy`	Linter — catches common mistakes
rustfmt	`rustup component add rustfmt` → `cargo fmt`	Formatter — enforces style
bacon	`cargo install --locked bacon`	Background code checker — auto-recompile/test on save (successor to the now-unmaintained cargo-watch)
cargo-expand	`cargo install cargo-expand`	Expand macros — essential for Module 13
cargo-flamegraph	`cargo install flamegraph`	Profiling — for Module 15 performance work
cargo-criterion	`cargo install cargo-criterion`	Benchmarking framework

🏆 Certifications

Certification	Provider	URL	Cost	When to Take
Rust Certification	Ardan Labs (Miami, FL)	ardanlabs.training	$99/attempt	Week 27 — after completing Modules 1–12
Member Training Offerings	Rust Foundation	rustfoundation.org/rust-foundation-trusted-training	Varies	Any time — lists accredited training providers

🗺️ Per-Module Resource Map

Module	Topic	Book Chapters	Curriculum Resources	Live Examples	Exercism
1	Setup	Ch 1, App D	Rustlings · Comprehensive Rust · Rust by Example	001, 006	hello-world
2	Common Concepts	Ch 3, App B	Rustlings · Comprehensive Rust · RBE flow_control	003, 022, 058, 069–071	lucians-lasagna · raindrops · grains · fizzbuzz
3	Ownership	Ch 4	Rustlings · Comprehensive Rust · RBE scope	101–104, 113–115	reverse-string · bob · run-length-encoding
4	Structs & Enums	Ch 5–6	Rustlings · Comprehensive Rust · RBE custom_types	041–044, 058, 061–590	clock · allergies · triangle
5	Modules	Ch 7	Rustlings · RBE modules	063, 065	space-age
6	Collections	Ch 8	RBE std/vec · RBE std/hash	002–028, 068, 073, 113, 471–500	word-count · anagram · pangram
7	Error Handling	Ch 9	RBE error	045–050, 072–073, 291–320	error-handling · wordy
8	Traits & Lifetimes	Ch 10, 17.2, 19.3–4	RBE generics · RBE traits	077–085, 123–150, 381–410, 531–560	accumulate · dot-dsl
9	Testing	Ch 11	RBE testing	744–758	sieve · perfect-numbers
10	Iterators & Closures	Ch 13	RBE closures · RBE iterators	054–057, 085–104, 256–290, 501–530	nucleotide-count · isbn-verifier · accumulate
11	Smart Pointers	Ch 15	Jon Gjengset: Smart Pointers	108–118, 355–368, 550–553	simple-linked-list · doubly-linked-list
12	Concurrency	Ch 16, 20	Jon Gjengset: Channels · Atomics	109, 321–350, 441–470	parallel-letter-frequency · bank-account
13	Macros	Ch 19.5 + tlborm	Jon Gjengset: Proc Macros	411–440, 422–427, 734–743	macros
14	Data Processing	Polars Guide · csv docs · Serde docs	Jon Gjengset: Serde episodes	171, 175, 759–773	saddle-points · tournament
15	Capstone	Ch 12 + Ch 20 + crate docs	Jon Gjengset: axum/tokio	251–263, 784–848, 699–732, path-*	poker · forth · react

Certification Quick Reference

You've completed Modules 1–15. Full certification details, exam coverage, registration steps, and the prep checklist live in one place to avoid two copies drifting apart: Certification Milestone: Rust Certification Exam ↑.

↑ Back to top

← Back to Learn Browse Live Examples →

Student Guide: Rust Programming Study Path

Contents

Phase 1: The Foundation (Weeks 1–10)

Module 1: Introduction & Environment Setup

Module 2: Common Programming Concepts

Module 3: Ownership, Borrowing, and Slices

Module 4: Structs and Enums

Module 5: Modules and Project Structure

Phase 2: Core Proficiency & Certification (Weeks 11–27)

Module 6: Common Collections

Module 7: Error Handling

Module 8: Generic Types, Traits, and Lifetimes

Module 9: Automated Tests

Module 10: Functional Features: Iterators and Closures

Module 11: Smart Pointers

Module 12: Concurrency

Certification Milestone: Rust Certification Exam (End of Phase 2, Week 27)

Rust Certification (Ardan Labs)

What the exam covers

How to register

Secondary certification options

Final prep checklist (Week 26–27)

Phase 3: Advanced Specialization (Weeks 28–33)

Module 13: Advanced Rust (Macros)

Module 14: Data Processing with Polars and CSV

Module 15: Final Capstone Project

Reference Resources Guide

📖 Books

🖥️ Interactive Practice & Online Playgrounds

🎓 Courses

🎥 Video

🦀 Live Examples Library

📜 Official Reference Docs

🛠️ Tools

🏆 Certifications

🗺️ Per-Module Resource Map

Certification Quick Reference