🎓 A1Learner
🔍

Rust Next Steps

A next-steps map points to the manuals and directions worth taking after a Rust course. The official books are already installed with a Rust install.

The road behind you

The Rust courses walked one road, in this order. Each stage leaned on the ones before it:

let road = ["Tutorial", "Data Structures", "Error Handling",
    "Generics & Traits", "Closures & Iterators", "Modules & Testing",
    "Smart Pointers", "Concurrency", "Async", "Tokio", "Advanced"];

The handbook is already installed

The official books came with your Rust install. You can open them with no internet at all:

// In your terminal:
// $ rustup doc          (the official books)
// $ rustup doc --std    (the standard library pages)

Find a method by searching

Real Rust work is half writing, half searching the docs. The std pages and docs.rs answer plain questions — like how to turn text into a number:

let n: i32 = "42".parse().expect("a number");
println!("n = {}", n);

Match a direction to a first step

Every direction starts from a door opened earlier on the road:

let direction = "web";
let first_step = match direction {
    "cli" => "Capstone 1: the grep clone",
    "web" => "the Tokio section, then Capstone 4",
    "systems" => "the Advanced section: FFI and unsafe",
    _ => "any capstone, started small",
};
println!("first step = {}", first_step);

Example

fn main() {
    let plan = [
        ("Build", "Capstone 1: grep clone"),
        ("Read", "std docs: Vec, HashMap, Iterator"),
        ("Build", "Capstone 4: chat server"),
        ("Share", "publish the crate from Capstone 5"),
    ];
    println!("A simple plan beats a big intention:");
    for (i, (kind, step)) in plan.iter().enumerate() {
        println!("{}. [{}] {}", i + 1, kind, step);
    }
}

Key points

  • The official Learn page offers three classic ways in
  • Read a guide (The Rust Programming Language, "the Book")
  • Study worked examples (Rust By Example)
  • Or repair small broken programs on your own machine (Rustlings)
  • Mixing all three beats any one alone
  • Use rustup doc to open the official books offline
  • rustup doc --std opens the standard library API pages
  • docs.rs: the generated documentation of every published crate lives there — searching it is a daily Rust habit
  • Three core manuals are worth keeping open
  • The Cargo Book covers projects and publishing
  • The Rustdoc Book covers documentation
  • The rustc Book covers the compiler's switches
  • Some directions have an official book waiting
  • Command-line tools have the Command Line Book
  • Embedded devices have the Embedded Book
  • WebAssembly has the Rust and WebAssembly Book
  • The deep end has doors too
  • The Reference gives the exact rules
  • The Rustonomicon covers unsafe Rust
  • The Unstable Book covers nightly-only features

In this example, plan is an array of four pairs. Each pair is a kind of step — Build, Read, Build, Share — and the step itself. The loop walks the array with .iter().enumerate(), so every step arrives with its position. Adding 1 turns positions into step numbers. println! then prints one plan line at a time. Build something. Read the manual for the pieces it used. Build something bigger. Then share the result. That rhythm — build, read, build, share — is how the capstones and the manuals work together.

Note

Finishing a course is the start, not the end

Rust skill grows by building small things often — one capstone at a time beats re-reading the whole course

Try it Yourself

Edit the code, then press Run.

Running is simulated · Rust Playground

Exercise

You finished the course and want to write a command-line tool for work. What is the best next step?