Rust

rustup installs and manages the toolchain (compiler, cargo, rustfmt, clippy) and lets you switch between stable and nightly. cargo is Rust’s build tool and package manager in one — it compiles, runs, tests, and resolves dependencies from crates.io. cargo new lays down a Cargo.toml manifest and a src/main.rs, so you have a runnable binary from the first command.

Every value in Rust has exactly one owner. When you assign a heap value like String to another variable, ownership moves — the original binding is no longer usable. This is how Rust frees memory deterministically with no garbage collector: when the owner goes out of scope, the value is dropped. To use a value without taking ownership, you borrow it with & (shared, read-only) or &mut (exclusive, mutable). The rule “many readers XOR one writer” is what eliminates data races at compile time.

Rust has no null and no exceptions. Absence is Option<T> (Some(v) or None); fallibility is Result<T, E> (Ok(v) or Err(e)). Because they are ordinary enums, the compiler forces you to handle both arms — you cannot accidentally use a missing value. The ? operator propagates an Err (or None) up to the caller in one character, so the happy path stays flat and readable.

match is Rust’s primary control-flow tool. It destructures values and binds their contents in one step, and it is exhaustive: if you add a variant to an enum later and forget to handle it, the code stops compiling. That turns a whole class of “forgot a case” bugs into build errors. Use if let when you care about only one variant, and _ as a catch-all only when a default is genuinely correct.

A trait declares a set of methods a type can provide; impl Trait for Type supplies them. Functions take trait bounds (fn f<T: Summary>(x: &T) or fn f(x: &impl Summary)), so they work for any conforming type. With static dispatch (generics) the compiler monomorphises a specialised copy per concrete type — the abstraction compiles away to the same code you’d write by hand, the literal meaning of “zero-cost”. When you genuinely need runtime polymorphism, &dyn Trait opts into dynamic dispatch instead.

serde is the de-facto framework for turning Rust data into formats and back. You #[derive(Serialize, Deserialize)] on a struct and a companion crate (serde_json, serde_yaml, …) does the format-specific work. Derives are checked at compile time, so a field-name or type mismatch is a build error, not a runtime surprise. cargo add writes the dependency into Cargo.toml for you, pinning a compatible version from crates.io.

Rust’s test runner is built into cargo. Unit tests live in the same file under a #[cfg(test)] module (compiled only for tests) and may call private functions. Mark each test with #[test] and assert with assert_eq! / assert!. cargo test builds the test binary and runs every test in parallel; a panicking assertion fails just that test. Integration tests go in a top-level tests/ directory and exercise only the public API.

Rust’s async is built on futures that do nothing until a runtime polls them; tokio is the dominant runtime that drives them and provides async I/O, timers, and tasks. axum is the tokio team’s web framework — handlers are plain async fns, routing is a typed Router, and extractors pull typed data out of a request. #[tokio::main] sets up the runtime so main itself can be async. The pairing gives you C-class throughput with the borrow checker still guarding shared state.

Concurrent handlers may touch the same data, so that data must be safe to share. Arc<T> is an atomically reference-counted pointer that lets many tasks own a handle to one value; Mutex<T> serialises mutation so only one task writes at a time. The compiler tracks the Send and Sync marker traits and refuses to compile a handler that would share non-thread-safe state — the data race is caught at build time, not in production. In async code prefer tokio::sync::Mutex when a lock is held across an .await.

A lifetime is the span during which a reference is valid. The borrow checker tracks them automatically; you only write annotations when a function returns a reference and the compiler cannot infer which input it borrows from. fn longest<'a>(x: &'a str, y: &'a str) -> &'a str says “the returned reference lives at least as long as both inputs”. This is purely a compile-time contract — there is no runtime cost — and it is what makes returning a borrow into a caller’s data provably safe with no dangling pointers.

A debug build skips optimisations; never judge performance from it. cargo build --release turns on the optimiser (opt-level = 3 by default), often a 10–100x difference on hot numeric code. criterion is the standard statistical benchmarking crate: it runs many iterations, accounts for variance, and reports confidence intervals, so a “faster” claim is real and not noise. Profile with a sampling profiler (e.g. perf + a flame graph) to find the hot function, then optimise only what the data proves is hot.