Chapter 18: Rust Resources & Official Book Guide
You have reached the end of this book, but Rust is a large language with a fast-moving ecosystem. This chapter is a curated map: the canonical texts to read next, the tools to install, the references to keep open, and a suggested path from "I can write Rust" to "I am fluent in Rust."
Learning Objectives
- Know the official documentation and when to consult each piece.
- Build a daily-driver toolset with
rustup,cargo,clippy, andrustfmt. - Navigate the crate ecosystem and evaluate quality.
- Follow a deliberate path to fluency.
18.1 The official documentation
The Rust project maintains a set of books, all free and cross-linked. Each has a job:
| Resource | URL | Read it for |
|---|---|---|
| The Rust Programming Language ("the Book") | doc.rust-ownership.org/book | A guided, project-based introduction. The canonical starting point. |
| Rust by Example | doc.rust-lang.org/rust-by-example | Runnable snippets organized by topic — a quick reference. |
| The Rust Reference | doc.rust-lang.org/reference | Precise, definitive language semantics (not a tutorial). |
| The Rustonomicon | doc.rust-lang.org/nomicon | The dark arts: unsafe, FFI, low-level memory. |
| The Async Book | rust-lang.github.io/async-book | How async/await works under the hood. |
| The Cargo Book | doc.rust-lang.org/cargo | Everything about the build system and packaging. |
| The Edition Guide | doc.rust-lang.org/edition-guide | What changed between the 2015, 2018, and 2021 editions. |
| The API Guidelines | rust-lang.github.io/api-guidelines | How to design a Rust API that feels idiomatic. |
| std API docs | doc.rust-lang.org/std | The standard library reference. |
A healthy habit: keep doc.rust-lang.org/std open while you code, and read the source of any type you use heavily — the standard library is exemplary Rust.
18.2 The toolset
Every Rust developer should have these wired into their editor and CI:
rustup— manage toolchains and targets.rustup updatekeeps you current;rustup component addadds tools.cargo— build, test, document, and publish.cargo checkis the fast feedback loop;cargo build --releaseis for shipping.rustfmt— the official formatter. Runcargo fmtso formatting is never a code-review discussion.clippy— the linter.cargo clippycatches a long list of common mistakes and non-idiomatic patterns. Treat its warnings seriously; many are genuine bugs.cargo doc --open— generates and serves the documentation for your crate and its dependencies. Reading your own docs is a fine way to evaluate your API.
rustup component add rustfmt clippy
cargo fmt
cargo clippy --all-targets -- -D warnings
cargo test
cargo doc --open
18.3 The crate ecosystem
A few crates are so widely used they are almost part of the language. Knowing them saves you from reinventing:
| Domain | Crate | Purpose |
|---|---|---|
| Serialization | serde, serde_json | (De)serialization, the universal format layer. |
| Errors | thiserror, anyhow | Library and application error types. |
| Async runtime | tokio | The dominant async runtime. |
| HTTP server | axum, actix-web | Web frameworks. |
| HTTP client | reqwest | High-level blocking and async client. |
| Database | sqlx | Async, compile-time-checked SQL. |
| Logging | tracing, tracing-subscriber | Structured logs and spans. |
| Random | rand | The randomness ecosystem. |
| Regex | regex | Perl-like regular expressions. |
| CLI parsing | clap | Argument parsing with derive macros. |
| Date/time | chrono, time | Date and time arithmetic. |
| Parallelism | rayon | Data-parallel iterators. |
Evaluating a crate: check the download count and recent version dates on crates.io, read the README, scan open issues, and prefer crates that are actively maintained and have documentation. A crate with no release in two years is a liability.
18.4 A path to fluency
- Read the Book end to end. It is short for what it covers and builds a project (a
grepclone) as it goes. - Do
rustlings. A set of small exercises that fill in the gaps the Book leaves to practice. - Build something real. A CLI tool, a small web service, a game — a project of your own surfaces the questions no tutorial anticipates.
- Read good code. The standard library,
serde,tokio, andaxumare all well-written and educational. - Write
unsafelast. Most Rust programmers rarely need it; when you do, read the Rustonomicon first. - Engage the community. The
rust-usersforum, the Discord, and local meetups are friendly and deep.
18.5 Staying current
Rust releases every six weeks — a stable release train, not a long wait between major versions. Most releases are incremental. Watch for the occasional edition (a chance to introduce small language conveniences without breaking the ecosystem) and the annual Rust survey for a pulse on where the community is heading.
Keep rustup update in your routine, skim the release notes, and let clippy and rustfmt absorb the small style changes for you.
18.6 Closing
Rust's promise is that you can write fast, low-level code without the fear that usually accompanies it. The compiler is strict, but that strictness is what lets you refactor a large codebase with confidence, ship a service that does not crash on a null, or ship firmware that does not overflow a buffer. The investment to learn it is real, and so is the payoff.
Keep the standard library docs open, write a little code every day, and let the borrow checker teach you. Welcome to Rust.