Rust Workbook and Development Guide

This repository is a practical, chaptered guide to modern Rust. It is designed to help you move from the language basics to advanced engineering topics without depending on external crates, hidden setup, or scattered notes.

No single repository can literally cover every library and domain in the Rust ecosystem, but this workbook covers the full language surface area you need to become productive and advanced in Rust: syntax, ownership, borrowing, lifetimes, data modeling, traits, modules, Cargo, testing, async, concurrency, macros, unsafe code, FFI, performance, and production workflows.

Repository map

• guide/00-roadmap.md: the overall learning path.
• guide/01-development-guide.md: day-to-day Rust engineering workflow.
• guide/02-project-recipes.md: patterns for libraries, CLIs, services, async apps, and FFI.
• guide/03-reference-and-cheatsheet.md: quick reference and review notes.
• workbook/: the chapter-by-chapter workbook with exercises and reflection prompts.
• src/: standard-library-only example modules that mirror the workbook topics.
• examples/: runnable binaries for quick practice.

Quick start

cargo test
cargo run --example basics
cargo run --example reliability
cargo run --example concurrency
cargo run --example async_walkthrough

Suggested study order

1. Read guide/00-roadmap.md to understand the progression.
2. Work through the chapters in workbook/ from 01 to 12.
3. Run and inspect the binaries in examples/.
4. Read the corresponding modules in src/ after each chapter.
5. Use the development guide when starting your own Rust project.

Workbook chapters

1. 01-getting-started.md
2. 02-ownership-borrowing-lifetimes.md
3. 03-types-control-flow-patterns.md
4. 04-structs-enums-collections.md
5. 05-traits-generics-lifetimes.md
6. 06-modules-crates-cargo-docs.md
7. 07-error-handling-testing-tooling.md
8. 08-iterators-closures-smart-pointers.md
9. 09-concurrency.md
10. 10-async-rust.md
11. 11-macros-unsafe-ffi-performance.md
12. 12-building-real-applications.md

How to use this repository well

• Read each chapter actively instead of passively.
• Write the exercise solutions before looking at the implementation modules.
• Change the sample code and rerun cargo test.
• Turn reflection prompts into flash cards or notes.
• Rebuild one small project at the end of every three chapters.

Capstone ideas

• Build a CLI notes application with file persistence.
• Build a small HTTP service with typed request/response models.
• Write a reusable library crate with documentation and tests.
• Expose a Rust function to another language through FFI.
• Profile and optimize a data-processing pipeline.

Success checklist

• You can explain ownership without using memorized phrases.
• You can choose between String, &str, Vec<T>, slices, and iterators confidently.
• You can design traits and generic APIs without over-abstracting.
• You can structure a multi-module Cargo project.
• You can test, lint, format, benchmark, and document a Rust codebase.
• You can reason about threads, channels, async tasks, and shared state.
• You can identify when unsafe code is truly necessary and how to isolate it.