Rust

Rust delivers memory safety without a garbage collector, making it the language of choice for performance-critical systems, CLI tools, and increasingly, web backends. The 2026 ecosystem has matured significantly — Axum, Tokio, and SQLx cover most backend use cases with excellent ergonomics.

Why Rust in 2026

• Memory safety — no null pointer dereferences, no data races, no use-after-free — caught at compile time
• Performance — comparable to C/C++, significantly faster than Go or Java for CPU-bound work
• WebAssembly — Rust compiles to WASM with better performance than any other language
• AI/ML tooling — Candle (Hugging Face), Burn, and llama.cpp's core are written in Rust
• Growing adoption — Linux kernel, Android, Windows, Chrome all accept Rust code

Quick Start — Axum Web API

use axum::{routing::get, Router, Json};
use serde::Serialize;

#[derive(Serialize)]
struct Health { status: &'static str }

async fn health() -> Json<Health> {
    Json(Health { status: "ok" })
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/health", get(health));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Learning Path

1. Ownership and borrowing — the core mental model, borrow checker intuition
2. Error handling — Result<T, E>, ? operator, thiserror and anyhow
3. Async Rust — async/await, Tokio runtime, Arc<Mutex<T>> patterns
4. Web backends — Axum routing, extractors, middleware, state sharing
5. Database access — SQLx async queries, compile-time SQL verification
6. Systems topics — unsafe Rust, FFI, SIMD, embedded no_std

Ecosystem Overview