Skip to content

Section 45: Learning Roadmaps — Overview

Purpose and Scope

This section provides structured, opinionated learning paths for eight distinct career tracks in systems engineering. Each roadmap is designed to be actionable: it sequences topics in dependency order, recommends specific books and papers rather than vague categories, specifies concrete lab milestones, and defines measurable progression criteria. The roadmaps are calibrated for practitioners with existing programming experience who want to develop genuine systems depth, not surface familiarity.

The underlying philosophy is that systems knowledge is hierarchical and sequential. Attempting to learn container internals without understanding namespaces, or distributed consensus without understanding clocks and ordering, produces cargo-cult knowledge that fails under novel conditions. Each roadmap therefore enforces prerequisite sequencing rather than allowing arbitrary topic selection.

Prerequisites

This is a meta-section that synthesizes the entire archive. There are no hard prerequisites for reading the overview, but completing the relevant roadmap requires the prerequisites specified within each track.

Learning Objectives

Upon completing this section, the reader will be able to:

  1. Select the appropriate learning roadmap for their current background and career goals
  2. Identify their current position on the roadmap and what prerequisites they are missing
  3. Locate specific book recommendations, paper reading lists, and online resources for each topic
  4. Identify open-source projects appropriate for contribution at each skill level
  5. Assess their own progress using the objective skill metrics defined for each track

Architecture Overview: Eight Career Tracks

TRACK OVERVIEW AND RELATIONSHIPS
===================================

  ┌─────────────────────────────────────────────────────────────┐
  │              FOUNDATIONS (all tracks)                        │
  │   CSAPP (Patterson & Hennessy) + OSTEP + K&R C              │
  └──────────────────────────┬──────────────────────────────────┘
                             |
        ┌────────────────────┼────────────────────────┐
        |                    |                         |
        v                    v                         v
  ┌───────────┐       ┌────────────┐           ┌────────────┐
  │ TRACK 1   │       │  TRACK 2   │           │  TRACK 3   │
  │ Kernel/OS │       │ Distributed│           │ Perf Eng.  │
  │ Developer │       │ Systems    │           │            │
  └───────────┘       └────────────┘           └────────────┘
        |                    |                         |
        v                    v                         v
  ┌───────────┐       ┌────────────┐           ┌────────────┐
  │ TRACK 4   │       │  TRACK 5   │           │  TRACK 6   │
  │ Security  │       │ Systems    │           │ Embedded / │
  │ Research  │       │ Networking │           │ Real-Time  │
  └───────────┘       └────────────┘           └────────────┘
        |                    |
        v                    v
  ┌───────────┐       ┌────────────┐
  │ TRACK 7   │       │  TRACK 8   │
  │ Database  │       │ Platform / │
  │ Internals │       │ Cloud Inf. │
  └───────────┘       └────────────┘

PROGRESSION MODEL (each track)
================================

  Phase 1: Conceptual       Phase 2: Implementation    Phase 3: Research
  ─────────────────         ───────────────────────    ─────────────────
  Read foundational  ──>   Build working toys     ──>  Read primary
  books + papers           (kernel, scheduler,         literature +
                            filesystem)                contribute to
                                                       production OSS

Key Concepts

  • Deliberate practice: skill development requires immediate feedback on specific sub-skills; reading without building does not produce systems intuition
  • Toy-first methodology: building a toy version of a real system (toy kernel, toy filesystem) produces the mental model that makes reading production source code tractable
  • Paper-then-code sequence: for research-derived systems (Raft, Paxos, LSM trees), reading the original paper before the implementation prevents cargo-cult understanding
  • Contribution ladder: OSS contribution path from documentation → tests → bug fixes → feature implementation → design discussion; each step requires deeper understanding
  • Retrospective reading: rereading foundational material after building experience reveals details invisible on first read; plan for at least two passes of core books

Eight Track Roadmaps Summary

Track 1: Kernel / OS Developer

Target role: Linux kernel contributor, OS developer, embedded OS engineer

Phase 1 — Foundation (6-12 months) - Operating Systems: Three Easy Pieces (Arpaci-Dusseau) — free online; definitive OS textbook - Computer Systems: A Programmer's Perspective (Bryant & O'Hallaron, 3rd ed.) — CSAPP; the gap-filling book - The C Programming Language (Kernighan & Ritchie, 2nd ed.) — K&R; required fluency - Build: XV6 (MIT) — read source; run under QEMU; add a system call - Lab: Compile a vanilla Linux kernel; boot under QEMU

Phase 2 — Depth (12-18 months) - Linux Kernel Development (Robert Love, 3rd ed.) — architecture overview; still valid for fundamentals - Understanding the Linux Kernel (Bovet & Cesati, 3rd ed.) — deep dive into memory, scheduling, VFS - Linux Device Drivers (Corbet, Rubini, Kroah-Hartman, 3rd ed.) — free online; write your first module - Professional Linux Kernel Architecture (Wolfgang Mauerer) — comprehensive reference - Build: Write a character device driver; implement a simple kernel module with proc file - Papers: Lottery Scheduling (Waldspurger), CFS paper, RCU paper (McKenney)

Phase 3 — Production (ongoing) - Contribute to Linux kernel: start with Documentation or staging drivers - Read LKML (Linux Kernel Mailing List) archives for current design discussions - Papers: eBPF verifier paper, io_uring design document, NUMA balancing paper

Progression metrics: Can write a kernel module that registers a character device; can read kernel git blame and understand the context of a patch; has sent at least one patch to a kernel subsystem

Track 2: Distributed Systems Engineer

Target role: infrastructure engineer at cloud company, distributed systems developer

Phase 1 — Foundation - Designing Data-Intensive Applications (Kleppmann) — best practical distributed systems book - Distributed Systems (van Steen & Tanenbaum, 3rd ed.) — free online - Computer Networking: A Top-Down Approach (Kurose & Ross) - Lab: Implement a consistent key-value store with a single-node log

Phase 2 — Depth - Papers: Lamport Clocks, Vector Clocks, Paxos Made Simple, In Search of an Understandable Consensus Algorithm (Raft), Dynamo, Spanner, Bigtable, MapReduce, Chubby, Dapper - Designing Distributed Systems (Burns) — patterns for distributed applications - Build: Implement Raft from scratch in any language (rafted, MIT 6.824 labs) - Lab: Build a distributed key-value store using your Raft implementation

Phase 3 — Production - MIT 6.824 (Distributed Systems) — all labs available free - Contribute to etcd, CockroachDB, TiKV, or Cassandra

Progression metrics: Can explain why Paxos and Raft agree on the same values by construction; can implement vector clocks and explain their limitations vs. Lamport clocks; has debugged a real split-brain scenario

Track 3: Performance Engineer

Target role: performance engineering team at cloud/datacenter company; latency-sensitive service optimization

Phase 1 — Foundation - Systems Performance (Brendan Gregg, 2nd ed.) — the definitive performance engineering book - The Art of Writing Efficient Programs (Shompole) — micro-optimization with modern hardware - Computer Organization and Design (Patterson & Hennessy) — hardware performance mental model

Phase 2 — Depth - BPF Performance Tools (Brendan Gregg) — eBPF/BCC/bpftrace for production analysis - Papers: Meltdown, Spectre, DPDK performance analysis papers, memory latency characterization papers - Lab: Profile a real application using perf, flamegraphs, and bpftrace; find and fix a bottleneck

Phase 3 — Production - Contribute to Brendan Gregg's BCC/bpftrace tool collection - Flame graph generation from production traces

Progression metrics: Can generate and interpret CPU, off-CPU, and memory flamegraphs; can identify CPU cache miss, lock contention, and NUMA imbalance as root causes; has quantified a performance improvement with statistical rigor

Track 4: Security Researcher

Phase 1: Hacking: The Art of Exploitation (Erickson) + CSAPP + Shellcoder's Handbook Phase 2: The Linux Programming Interface (Kerrisk) + papers: ret2libc, ROP, heap exploitation techniques, JIT spraying, Spectre Phase 3: CVE analysis on Linux kernel; CTF participation; kernel exploit development on VMs

Track 5: Systems / Network Engineer

Phase 1: TCP/IP Illustrated Volume 1 (Stevens) + UNIX Network Programming (Stevens) Phase 2: Linux Networking Internals (Benvenuti) + XDP/eBPF papers + DPDK documentation Phase 3: Contribute to the Linux networking subsystem or an open-source router/switch

Track 6: Embedded / Real-Time Engineer

Phase 1: Programming Embedded Systems (Barr & Massa) + Making Embedded Systems (White) Phase 2: Real-Time Systems Design and Analysis (Laplante) + FreeRTOS source + Tock OS documentation Phase 3: Contribute to Zephyr RTOS or Tock OS

Track 7: Database / Storage Engineer

Phase 1: Database Internals (Petrov) + Designing Data-Intensive Applications (Kleppmann) Phase 2: Papers: B-Tree original, LFS, Log-Structured Merge Trees, ARIES, Spanner, F1 Phase 3: Contribute to RocksDB, PostgreSQL, or TiKV

Track 8: Platform / Cloud Infrastructure

Phase 1: Site Reliability Engineering (Google SRE book, free online) + Kubernetes documentation internals Phase 2: Kubernetes in Action (Luksa) + Papers: Borg, Omega, Kubernetes design papers Phase 3: Contribute to Kubernetes, containerd, or Cilium

Book Master Reference List

Title Author(s) Track Priority
Operating Systems: Three Easy Pieces Arpaci-Dusseau et al. 1 Essential
Computer Systems: A Programmer's Perspective Bryant & O'Hallaron All Essential
Linux Kernel Development Robert Love 1 Essential
Understanding the Linux Kernel Bovet & Cesati 1 High
Linux Device Drivers Corbet, Rubini, Kroah-Hartman 1 High
Designing Data-Intensive Applications Kleppmann 2,7 Essential
Systems Performance Brendan Gregg 3 Essential
BPF Performance Tools Brendan Gregg 3 High
TCP/IP Illustrated Vol. 1 W. Richard Stevens 5 Essential
Database Internals Alex Petrov 7 Essential
Modern Operating Systems Tanenbaum 1 Reference
The Art of Multiprocessor Programming Herlihy & Shavit 1,3 High
Is Parallel Programming Hard? (perfbook) Paul McKenney 1 High

File Map

45-learning-roadmaps/
├── 00-overview.md                    ← This file
├── 01-track-kernel-os-developer.md
├── 02-track-distributed-systems.md
├── 03-track-performance-engineer.md
├── 04-track-security-researcher.md
├── 05-track-systems-networking.md
├── 06-track-embedded-realtime.md
├── 07-track-database-storage.md
├── 08-track-platform-cloud.md
├── 09-book-recommendations.md
├── 10-paper-reading-lists.md
├── 11-online-resources-and-courses.md
├── 12-lab-setup-guides.md
└── 13-progression-metrics.md

Cross-References

  • Section 46 (Labs): concrete lab exercises for each track
  • Section 47 (Projects): project-based learning extensions
  • Section 48 (Research Papers): full paper reading lists referenced in roadmaps
  • All Sections 00-44: content the roadmaps direct the learner through