Rust

Derive macros. Build: round-trip a struct through JSON, CBOR, postcard. Output: byte-size comparison.

N-dim arrays, broadcasting, strides. Build: a small matmul + a broadcast op. Output: memory-layout diagram.

DataFrames, lazy frames, joins. Build: re-analyze the Python ETL dataset. Output: the same plot, in Rust.

Static charts. Build: render every chart this course has produced so far. Output: PNG gallery.

Tensors, autograd, two-layer MLP. Build: a 2-layer MLP trained end-to-end on MNIST. Output: loss curve + a few correct/incorrect predictions.

Partition keys, single-table. Build: a contacts app. Output: item + GSI diagram.

Managed Redis. Build: cache layer in front of RDS. Output: hit-rate + p99 latency chart.

Build: fanout pipeline (SNS → multiple SQS). Output: message-flow diagram.

Subnets, route tables, NAT, IGW. Build: multi-AZ VPC by hand. Output: network topology diagram.

ALB vs NLB vs GWLB. Build: ALB across two EC2s. Output: round-robin traffic chart.

DNS at scale. Build: latency-based routing across regions. Output: per-region latency map.

CDN, edge caching. Build: sign URLs, cache static + dynamic. Output: origin-vs-edge latency chart.

Build: role-based IAM + a Cognito federated login. Output: policy graph + signed-request walkthrough.

Web firewall and DDoS. Build: WAF rule blocking SQLi. Output: before/after attack-success rate chart.

Metrics and audit. Build: dashboard + alarm + audit query. Output: dashboard screenshot + audit-log table.

Tracing and compliance. Build: trace a request, run a config rule. Output: trace flame graph + compliance status.

Managed ML + Cost Explorer/Trusted Advisor. Build: train an MLP on SageMaker; render a Cost Explorer breakdown for it. Output: training curve + cost pie chart.

Build: a parallel sum the compiler accepts and one it rejects. Output: what-compiles matrix.

mpsc, crossbeam. Build: worker pool. Output: job-flow timeline.

Build: shared counter, race-then-fix. Output: contention plot.

wait/notify. Build: a bounded buffer with cv signaling. Output: producer/consumer timeline.

Counting permits, the often-wrong-primitive lesson. Build: a connection-pool limiter. Output: permit-count timeline.

Ordering made concrete. Build: lock-free counter, SPSC queue. Output: before/after reordering diagrams.

Build: coarse vs fine-grained locked HashMap. Output: throughput-vs-threads chart.

Data race vs deadlock vs atomicity violation. Build: one reproducible example of each. Output: taxonomy table + trace per bug.

Two-thread alternation. Build: condvar version and channel version. Output: interleaving trace.

Three-way coordination. Build: three threads + two semaphores. Output: per-thread Gantt.

Four-way work distribution. Build: one thread per output type. Output: output trace + per-thread tick count.

Barrier for grouped threads. Build: a 2H+1O barrier. Output: molecule-assembly timeline.

Build: `BlockingQueue<T>` with bounded capacity. Output: blocking-then-unblocking timeline.

Build: `TTLCache<K, V>` with `RwLock` + background expirer thread. Output: hit/miss/evict timeline.

Lock striping, dashmap-style. Build: a 16-stripe HashMap. Output: contention heatmap by stripe.

Build: atomic-bitset Bloom filter. Output: false-positive rate vs load chart.

Divide-and-conquer parallelism. Build: parallel merge sort with `rayon::join`. Output: speedup-vs-cores chart.

Futures, wakers. Build: 300-line executor running ten tasks. Output: runtime trace.

Tasks, `select!`, cancellation. Build: port scanner with timeouts. Output: live port-state grid.

Addresses, fragmentation, TTL. Build: parse and pretty-print an IP packet from hex. Output: annotated packet diagram.

Connectionless datagrams. Build: a UDP echo server + a packet-loss simulator. Output: loss-vs-throughput chart.

Sockets, three-way handshake. Build: `TcpListener` echo server. Output: Wireshark-style capture.

ping, traceroute. Build: both, by hand. Output: hop-by-hop latency table.

IP → MAC on the LAN. Build: raw-socket ARP query. Output: ARP cache view, before/after.

Auto-config. Build: a tiny DHCP client. Output: DORA sequence diagram.

Path vectors at internet scale. Build: a toy BGP speaker between two ASes. Output: AS-path graph.

Build: 300-line HTTP server. Output: one-request sequence diagram.

Handshake, cert chain, AEAD. Build: a TLS 1.3 client speaking to a real server (using ring for primitives, not building crypto from scratch). Output: handshake state machine + key-derivation trace.

HTTP over TLS, HSTS, cert pinning. Build: an axum server with rustls. Output: browser padlock + cert chain rendered.

Upgrade, frames, pings. Build: chat server. Output: live multi-client terminal chat.

UDP packets, raw event-loop. Build: a dig clone + a mio echo server. Output: parsed DNS answer + event-loop tick diagram.

DMA, MMIO, polling vs interrupts. Build: simulate each model in userspace. Output: throughput chart per model.

Geometry, rotational latency. Build: model an HDD with seek + rotation. Output: access-pattern latency chart.

FTL, wear leveling, GC. Build: a tiny FTL with garbage collection. Output: erase-block heatmap.

0/1/5/6. Build: a software RAID-5 striper with parity. Output: read/write/rebuild speed chart.

Disks pretend to be byte streams. Build: read/write a raw block device file. Output: IO-size vs latency chart.

Build: 300-line WAL. Output: crash-then-recover animation.

Build: put/get/delete crash-safe. Output: throughput vs sled.

Pages, splits, merges. Build: single-file B-tree. Output: page-layout viewer.

Memtable, SSTables, compaction. Build: tiny LSM. Output: compaction animation.

Build: MVCC on the KV store. Output: two transactions seeing different snapshots.

Checksums, end-to-end verification, scrubbing. Build: CRC32 + a ZFS-style scrubber. Output: corruption-detection trace.

Build: same workload, both engines. Output: read/write/space three-way chart.

Inodes, directories. Build: parse an ext2 image from hex. Output: annotated hex viewer.

Build: mount a filesystem on your KV store. Output: live tree of the mounted FS.

Crash safety, atomic renames. Build: a journal on top of FUSE. Output: before/after crash mid-write.

Cylinder groups, the historical leap. Build: a cylinder-group-aware allocator on top of FUSE. Output: allocation-locality heatmap.

Append-only segments. Build: an LFS-style allocator. Output: segment-utilization chart over time.

Layered images. Build: lower + upper, render merged. Output: three-pane diff viewer.

Network and whole-file caching. Build: tiny NFS-shaped server + an AFS-shaped client. Output: cache-state diagram per model.

Single leader, multi-leader, leaderless. Build: a replicated KV with chosen consistency. Output: replication-lag chart + consistency-anomaly trace.

Leader election, log replication. Build: a 3-node Raft. Output: election timeline + log convergence.

Build: a vector clock + a partition simulator. Output: concurrent-event graph.

Distributed transactions. Build: a 2PC coordinator + a saga compensator. Output: sequence diagram per protocol.

Spans, baggage, sampling. Build: propagate a trace-id across three services. Output: flame graph.

Threat models, trust boundaries, defense in depth. Build: a STRIDE threat-model doc for one of your earlier projects. Output: the threat-model table + a trust-boundary diagram.

Passwords, salts, MFA, password-less. Build: Argon2 + TOTP MFA. Output: hash-derivation trace + QR code for TOTP setup.

Capabilities vs ACLs vs RBAC vs ABAC. Build: a policy engine evaluating all four models. Output: per-model permission matrix.

Symmetric, asymmetric, hashes, signatures, AEAD. Build: each primitive once from a textbook recipe (slow, educational; never ship). Output: round-trip animation per primitive.

Kerberos, OAuth 2, signed requests. Build: an OAuth 2 client and resource server. Output: token-flow sequence diagram.

SQLi, XSS, CSRF, buffer overflow. Build: break and fix one of each in your axum/sqlx code. Output: before/after request-flow diagrams.

Build: `no_std` Linux binary via libc. Output: binary-size comparison.

Build: a linker script + `_start`. Output: annotated `readelf`.

Build: cargo runner → QEMU → serial. Output: serial console screenshot.

Build: draw a red square. Output: the red square in QEMU.

Build: IRQ handler that echoes. Output: live framebuffer echo.

What a CPU actually understands, and why an ISA is a contract that outlasts every chip that implements it. Build: emit a Rust function as ARM assembly with cargo --emit=asm. Output: Rust source next to its disassembly.

Same Rust source, two architectures, two outputs the compiler decides. Build: rustup target add x86_64-apple-darwin, write one function, compile for both. Output: ARM assembly next to x86 assembly for the same code.

Why Relaxed vs SeqCst matters more on ARM than on x86, and how Rust's atomics let you choose. Build: a microbench that races two threads with different Ordering values. Output: timing diff between Relaxed and SeqCst on Apple Silicon.

Why one big core lost to thousands of small ones for the right kind of problem. Build: a wgpu Rust example that multiplies matrices on your Mac's Metal GPU. Output: CPU vs GPU timing chart for a matrix multiply.

The plan. Build: none. Output: kernel architecture diagram.

How the kernel hands the CPU to user code and gets it back. Build: a trap on a software interrupt. Output: trap entry/exit register diagram.

Build: a `Process` struct, fork two. Output: process table.

Build: switch routine in inline asm. Output: register-save animation.

brk, sbrk, mmap. Build: a userspace malloc/free on top of sbrk. Output: heap layout over time.

Base + bounds, the pre-paging world. Build: a segmented address space simulator. Output: segment-table walk.

Build: identity-map first 4 MB by hand. Output: address-translation visualizer.

Multi-level. Build: page-table builder. Output: live page-table tree.

Hit/miss cost. Build: a TLB simulator over a memory-access trace. Output: hit-rate vs working-set chart.

Page in, page out. Build: a swap-backed page fault handler. Output: page-fault rate over a working-set trace.

FIFO, LRU, clock, working set. Build: all four. Output: miss-rate-vs-policy chart on the same trace.

Bump, linked-list, slab. Build: a kernel `Box`. Output: fragmentation map.

Build: timer interrupt that prints. Output: tick-frequency timing chart.

Build: a `write` syscall. Output: register-flow diagram across the boundary.

Build: it. Output: Gantt chart of CPU per process.

Build: it. Output: Gantt vs RR on mixed CPU/IO workload.

Tickets, fairness, currency. Build: it. Output: CPU-share-vs-tickets chart.

vruntime, red-black tree. Build: it. Output: vruntime growth per process.

Per-CPU runqueues, work stealing, affinity. Build: a 4-CPU scheduler with stealing. Output: per-CPU utilization + migration count chart.

Build: the harness. Output: Gantts side-by-side + summary table.

The contrast. Build: feed the process table to an LLM. Output: latency-vs-determinism chart + discussion.

Pipes, shared memory, message passing. Build: a pipe between two processes. Output: message-flow diagram.

Build: the ELF loader. Output: loaded address space visualized.

Build: drop privilege, set stack, jump. Output: userspace "hello" running on your kernel.

Build: read, parse, exec. Output: ls/echo running on your OS.

Build: a chrooted shell. Output: truncated FS view.

mount, PID, net, user, IPC, UTS. Build: clone with each flag. Output: six side-by-side terminals showing isolation.

CPU, memory, IO. Build: limit a CPU-burner to one core. Output: CPU-percent chart before/after.

Build: mount lower + upper. Output: three-pane diff viewer.

Build: construct a valid image. Output: layer-tree with sha256 hashes.

Build: runc-shaped, ~800 lines. Output: lifecycle state diagram.

Build: axum + your KV. Output: push/pull sequence diagram.

Bridges, veth, NAT. Build: two containers over a bridge. Output: topology + packet flow.

Build: on your KV, with presigned URLs. Output: browser uploading via your URL.

Partition keys, GSIs. Build: it. Output: request distribution heatmap.

Visibility timeouts, DLQ. Build: on your WAL. Output: message lifecycle with retry + DLQ.

Fanout to multiple queues. Build: on top of SQS-lite. Output: fanout diagram.

Build: a Redis-shaped server speaking RESP. Output: hit-rate + p99 chart.

Software bridges + routing tables. Build: multi-subnet virtual network. Output: topology diagram.

L7 round-robin + health checks. Build: it, on top of axum. Output: per-backend traffic chart.

Edge nodes + signed URLs. Build: a 3-edge CDN. Output: origin-vs-edge latency chart.

Build: on your container runtime. Output: invocation timeline.

Bin-packing placement. Build: it. Output: live placement diagram.

Where the slow oracle finally helps. Build: LLM picks placement, compare to bin-packing. Output: placement-quality chart.

Build: a Prometheus-shaped scraper + a Jaeger-shaped trace collector. Output: live dashboard + flame graph.

Declarative resource trees + signed requests. Build: a YAML applier driving your S3/Dynamo/SQS/Lambda/ECS + sigv4-style signing. Output: dependency graph of a stack being applied + signed-request walkthrough.

A Rust photo-blog: web service in your Lambda, photos in your S3, posts in your DynamoDB, image-resize jobs through your SQS, scheduled by your ECS, in containers on your kernel, on your filesystem, behind your ELB, cached at your CDN edges, observed by your CloudWatch and X-Ray. Build: every glue piece. Output: browser screenshot of the running app.

Build: a tracing-id propagated end-to-end. Output: flame graph from HTTP request through kernel syscall.

The map of adjacent territory. Build: none — a curated reading list. Output: graph of next stops (compilers, distributed databases, formal methods, GPU programming, embedded).