The 1% Developer
Deep CS Mastery Roadmap · OS · Compilers · Networking · For Rust Programmers
A 24-month self-directed curriculum for achieving deep mastery of computer systems - from C and x86 assembly through OS internals, compilers, networking, and distributed systems. Designed for Rust programmers who want to go all the way to the bottom of the stack.
Foundations
Before you can go deep, you need the lingua franca of systems. Every major system - Linux, CPython, PostgreSQL, NGINX - is written in C. Understanding C means you can read these codebases, understand kernel interfaces, and reason about memory at the machine level. Your Rust knowledge makes C much easier - the mental models are identical, just without safety guarantees.
Week-by-Week Plan
C Programming
K&R C - The original, still the best. Read every exercise. Key topics: pointers & pointer arithmetic, manual memory management, structs, function pointers, undefined behavior. Project: re-implement your favorite Rust utility (cat, grep, wc) in C from scratch.
x86-64 Assembly
Programming from the Ground Up. Registers, calling conventions (System V ABI), stack frames, addressing modes, system call interface. Exercise: Write a Hello World in pure assembly. Trace a Rust function call in godbolt.
Linux Internals & Tools
The Linux Command Line - Free online. Tools to master: gdb, strace, ltrace, perf, valgrind, nm, objdump, readelf. Understand: ELF binary format, dynamic linking, the linker (ld), Makefiles, CMake basics. Exercise: Use strace to trace what happens when you run 'ls'. Count every syscall.
Resources6
Kernighan & Ritchie
The original, still the best. Read every exercise.
David Malan
Best introduction to C for systems context. Free.
Jonathan Bartlett
Free PDF online. Teaches x86 assembly from zero. Excellent for OS foundations.
Low Level Learning
Excellent C and assembly deep dives. Very practical.
Write Rust/C, see the assembly in real time. Use this DAILY forever.
William Shotts
Free online. Master bash, pipes, process management.
Build Projects
- Re-implement cat, grep, and wc in C from scratch
- Write a Hello World in pure x86-64 assembly
- Trace a Rust function call in Compiler Explorer - explain every instruction
- Use strace to trace 'ls' and count every syscall
You can write a C program with manual memory management, read x86 assembly generated by Rust/C, and trace a program's system calls with strace.
Computer Architecture
This is the bedrock. Everything above - OS scheduling, compiler optimization, network I/O - is built on top of hardware behavior. Most developers treat the CPU as a black box. You won't. After this phase you will understand why a cache miss causes a 200x latency penalty, why memory ordering matters in concurrent code, and what happens at the hardware level when a page fault occurs.
Week-by-Week Plan
CPU Pipeline & Instruction Execution
CS:APP Ch1-3. Study fetch-decode-execute. Hazards, forwarding, branch prediction.
Memory Hierarchy - Caches
CS:APP Ch6. Drepper's paper. Write C/Rust code that demonstrates cache effects. Measure.
Virtual Memory
CS:APP Ch9. Understand TLB, page tables, physical vs virtual addresses. This prereqs OS.
ISA Deep Dive - RISC-V & x86
Patterson & Hennessy. Write RISC-V assembly. Compare with x86. Study calling conventions.
Hardware Concurrency
Memory models, cache coherence (MESI protocol), atomic instructions, memory barriers.
Project: Cache Simulator
Implement a set-associative cache simulator in Rust. Test against real workloads.
Resources7
Patterson & Hennessy
The Bible of computer architecture. Read chapters 1-5, 4.6-4.11.
Bryant & O'Hallaron
CMU's legendary textbook. Best book on linking, memory, assembly, I/O from a programmer's POV.
Andrew Tanenbaum
Great complement. Goes from logic gates to OS. Builds intuition bottom-up.
Ulrich Drepper
Free PDF (LWN.net). The definitive guide to CPU caches. Read this twice.
nand2tetris.org
Build a computer from logic gates to OS. Possibly the best CS course ever made. Free.
CMU
Companion to CS:APP. Lectures by the authors. Free on YouTube. 26 lectures.
MIT OCW
Deep dive into digital systems and processor design.
Build Projects
- Implement a set-associative cache simulator in Rust - test against real memory traces
- Write a program in C that demonstrates cache thrashing vs. cache-friendly access - measure with perf
- Implement a RISC-V instruction decoder in Rust
- Complete CMU 15-213 Cache Lab
You can explain why a cache miss causes a 200x latency penalty, why memory ordering matters in concurrent code, and what happens when a page fault occurs at the hardware level.
Operating Systems
How kernels work. Then build one. The most important Unix insight: everything is a file. The second: everything is a process. Both ideas are beautifully simple and incredibly powerful. Your primary project is building a minimal OS kernel in Rust - follow Philipp Oppermann's tutorial but extend it significantly.
Week-by-Week Plan
Processes & the Process Model
OSTEP Part 1. Fork, exec, wait. Write a shell in C, then in Rust. Study /proc filesystem.
CPU Scheduling
OSTEP scheduling chapters. FIFO, SJF, MLFQ, CFS. Implement MLFQ in Rust as simulation.
Virtual Memory - Paging
OSTEP Part 2. Page tables, TLBs, demand paging. Start MIT 6.S081 Lab 3 (page tables).
Memory Allocation
malloc internals. Implement slab allocator and buddy allocator in Rust. Study jemalloc.
Concurrency - Locks & CVs
OSTEP Part 3. Spinlocks, mutexes, condition variables. Implement from atomics in Rust.
File Systems
OSTEP persistence chapters. Inodes, directories, journaling. Study ext4 source code.
System Calls & Kernel Interface
Linux syscall table. Write kernel modules. MIT 6.S081 labs on traps and system calls.
Capstone: Rust OS
Combine everything. Extend blog_os with scheduler, syscalls, basic filesystem.
Resources10
Arpaci-Dusseau & Arpaci-Dusseau
Free online. The best modern OS textbook. Do every homework and project - the projects are the real education.
Andrew Tanenbaum
4th edition. Broader coverage than OSTEP. Great for network file systems.
Robert Love
3rd edition. Practical guide to how the Linux kernel is actually structured.
Bovet & Cesati
Deep technical reference. Not for beginners but invaluable when you're ready.
Maurice Bach
1986 but timeless. How original Unix was implemented. Historical foundation.
MIT PDOS
The BEST OS course. Implements xv6 (Unix-like). 21 labs: syscalls, page tables, traps, COW, multithreading, networking, file system, mmap, locks.
Ion Stoica
Full semester. Excellent lectures by Ion Stoica. Covers all OS fundamentals.
Philipp Oppermann
Write an OS in Rust from scratch. The gold standard for Rust OS development.
Community reference for OS development. Hardware details, BIOS/UEFI, bootloaders.
Gynvael Coldwind
Low-level programming, OS concepts, security. Polish hacker with excellent content.
Build Projects
- Start with phil-opp.com blog OS - VGA text mode, interrupts, memory paging
- Add a proper physical memory allocator (buddy allocator or bitmap allocator)
- Add a basic virtual memory system with page table management
- Add a simple round-robin process scheduler
- Add system call interface (int 0x80 or syscall instruction)
- Stretch goal: Add a simple FAT32 file system driver
- Complete all MIT 6.S081 xv6 labs
Key Papers5
Ritchie & Thompson (1974)
The original Unix paper. Short, brilliant.
Waldspurger & Weihl
Creative scheduling approach - proportional share resource management.
Rosenblum & Ousterhout
LFS paper - foundational file system design.
Engler et al.
Alternative OS design philosophy - library OSes.
Lipp et al. / Kocher et al. (2018)
Modern relevance of hardware-OS interaction.
You have a bootable OS kernel in Rust with a working page allocator, basic scheduler, and system call interface. You can explain how fork() creates a new process at the kernel level.
Compilers
From source text to machine instructions - understand every step. Understanding compilers makes you a better programmer in every language. You'll understand why Rust's borrow checker works, how LLVM optimizes your loops, why certain code patterns are faster than others, and how garbage collectors work. The compiler is the layer between your intent and the machine.
Week-by-Week Plan
Lexical Analysis
Crafting Interpreters Part 1. Write a lexer/scanner in Rust. Understand DFAs and NFAs.
Parsing & Grammars
Context-free grammars, LL(1), recursive descent. Parse a full expression language in Rust.
ASTs & Tree Walking
Build AST nodes, visitor pattern, tree-walk interpreter. Implement closures properly.
Semantic Analysis & Types
Symbol tables, scoping, type checking. Implement Hindley-Milner type inference basics.
Bytecode & Virtual Machines
Crafting Interpreters Part 2. Design instruction set, write a stack VM in Rust.
Intermediate Representations
Three-address code, SSA form, control flow graphs. Study LLVM IR.
Optimization Passes
Constant folding, dead code elimination, inlining, loop invariant code motion.
Code Generation
Register allocation (linear scan), instruction selection, calling conventions. LLVM backend.
Resources12
Robert Nystrom
Free online. Best book to start. Build two complete interpreters.
Cooper & Torczon
2nd or 3rd edition. Best academic compiler textbook. Covers SSA, register allocation.
Appel
Tiger book. Great for register allocation, dataflow analysis. Any language version works.
Aho, Lam, Sethi, Ullman
The Dragon Book. Classic. Dense but comprehensive. Best for formal grammars, regex.
Benjamin Pierce
TAPL. The definitive book on type systems. Lambda calculus, type inference.
Michael Scott
Great survey of PL design decisions. Why languages are designed the way they are.
Alex Aiken
Full Stanford compiler course. Implements Cool language. Free.
Cornell
Lecture notes and slides free. Implements Xi language.
Official LLVM Kaleidoscope tutorial. Build a JIT compiler in C++. Then use inkwell in Rust.
Thorsten Ball
Writing An Interpreter/Compiler In Go. Clean and practical. Great companion to Crafting Interpreters.
Tsoding
Builds interpreters and compilers live. Learn from watching an expert think.
Jon Gjengset
Deep Rust internals. His videos on the borrow checker are essential.
Build Projects
- Build a complete Lox interpreter following Crafting Interpreters (tree-walking, then bytecode VM) - implement in Rust
- Build your own programming language that compiles to x86-64 or WebAssembly: lexer, recursive descent parser, typed AST, Hindley-Milner type inference, SSA IR with 3+ optimization passes, x86-64 or WASM backend, REPL
- Implement a minimal Hindley-Milner type inference engine for a small ML-like language
- Write LLVM passes using inkwell (Rust LLVM bindings) - implement at least one optimization pass
Key Papers4
Cooper, Harvey, Kennedy
Essential for SSA form construction.
Damas & Milner (1982)
The foundational type inference paper.
Poletto & Sarkar
Practical register allocation algorithm used in production compilers.
Lattner & Adve
The LLVM architecture paper.
You have built a working compiler/interpreter in Rust that handles closures, basic types, and generates real machine code or bytecode. You can explain what SSA form is and why it simplifies optimization.
Networking
From ethernet frames to HTTP/3 - understand every layer. Most developers use networking as a black box. After this phase you will understand TCP's flow control from the sequence number level, implement a DNS resolver from raw UDP packets, and know exactly what happens when your browser makes an HTTPS request.
Week-by-Week Plan
The Protocol Stack
OSI model vs TCP/IP model. Ethernet, IP, UDP, TCP. Read Kurose&Ross Ch1-3. Use Wireshark.
TCP Deep Dive
3-way handshake, flow control, congestion control (Reno, CUBIC, BBR). Read Stevens Vol.1.
Sockets Programming
TCP/UDP servers in Rust. Non-blocking sockets. epoll/kqueue. Read Beej's guide fully.
DNS
How DNS works end-to-end. Implement a DNS resolver in Rust from scratch.
HTTP/1.1, HTTP/2, HTTP/3
HTTP semantics, pipelining, multiplexing, header compression, QUIC. Build HTTP/1.1 server.
TLS / Security
TLS handshake, certificates, PKI, cipher suites. Study rustls source code.
Async I/O & io_uring
epoll event loop, io_uring, how tokio works internally. Study tokio source code.
Project: TCP Stack in Rust
Stanford CS144 labs in Rust. Full TCP implementation: SYN, ACK, retransmit, flow control.
Resources10
Kurose & Ross
8th edition. THE standard networking textbook. Goes from application layer to physical.
W. Richard Stevens
Deep technical reference for TCP/IP. Stevens was a genius. This book has no peer.
W. Richard Stevens
The definitive guide to sockets programming. Everything about socket APIs.
Ilya Grigorik
Free online. HTTP, TLS, QUIC, WebSocket, WebRTC deep dives.
Brian Hall
Free. The most practical sockets tutorial on the internet.
Stanford
You implement a TCP stack in C++. Do it in Rust instead. Essential.
Jon Gjengset
4-hour live coding session. Implements RFC 793 TCP from scratch. Must watch.
Hussein Nasser
Deep networking topics: HTTP, TCP, proxies, databases. Very practical.
MIT
Graduate level. Covers routing, congestion control, SDN.
Packet capture and analysis. Use on every week of the networking phase.
Build Projects
- DNS resolver: Parse DNS packets, send UDP queries, handle responses, implement caching
- HTTP/1.1 server: From raw TCP sockets, parse requests, route handlers, chunked encoding
- TCP stack (userspace): Jon Gjengset's approach - tun/tap device, implement RFC 793
- Simple proxy: HTTP CONNECT proxy - understand how VPNs and load balancers work
Key Papers5
The original TCP spec. Read it after implementing TCP.
The DNS RFCs. Read alongside your DNS resolver project.
Then RFC 7230-7235 which updated it.
HTTP/3 foundation. Understand what problems QUIC solves.
The TLS 1.3 spec. Study the handshake sequence.
You have a working TCP implementation in Rust (even partial), a DNS resolver, and an HTTP server. You can explain the TCP 3-way handshake, slow start, and TLS 1.3 handshake from memory.
Advanced Intersections
Where OS, compilers, and networking converge. This phase covers LLVM compiler backends, eBPF for kernel programmability, async runtime internals (tokio), distributed systems, and database internals. Each topic sits at the intersection of multiple previous phases.
Week-by-Week Plan
LLVM & Compiler Backends
Getting Started with LLVM Core Libraries. Use inkwell (Rust bindings). Build your language from Phase 2B on top of LLVM. Write LLVM passes: mem2reg, SROA, GVN, LICM.
eBPF - The Kernel Superpower
Learning eBPF (Liz Rice). Write eBPF programs in Rust with aya. Write a TCP connection tracer, a network packet filter, a CPU profiler - all in Rust with aya. eBPF sits at the intersection of OS and networking.
Async Runtimes & io_uring
How Tokio Works - tokio.rs/tokio/tutorial. Understand futures, wakers, poll(), executors, task scheduling, thread pools. Read Carl Lerche's blog posts on building async runtimes from scratch. Implement a minimal async executor in Rust (~200 lines). Study io_uring and the Linux kernel.
Distributed Systems
Designing Data-Intensive Applications (DDIA) - Kleppmann. MIT 6.824 Distributed Systems course. Key papers: Raft, Paxos, Spanner, Dynamo, MapReduce, GFS, Chubby - all free on Google Scholar. Project: implement the Raft consensus algorithm in Rust.
Database Internals
Database Internals (Alex Petrov). B-trees, LSM trees, WAL, MVCC, distributed transactions. CMU 15-445 Database Systems (Andy Pavlo - YouTube). Project: implement a simple B-tree storage engine in Rust with WAL for crash recovery.
Resources8
Lopes & Aule
Practical guide to using LLVM for JITs, passes, and custom backends.
Liz Rice
O'Reilly. The best practical eBPF book. Understand kernel hooks, maps, programs.
Write eBPF programs in Rust! Incredible for OS + networking work. Official book free.
Official tokio tutorial. Then READ THE SOURCE CODE - github.com/tokio-rs/tokio.
Martin Kleppmann
The best modern distributed systems book. Replication, consensus, streaming.
Robert Morris et al.
Labs implement Raft consensus, MapReduce, distributed KV. Essential.
Alex Petrov
B-trees, LSM trees, WAL, MVCC, distributed transactions. The internal view.
Andy Pavlo
Carnegie Mellon's database course. Andy Pavlo is an exceptional teacher.
Build Projects
- Extend your Phase 2B compiler to use LLVM as backend via inkwell
- Write an eBPF TCP connection tracer in Rust with aya
- Implement a minimal async executor in Rust from scratch (~200 lines) - futures, wakers, poll()
- Implement the Raft consensus algorithm in Rust (complete with leader election and log replication)
- Build a simple B-tree storage engine in Rust with WAL for crash recovery
Key Papers5
Ongaro & Ousterhout
Read the full dissertation, not just the conference paper.
DeCandia et al.
The paper that defined eventual consistency engineering.
Corbett et al.
TrueTime and external consistency at global scale.
Dean & Ghemawat
The paper that started the big data era.
Ghemawat et al.
GFS - distributed storage at Google scale.
You have implemented Raft, a working async executor, and an eBPF program. You understand LLVM IR and can write optimization passes. You can explain distributed consensus and why two-phase commit is not consensus.
Capstone Projects
Build things that prove you are the 1%. The capstone phase is about public credibility - building large projects, contributing to open source, reading papers, and teaching others. After this phase, your GitHub profile and writing will speak for themselves.
Week-by-Week Plan
Toy Operating System
A bootable x86-64 OS in Rust: bootloader, interrupt handling, physical & virtual memory manager, process scheduler (preemptive), basic system calls, simple shell, ext2-like filesystem. ~15,000 lines.
Systems Programming Language
A compiled language targeting x86-64 (via LLVM/Cranelift): recursive descent parser, LLVM IR codegen, basic optimizer, standard library. Must self-host basic programs. ~10,000 lines.
TCP/IP Stack
Userspace network stack in Rust: Ethernet framing, ARP, IPv4/IPv6, ICMP, UDP, TCP (3-way handshake, retransmit, congestion control). Works with Linux tun/tap. ~5,000 lines.
Async Runtime
A tokio-style async executor in Rust: future trait, waker mechanism, epoll/io_uring event loop, timer wheel, task scheduler. ~3,000 lines.
Open Source Contributions
Pick one: Linux kernel (driver or subsystem), rustc (compiler), LLVM (pass or backend), tokio/hyper (async runtime), PostgreSQL. Get at least one substantial PR merged.
Resources4
John Ousterhout
Read before scoping any capstone project. Shapes how to design for depth, not complexity.
Andreas Kling's OS. Watch his YouTube coding streams. Real-world OS dev.
Unix-like OS written entirely in Rust. See how real Rust OS code looks.
6000 lines of C. Read every file. The most educational OS codebase for OS work.
Build Projects
- Choose at least ONE major project: Toy OS (~15k lines), Systems Language (~10k lines), TCP/IP Stack (~5k lines), or Async Runtime (~3k lines)
- Contribute at least one substantial PR to: Linux kernel, rustc, LLVM, tokio/hyper, or PostgreSQL
- Write detailed blog posts about every project - 'How I Built a TCP Stack in Rust' will be read by thousands
- Read and summarize 5 systems papers - publish the summaries
- Give at least one talk: RustConf, Linux Foundation events, local meetup
Key Papers3
Ken Thompson (1984)
Turing Award lecture. Read at the end of the journey.
Moseley & Marks
Essential essay on complexity. Shapes capstone design.
Fred Brooks (1986)
Why complexity cannot be engineered away.
You have shipped at least one major systems project (>5,000 lines), written publicly about it, contributed to an open source project, and can speak for 30 minutes about design tradeoffs. Your GitHub profile demonstrates sustained, serious work.