Summary

# ===== Core mental model =====
# Rust trades up-front strictness for runtime safety + speed.
# OWNERSHIP + BORROWING enforce memory safety at compile time.
# Result + Option encode errors + missing values in the type system.
# Zero-cost abstractions: high-level code compiles to tight assembly.

# ===== Daily reflexes =====
# - Default to immutable bindings (let); reach for let mut when truly mutating
# - Borrow over clone (&T over T) in function signatures
# - Result for fallible APIs; ? for propagation
# - Pattern matching (match, if let, let-else, while let)
# - Small modules + visibility via pub
# - Iterator chains over manual indexing
# - thiserror for custom error enums

# ===== Tools you reach for =====
# - cargo (build, test, run, fmt, doc)
# - cargo clippy -- -D warnings
# - cargo audit + cargo deny for supply chain
# - cargo nextest for faster tests
# - cargo machete for unused deps

# ===== Async + concurrency =====
# - tokio for async runtime; async/await syntax
# - Send + Sync traits enforce data-race safety at compile time
# - Bounded channels (tokio::sync::mpsc)
# - Structured concurrency via select! + CancellationToken
# - Avoid Mutex<HashMap<...>> when DashMap or sharding fits better

# ===== Production patterns =====
# - axum or actix for HTTP services
# - sqlx for typed SQL queries
# - tracing crate for structured logs + spans
# - serde for serialisation
# - Distroless static binaries via musl
# - --release builds in CI for benchmarks

# ===== Where Rust wins =====
# - Systems software (kernels, browsers, embedded)
# - Performance-critical services
# - Safety-critical code (cryptography, parsers, networking)
# - WebAssembly modules
# - CLI tools where every microsecond counts

# ===== Where Rust hurts =====
# - Quick prototypes (compiler argues with you)
# - GUI / desktop apps (ecosystem young: Tauri, egui, Slint)
# - Heavy refactor cycles in a small team
# - Anywhere Go / Python / TypeScript would do (speed is not always worth it)

# ===== What to learn next =====
# - Async deeper: pin, futures, select, structured concurrency
# - unsafe (when and why; rarely in app code)
# - FFI with C (extern "C")
# - Embedded Rust (no_std, embedded-hal)
# - WebAssembly (wasm-pack, wasmtime)
# - Procedural macros for codegen

# ===== Books + resources =====
# - The Rust Programming Language (the Book; free online)
# - Programming Rust (Blandy + Orendorff)
# - Zero to Production in Rust (Luca Palmieri)
# - Crust of Rust (Jon Gjengset on YouTube)
# - This Week in Rust newsletter

# ===== Patterns to internalise =====
# - Borrow > clone > own
# - Result + ? for error propagation
# - Iterator chains over loops
# - cargo clippy + rustfmt on save
# - Small modules + clear visibility

# ===== Closing thought =====
# Rust's strictness up front saves the bugs that take production down at 3am.
# The compiler is a brutal but fair teammate; once the borrow checker stops
# feeling like an obstacle, your code stops crashing. Reach for it when wrong
# code being impossible to compile is worth the time investment — and for many
# domains in 2026, that bargain pays back faster than anyone expected.

// Next: async ecosystems (tokio, axum), embedded (no_std), WebAssembly.