64 courses, two planes.

Rust from the first line

Variables, enums, pattern matching, Cargo, and a first honest meeting with ownership, on a command-line tool you write yourself. For people who have never written Rust, or who bounced off it once.

vec!["Ownership", "Enums", "Pattern matching", "Cargo"]

Ownership and lifetimes, for real

Moves, borrows, lifetimes, Box, Rc, Arc and interior mutability, until the compiler's errors read like advice. You rewrite a design the borrow checker keeps refusing, and find out why it was right.

vec!["Borrowing", "Lifetimes", "Smart pointers", "Interior mutability"]

Traits, generics and API design

Traits, generics, iterators, error handling and the patterns the standard library uses. You design a small crate with an API that makes the wrong call fail to compile.

vec!["Traits", "Iterators", "Error types", "Crate design"]

Deep dive

Write your own Vec

Raw pointers, allocation, unsafe contracts, undefined behaviour and the memory model. You build Vec and a small arena allocator from scratch, then run them under Miri until it has nothing left to say.

vec!["Unsafe", "Miri", "Allocators", "Memory model"]

Threads, Send and Sync

Threads, channels, Mutex and Arc, and the two marker traits that turn data races into compile errors. You write the program from our homepage, watch it fail to build, and then fix it three ways.

vec!["Threads", "Send", "Sync", "Channels"]

Async Rust with Tokio

Tasks, select, channels, timeouts, and the rules that keep one blocking call from stalling everything. You build a small network service and watch it run in tokio-console.

vec!["Tokio", "Tasks", "select!", "tokio-console"]

Async that holds up

Cancellation safety, streams, tower middleware, backpressure and graceful shutdown. You find the bug where a dropped future loses data, and design it out of the service for good.

vec!["Cancellation", "Streams", "tower", "Backpressure"]

Deep dive

An async runtime from scratch

Futures, Pin, wakers and a reactor on top of epoll: you write a working executor, then a small HTTP server on it, and test the hard parts with loom. Tokio stops being magic in about the fourth week.

vec!["Futures", "Pin", "Wakers", "loom"]

Testing Rust from the first test

Unit tests, integration tests, doc tests and cargo-nextest, and what the type system means you no longer have to test. For people who have been trusting the compiler to do everything.

vec!["Unit tests", "Doc tests", "cargo-nextest", "Coverage"]

Testing against the real thing in Rust

Real PostgreSQL in containers, sqlx test transactions, fakes behind traits and snapshot tests with insta. You delete the tests that were only testing the mocks.

vec!["sqlx", "Fakes", "insta", "Snapshots"]

Property tests and fuzzing in Rust

proptest, cargo-fuzz and cargo-mutants, to catch the cases nobody thought to write down. A parser that never panics is harder to write than it looks, and you'll have one by the end.

vec!["proptest", "cargo-fuzz", "cargo-mutants", "Panics"]

Deep dive

Load, failure and simulation in Rust

Load tests, fault injection and deterministic simulation with turmoil, where a whole network of services runs inside one process. You reproduce a one-in-a-million bug on demand, then fix it.

vec!["Load testing", "Fault injection", "turmoil", "Simulation"]

Your first Rust service

An HTTP API with axum, Tokio and serde: routing, extractors, validation and errors as types, with tests that call real handlers. For people who know a little Rust and want it to do a job.

vec!["axum", "serde", "Extractors", "Error types"]

Rust and PostgreSQL

sqlx and queries checked against a real database at compile time, connection pools, transactions and migrations. You change a column and let the compiler list every query you just broke.

vec!["sqlx", "Transactions", "Migrations", "Compile-time SQL"]

gRPC and service contracts in Rust

Protobuf, tonic, streaming, deadlines and tower middleware, plus the schema changes a client you can't see will survive. You connect a Rust service to a Go one and evolve the contract between them.

vec!["Protobuf", "tonic", "Streaming", "Versioning"]

Deep dive

A storage engine in Rust

A write-ahead log, a B-tree, memory-mapped files and crash recovery, built from an empty file with the type system guarding the invariants. You pull the plug mid-write and prove that nothing was lost.

vec!["WAL", "B-trees", "mmap", "Crash testing"]

SQL for Rust developers

Tables, keys, joins, aggregates, transactions and schema design, written by hand in psql and then called from Rust. For people who know the borrow checker better than they know a query plan.

vec!["Joins", "Transactions", "Schema design", "psql"]

Caching and Redis in Rust

In-process caches with moka, Redis behind them, and the expiry, invalidation and stampede problems that come with both. You make a read-heavy endpoint an order of magnitude faster and keep it correct.

vec!["moka", "Invalidation", "Stampedes", "Expiry"]

Streams with Kafka and NATS in Rust

rdkafka and async-nats, consumer groups, ordering and the transactional outbox, with backpressure from Tokio to the broker. You move one feature onto a stream without losing a single event.

vec!["rdkafka", "async-nats", "Outbox", "Backpressure"]

Deep dive

A query engine in Rust

A SQL parser, a planner and a vectorised executor over Apache Arrow, with enough of DataFusion read along the way to see how the real thing does it. You run one query through every stage and profile each of them.

vec!["Arrow", "DataFusion", "Query planning", "Vectorisation"]

Networks from a raw socket in Rust

TCP, DNS, timeouts and connection pools, with std::net on one side of the screen and a packet capture on the other. For people who know Rust and have only seen a network through a library.

vec!["TCP", "DNS", "Timeouts", "Packet capture"]

Build a reverse proxy in Rust

hyper, rustls and Tokio, with load balancing, health checks, retries and HTTP/2, in a proxy you write yourself. You put it in front of a real service and kill backends while the traffic keeps flowing.

vec!["hyper", "rustls", "Load balancing", "HTTP/2"]

Replication and consistency in Rust

Leaders, followers, quorums, clocks and what the word consistency actually promises, with the states of each protocol written as types. You partition your own store and see which guarantees survive.

vec!["Replication", "Quorums", "Clocks", "Type states"]

Deep dive

Write your own Raft in Rust

Leader election, log replication and snapshots, from the paper to a working key-value store, with the type system guarding the invariants and turmoil breaking the network. You find out why the paper is so careful.

vec!["Raft", "Consensus", "Snapshots", "turmoil"]

Secure Rust from day one

What memory safety covers and what it doesn't: input validation, injection, secrets and password hashing, built into a small service from the first commit. For people who assumed the compiler had this handled.

vec!["Validation", "Injection", "Secrets", "Password hashing"]

Authentication and authorisation in Rust

Sessions, OAuth 2, OpenID Connect, where JWTs help and where they hurt, and permissions encoded as types so a missing check won't compile. You secure one API for a browser and a mobile app at once.

vec!["OAuth 2", "OIDC", "JWT", "Typed permissions"]

TLS and cryptography in Rust

rustls, certificates, mutual TLS between services, and which primitives to reach for and which to leave alone. You run your own small certificate authority and rotate its keys without downtime.

vec!["rustls", "mTLS", "Certificates", "Key rotation"]

Deep dive

Breaking Rust services

Your own code, read the way an attacker reads it: logic bugs, panics as denial of service, unsafe blocks and the supply chain, with cargo-audit and cargo-vet on the way. You break into a deliberately weak service, then close every hole you used.

vec!["Panics", "Unsafe audits", "cargo-audit", "cargo-vet"]

Ship a Rust binary

Release profiles, static builds with musl, small images, cross-compiling, and CI that doesn't take twenty minutes. For people whose Rust has only ever run under cargo run.

vec!["Release profiles", "musl", "Containers", "CI caching"]

Observability in Rust

The tracing crate, OpenTelemetry, metrics and tokio-console, and why a span in async code is harder than it looks. You instrument a service until any slow request explains itself.

vec!["tracing", "OpenTelemetry", "Metrics", "Spans"]

Porting a service to Rust

Finding the part worth porting, measuring before you start, and moving traffic across one endpoint at a time. You replace one hot path in a running service and prove the gain, or prove there wasn't one.

vec!["Strangler pattern", "FFI", "Shadow traffic", "Benchmarks"]

Deep dive

Rust at high traffic

Profiling with perf and flamegraphs, allocators, zero-copy parsing, load shedding and running an incident. You keep a service up through a simulated launch day, then write the postmortem.

vec!["Flamegraphs", "Allocators", "Zero-copy", "Incidents"]