Tags

Every page in this site is tagged. Use this index to find every chapter that touches a concept - across every path.

Filter by a path slug (go, java, rust, python, linux, containers, kubernetes, ai-systems) to see one path's tag landscape, or by a domain tag (gc, concurrency, jit, observability, ffi, ...) to see every path that covers it.

abi

• FFI - calling C from everything

ai

• Deep Dives-Self-Contained Reference Chapters
• tutoriaal-companion learning material for AI_EXPERT_ROADMAP.md

ai-expert-roadmap-from-scratch

• 00 - Where are you starting from
• 01 - The 12-month arc, honest version
• 02 - Math you actually need (and what you don't)
• 03 - The Python + Linux baseline
• 04 - ML mental model in one page
• 05 - Transformers in one page
• 06 - The Hugging Face ecosystem map
• 07 - Picking a specialization
• 08 - Reading papers without drowning
• 09 - Building in public
• 10 - Your portfolio: 3 projects
• 11 - Evaluating job postings honestly
• 12 - Open source as resume
• 13 - Interview prep: what they actually ask
• 14 - First 90 days on the job
• 15 - Done - the next 12 months
• AI Expert Roadmap From Scratch (Beginner)

ai-roadmap

• 00-How to use this folder
• 01-Linear Algebra
• 02-Calculus
• 03-Probability & Statistics
• 04-Python for ML
• 05-PyTorch
• 06-Classical ML
• 07-Deep Learning
• 08-Transformers
• 09-LLM Application Engineering
• 10-Retrieval & RAG
• 11-Agents
• 12-Evaluation Systems
• 13-LLM Observability
• 14-Inference & Serving
• 15-Fine-tuning
• 16-Distributed Training
• Cross-References-`tutoriaal` and Sibling Curricula
• Curriculum Audit-`tutoriaal`
• Deep Dive 01-Math for Machine Learning (Self-Contained Reference)
• Deep Dive 03-Classical ML Rigor
• Deep Dive 05-LLM Application Patterns
• Deep Dive 06-Retrieval and Retrieval-Augmented Generation
• Deep Dive 07-Agent Reliability Engineering
• Deep Dive 08-Evaluation Systems for LLMs
• Deep Dive 09-LLM Observability
• Deep Dive 10-Fine-Tuning: From SFT to RLHF
• Deep Dive 11-Multimodal Foundations
• Deep Dive 12-AI Safety, Prompt Injection, Jailbreaks, and Red-Teaming
• Deep Dive 13-The AI-for-SRE Bridge: Your Unique Lane
• Deep Dive 14-Future-Proofing the Curriculum: A Durability Audit
• Deep Dives-Self-Contained Reference Chapters
• Deep Learning Fundamentals
• Month 1-Week 1: Vectors, dot products, and your first ML model from scratch
• Month 1-Week 2: Calculus, the chain rule, and logistic regression
• Month 1-Week 3: Probability foundations + MLP forward/backward by hand
• Month 1-Week 4: PyTorch, autograd, and your first blog post
• Month 10-Week 1: Capstone build kickoff
• Month 10-Week 2: Capstone build sprint 1
• Month 10-Week 3: Capstone build sprint 2 + first user
• Month 10-Week 4: Capstone v0.1 ship + month-10 retro
• Month 11-Week 1: The capstone long-form post
• Month 11-Week 2: Publish + give a talk
• Month 11-Week 3: Network outreach + profile alignment
• Month 11-Week 4: Capstone v0.2 hardening + month retro + outreach follow-ups
• Month 12-Week 1: Job-market reconnaissance OR sustained-build mode
• Month 12-Week 2: Interview prep-coding, ML system design, breadth, behavioral
• Month 12-Week 3: Year-2 plan + capstone v0.3 + year-in-review draft
• Month 12-Week 4: Year-in-review + final retrospective + the honest question
• Month 2-Week 1: Classical ML-picking a course and shipping a real classifier
• Month 2-Week 2: Experiment tracking, ablations, and seed variance
• Month 2-Week 3: Tabular ML, gradient boosting, and feature engineering
• Month 2-Week 4: Course wrap, ablation post, transformer preview
• Month 3-Week 1: Karpathy makemore-bigrams to MLP, with diagnostic discipline
• Month 3-Week 2: Self-attention, multi-head attention, GPT from scratch
• Month 3-Week 3: nanoGPT, BPE, sampling strategies
• Month 3-Week 4: Q1 capstone-modify a transformer, ship a retrospective
• Month 4-Week 1: LLM application toolkit + first non-trivial app
• Month 4-Week 2: Tool use, streaming, prompt caching
• Month 4-Week 3: Evals-golden set, heuristics, judge, and validation
• Month 4-Week 4: Polish, DSPy experiment, fourth blog post, OSS PR
• Month 5-Week 1: Retrieval framing + BM25 baseline + retrieval metrics
• Month 5-Week 2: Dense retrieval, embeddings, vector databases
• Month 5-Week 3: Hybrid retrieval, reranking, contextual retrieval
• Month 5-Week 4: End-to-end RAG eval, RAGAS, publish
• Month 6-Week 1: Agent foundations-tool-use loop and ReAct
• Month 6-Week 2: Reflection, state management, observability
• Month 6-Week 3: Inspect AI, regression detection, online eval prep
• Month 6-Week 4: Q2 capstone-observability bridge post + Q3 track decision
• Month 7-Week 1: Specialty kickoff-foundational paper + design doc + first commit
• Month 7-Week 2: Frontier paper + substantive build
• Month 7-Week 3: Head-to-head vs incumbent + supporting paper
• Month 7-Week 4: Track milestone + first specialty post
• Month 8-Week 1: vLLM, KV cache, quantization (universal)
• Month 8-Week 2: LoRA + QLoRA-first fine-tune
• Month 8-Week 3: DPO and preference data
• Month 8-Week 4: Self-host economics blog post + GRPO preview
• Month 9-Week 1: DDP, FSDP, multi-GPU run
• Month 9-Week 2: Track final push (part 1) + first OSS PR
• Month 9-Week 3: Track final push (part 2) + writeup draft
• Month 9-Week 4: Q3-closing post + Q4 capstone planning + profile update
• PyTorch Fluency: The User-Level Reference
• tutoriaal-companion learning material for AI_EXPERT_ROADMAP.md

ai-runtime

• Appendix C - Deep-Dive Session: CPython Internals and the AI Runtime Stack

ai-systems

• AI Systems Engineering-A 24-Week Beginner-to-Advanced Mastery Roadmap
• Appendix A-Hardening, Observability, and Fleet Operations
• Appendix B-Build-From-Scratch Reference
• Appendix C-Contributing to the AI Systems Ecosystem
• Capstone Projects - Three Tracks
• Capstone Projects-Three Tracks, One Choice
• Deep Dive 01-NVIDIA GPU Architecture and Memory Hierarchy
• Deep Dive 02: CUDA Programming-From First Kernel to Optimized GEMM
• Deep Dive 05-JAX and XLA
• Deep Dive 07: Attention, the Transformer, and FlashAttention
• Deep Dive 08-LLM Inference Serving Systems
• Deep Dive 09: Quantization Theory and Practice for LLMs
• Deep Dive 10-Speculative Decoding and Prefill/Decode Disaggregation
• Deep Dive 11-Numerics and Mixed Precision
• Deep Dive 12 - Kernel Fusion: Theory, Practice, and the Compilers That Do It For You
• Deep Dives-Self-Contained Reference Chapters
• Distributed Training: Mathematics and Engineering
• Month 1-Foundations: Compute Hierarchy, Tensors, Autograd, Training Loops
• Month 2-GPU Programming: Architecture, CUDA, Memory, Triton
• Month 3-Framework Internals: PyTorch, torch.compile, JAX/XLA, Custom Ops
• Month 4-Distributed Training: NCCL, DDP, FSDP, Tensor & Pipeline Parallelism, FP8
• Month 5-Inference Systems: KV-Cache, Paged Attention, Continuous Batching, Quantization, Speculative Decoding
• Month 6 - AI Systems at a Senior Level: RAG, Agents, Evals, Training, Serving
• Month 6-ML Infrastructure, Safety & Eval Infra, Capstone Defense
• Prelude-The Shape of the Discipline
• PyTorch Internals: A Deep Dive Reference
• Triton: A Deep Dive into the Block-Level GPU DSL
• Week 1 - The Compute Hierarchy and the Cost Model
• Week 10 - torch.compile, TorchDynamo, Inductor
• Week 11 - JAX, XLA, HLO
• Week 12 - Custom Operators: From CUDA Kernel to `torch.ops`
• Week 13 - Communication Primitives: NCCL, Allreduce, Topology
• Week 14 - Data Parallelism: DDP, ZeRO, FSDP
• Week 15 - Tensor Parallelism and Pipeline Parallelism
• Week 16 - Mixed Precision, FP8, Numerical Stability at Scale
• Week 17 - LLM Inference, the KV-Cache, Attention Math
• Week 18 - Paged Attention, Continuous Batching, vLLM
• Week 19 - Quantization: INT8, INT4, FP8, AWQ, GPTQ, SmoothQuant
• Week 2 - Linear Algebra Refresh, BLAS, NumPy
• Week 20 - Speculative Decoding, Disaggregation, Inference Frontiers
• Week 21 - LLM-App Foundations: Prompts, Tokens, Streaming, Cost
• Week 21 - ML on Kubernetes: KServe, KubeRay, Volcano, GPU Operators
• Week 22 - Observability, Cost, Eval Pipelines, MLOps
• Week 22 - Retrieval-Augmented Generation: Doing It Properly
• Week 23 - Agents, Tools, Durable Execution, Cost & Safety
• Week 23 - Safety, Red-Teaming, Alignment Infrastructure
• Week 24 - Capstone Integration & Defense
• Week 24 - Training, Serving, Rollout, and the Capstone Defense
• Week 3 - Tensors, Autograd, the Gradient Tape
• Week 4 - The Honest Training Loop
• Week 5 - GPU Hardware Architecture
• Week 6 - Your First CUDA Kernels
• Week 7 - Memory Optimization: Coalescing, Shared Memory, Tensor Cores
• Week 8 - Triton: GPU Kernels From Python
• Week 9 - PyTorch Internals: Tensor, Dispatcher, ATen

ai-systems-from-scratch

• 00 - Introduction
• 01 - Setup
• 02 - Tensors
• 03 - Linear Algebra You Actually Need
• 04 - Your First Neural Network
• 05 - Training Loop
• 06 - Inference and Saving
• 07 - Transformers and Tokenization
• 08 - Hugging Face Transformers
• 09 - Fine-Tuning
• 10 - Retrieval-Augmented Generation (RAG)
• 11 - Evaluation
• 12 - Serving Models
• 13 - Picking a Project
• 14 - Anatomy of an AI OSS Project
• 15 - Your First Contribution
• AI Systems From Scratch - Beginner to OSS Contributor

allocator

• Month 2-Memory, the Garbage Collector, and Interface Internals
• Week 5 - Memory Layout, Padding, Alignment
• Week 6 - The Garbage Collector
• Week 7 - Interface Values, itabs, and Dispatch Cost
• Week 8 - Allocation Profiling, `sync.Pool`, GC Tuning

apiserver

• Month 1-The Control Plane: etcd, kube-apiserver, scheduler, controllers
• Week 1 - etcd and the Raft Consensus Foundation
• Week 2 - The kube-apiserver
• Week 3 - The Scheduler
• Week 4 - Built-in Controllers and `client-go` Foundations

apparmor

• Month 5-Security and Hardening
• Week 17 - Discretionary and Mandatory Access Control
• Week 18 - Capabilities, Seccomp, no_new_privs
• Week 19 - Encryption at Rest: LUKS, dm-crypt, dm-verity
• Week 20 - Audit, Integrity Measurement, and Compliance

architecture

• Month 5 - Patterns and Architecture: Pythonic Design, Testing, Observability, Service Shape
• Month 5-Production Architecture: Hexagonal, Zero-Copy I/O, Observability, Testing
• Week 17 - Hexagonal Architecture and Domain Modeling in Rust
• Week 17 - Pythonic Design Patterns
• Week 18 - Data Structures Beyond `list`/`dict`
• Week 18 - Zero-Copy I/O and the Poll-Based Model
• Week 19 - Observability: tracing, metrics, OpenTelemetry
• Week 19 - Testing, Property-Based Testing, Mutation Testing, Fakes vs. Mocks
• Week 20 - Observability, FastAPI, Production Service Shape
• Week 20 - Testing Strategy: Unit, Property, Fuzz, Miri, Integration

arena

• Appendix B-Build-From-Scratch Data Structures Reference

async

• Async models
• Concurrency
• Month 3-Concurrency and Async: Atomics, Lock-Free, Pin, Tokio, Smol
• Week 10 - Channels, Lock-Free Patterns, and `loom`
• Week 11 - Async Foundations: `Future`, `Pin`, `Unpin`, the State Machine
• Week 12 - Runtimes: Tokio Internals, Smol, Embassy
• Week 9 - Threading, Send, Sync, and the Memory Model

async-profiler

• Appendix A - Production Hardening

asyncio

• Async models
• Month 4 - Concurrency and Parallelism: asyncio, Threads, Processes, Free-Threaded, Subinterpreters
• Week 13 - `asyncio` Foundations: Event Loop, Tasks, Coroutines
• Week 14 - Structured Concurrency, Cancellation, ExceptionGroups, `anyio`
• Week 15 - Threads, Processes, Subinterpreters, `concurrent.futures`
• Week 16 - Native Extensions, Releasing the GIL, FFI

atomics

• Memory models

audit

• Curriculum Audit-`tutoriaal`

autograd

• Month 3-Framework Internals: PyTorch, torch.compile, JAX/XLA, Custom Ops
• Week 10 - torch.compile, TorchDynamo, Inductor
• Week 11 - JAX, XLA, HLO
• Week 12 - Custom Operators: From CUDA Kernel to `torch.ops`
• Week 9 - PyTorch Internals: Tensor, Dispatcher, ATen

beginner

• Beginner glossary

bench

• Testing

bindgen

• Month 4-Unsafe Rust, FFI, and Macros
• Week 13 - Unsafe Rust: Raw Pointers, NonNull, MaybeUninit, UB
• Week 14 - FFI: Calling C, Being Called By C
• Week 15 - Declarative Macros (`macro_rules!`)
• Week 16 - Procedural Macros

bloom-filter

• Appendix B-Build-From-Scratch Data Structures and Patterns

borrowing

• Month 1-Foundations: Toolchain, Memory Layout, Ownership, Errors
• Week 1 - The Toolchain and the Compiler Pipeline
• Week 2 - Memory Layout: Stack, Heap, Data, BSS, TLS
• Week 3 - Ownership, Borrowing, and Region Inference
• Week 4 - The Error Model

bpftrace

• Appendix A-Hardening and Performance Tuning Reference

buddy

• Month 2-Memory Management and Scheduling
• Week 5 - Virtual Memory, Paging, and the Page Cache
• Week 6 - Swapping, OOM, Memory Pressure (PSI)
• Week 7 - The CPU Scheduler (CFS, EEVDF)
• Week 8 - Disk I/O Scheduling, Filesystems Beyond ext4

build

• Appendix B-Build-From-Scratch Reference
• Build systems & toolchains
• Month 1-Kernel Foundations: Boot, Syscalls, VFS, Processes
• Month 2-Filesystems and Image Builds
• Week 1 - Boot, Init, Systemd
• Week 2 - Syscalls and the Kernel/Userspace Boundary
• Week 3 - The Virtual File System (VFS)
• Week 4 - Processes, Threads, and Signals
• Week 5 - OverlayFS and Storage Drivers
• Week 6 - `buildah`: Building Images Without Dockerfiles
• Week 7 - Multi-Stage Builds, Distroless, Minimal Images
• Week 8 - Layer Caching, Build Context, Reproducibility

build-tools

• Month 1 - Language & Toolchain (Weeks 1–4)
• Month 1-Foundations: Toolchain, Memory Layout, Ownership, Errors
• Week 1 - Modern Syntax and the Type System
• Week 1 - The Toolchain and the Compiler Pipeline
• Week 2 - Build Tools, Dependencies, and JPMS
• Week 2 - Memory Layout: Stack, Heap, Data, BSS, TLS
• Week 3 - Collections, Streams, and `java.time`
• Week 3 - Ownership, Borrowing, and Region Inference
• Week 4 - Testing, Logging, and the Definition-of-Done
• Week 4 - The Error Model

buildkit

• Month 2-Filesystems and Image Builds
• Week 5 - OverlayFS and Storage Drivers
• Week 6 - `buildah`: Building Images Without Dockerfiles
• Week 7 - Multi-Stage Builds, Distroless, Minimal Images
• Week 8 - Layer Caching, Build Context, Reproducibility

bytecode

• Month 2 - JVM & Bytecode (Weeks 5–8)
• Week 5 - Class Loading and Bytecode
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 8 - JMH and Microbenchmarking

c

• FFI - calling C from everything

c1

• Month 2 - JVM & Bytecode (Weeks 5–8)
• Week 5 - Class Loading and Bytecode
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 8 - JMH and Microbenchmarking

c2

• Month 2 - JVM & Bytecode (Weeks 5–8)
• Week 5 - Class Loading and Bytecode
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 8 - JMH and Microbenchmarking

calendar

• Appendix B - The Legacy Java Field Guide

capabilities

• Month 4-Container Security
• Week 13 - The Default Threat Model
• Week 14 - Capabilities for Containers
• Week 15 - Seccomp Profiles for Containers
• Week 16 - LSM for Containers: SELinux and AppArmor

capstone

• Capstone Projects
• Capstone Projects - Three Tracks
• Capstone Projects-Three Tracks, One Choice
• Capstone Projects-Three Tracks, One Choice
• Capstone Projects-Three Tracks, One Choice
• Capstone Projects-Three Tracks, One Choice
• Capstone Projects-Three Tracks, One Choice
• Capstone Projects-Three Tracks, One Choice
• Month 6 - AI Systems at a Senior Level: RAG, Agents, Evals, Training, Serving
• Month 6 - Capstone (Weeks 21–24)
• Month 6-Build Your Own: Mini-Docker From Scratch
• Month 6-Kernel Modules, Performance Mastery, Capstone
• Month 6-Kubernetes The Hard Way + Capstone
• Month 6-ML Infrastructure, Safety & Eval Infra, Capstone Defense
• Month 6-Mastery: Consensus, Distributed Storage, Performance Tuning, Defense
• Month 6-Mastery: Custom Data Structures, `no_std`, Compiler Internals, Capstone
• Week 21 - Bootstrap: VMs, Certificates, etcd
• Week 21 - Consensus Algorithms: Raft (and a Glance at Paxos)
• Week 21 - Design and Foundation
• Week 21 - Implementing Complex Data Structures From Scratch
• Week 21 - LLM-App Foundations: Prompts, Tokens, Streaming, Cost
• Week 21 - Loadable Kernel Modules (LKM)
• Week 21 - ML on Kubernetes: KServe, KubeRay, Volcano, GPU Operators
• Week 21 - Scaffolding: Project Setup, OCI Bundle Reading
• Week 22 - Control Plane and Worker Nodes
• Week 22 - Core Implementation
• Week 22 - Distributed Storage Patterns
• Week 22 - Namespaces and Process Isolation
• Week 22 - Observability, Cost, Eval Pipelines, MLOps
• Week 22 - Retrieval-Augmented Generation: Doing It Properly
• Week 22 - Tracing and Performance Mastery: ftrace, perf, BPF
• Week 22 - `no_std`, Custom Allocators, Embedded Targets
• Week 23 - Agents, Tools, Durable Execution, Cost & Safety
• Week 23 - Cgroups v2, Capabilities, Seccomp, OverlayFS
• Week 23 - Compiler Internals: MIR, Borrow Check, Codegen
• Week 23 - Failure, Observability, and Operations
• Week 23 - Performance Tuning at Scale
• Week 23 - Performance Tuning: Profile, Tune, Re-Profile
• Week 23 - RBAC, Multi-Tenancy, mTLS Everywhere
• Week 23 - Safety, Red-Teaming, Alignment Infrastructure
• Week 24 - Capstone Integration & Defense
• Week 24 - Capstone Integration & Defense
• Week 24 - Capstone Integration, Defense, Final Hardening
• Week 24 - Capstone Integration, Profiling, Hardening, Defense
• Week 24 - Defense
• Week 24 - Defense, Documentation, and the Capstone Demo
• Week 24 - Polish, Defense, Distribution
• Week 24 - Training, Serving, Rollout, and the Capstone Defense

cargo

• Build systems & toolchains
• Month 1-Foundations: Toolchain, Memory Layout, Ownership, Errors
• Week 1 - The Toolchain and the Compiler Pipeline
• Week 2 - Memory Layout: Stack, Heap, Data, BSS, TLS
• Week 3 - Ownership, Borrowing, and Region Inference
• Week 4 - The Error Model

cffi

• Month 3 - Runtime and Performance: CPython Internals, GIL, GC, the Allocator
• Week 10 - Memory: Refcounts, Cyclic GC, the `pymalloc` Allocator
• Week 11 - The GIL, Free-Threaded Python, and the Concurrency Model
• Week 12 - The Optimization Ladder: Algorithm → Vectorize → Native → JIT
• Week 9 - The CPython VM: Objects, Bytecode, the Eval Loop

cfs

• Month 2-Memory Management and Scheduling
• Week 5 - Virtual Memory, Paging, and the Page Cache
• Week 6 - Swapping, OOM, Memory Pressure (PSI)
• Week 7 - The CPU Scheduler (CFS, EEVDF)
• Week 8 - Disk I/O Scheduling, Filesystems Beyond ext4

cgo

• FFI - calling C from everything
• Month 4-Reflection, Code Generation, Plugins
• Week 13 - Reflection: `reflect`, Performance, and Discipline
• Week 14 - `go/ast`, `go/parser`, `go/types`: Static Analysis
• Week 15 - `go generate` and AST-Based Code Generation
• Week 16 - Plugins: `plugin`, `go-plugin`, gRPC-Based Extensions

cgroups

• Month 3-Namespaces, cgroups v2, eBPF
• Week 10 - Control Groups v2
• Week 11 - eBPF: Foundations
• Week 12 - eBPF in Production: Observability Tools
• Week 9 - Namespaces

channel

• Appendix B-Build-From-Scratch Data Structures Reference
• Month 3-Concurrency Mastery: Channels, Atomics, Context, Patterns
• Week 10 - `sync` Primitives and `sync/atomic`
• Week 11 - `context.Context`, Cancellation, errgroup, singleflight
• Week 12 - Worker Pools, Leak Detection, Deadlock Prevention
• Week 9 - Channels, Deeply

ci

• Build systems & toolchains

ci-cd

• Containerization & deployment

cni

• Month 4-Networking and Storage at Scale
• Week 13 - The CNI Spec and Pod Networking
• Week 14 - Cilium and eBPF Networking
• Week 15 - Service Meshes: Istio, Linkerd, Cilium Service Mesh
• Week 16 - CSI at Scale: Snapshots, Backup, Cloning

codegen

• Month 4-Reflection, Code Generation, Plugins
• Week 13 - Reflection: `reflect`, Performance, and Discipline
• Week 14 - `go/ast`, `go/parser`, `go/types`: Static Analysis
• Week 15 - `go generate` and AST-Based Code Generation
• Week 16 - Plugins: `plugin`, `go-plugin`, gRPC-Based Extensions

compact-headers

• Month 3 - Memory & Garbage Collection (Weeks 9–12)
• Week 10 - The Generational Hypothesis and the Modern GCs
• Week 11 - Heap Sizing, GOMEMLIMIT-Equivalents, and Container Awareness
• Week 12 - JFR, Heap Dumps, and Allocation Profiling
• Week 9 - Object Layout, Headers, and Cache Effects

compiler

• Appendix C-Contributing to `rustc`: A Playbook

concurrency

• Async models
• Concurrency
• Memory models
• Month 3-Concurrency Mastery: Channels, Atomics, Context, Patterns
• Month 3-Concurrency and Async: Atomics, Lock-Free, Pin, Tokio, Smol
• Month 4 - Concurrency & Project Loom (Weeks 13–16)
• Month 4 - Concurrency and Parallelism: asyncio, Threads, Processes, Free-Threaded, Subinterpreters
• Week 10 - Channels, Lock-Free Patterns, and `loom`
• Week 10 - `sync` Primitives and `sync/atomic`
• Week 11 - Async Foundations: `Future`, `Pin`, `Unpin`, the State Machine
• Week 11 - `context.Context`, Cancellation, errgroup, singleflight
• Week 12 - Runtimes: Tokio Internals, Smol, Embassy
• Week 12 - Worker Pools, Leak Detection, Deadlock Prevention
• Week 13 - The Java Memory Model and `java.util.concurrent` Foundations
• Week 13 - `asyncio` Foundations: Event Loop, Tasks, Coroutines
• Week 14 - Executors, `CompletableFuture`, and the Pre-Loom World
• Week 14 - Structured Concurrency, Cancellation, ExceptionGroups, `anyio`
• Week 15 - Threads, Processes, Subinterpreters, `concurrent.futures`
• Week 15 - Virtual Threads, Structured Concurrency, and Scoped Values
• Week 16 - Lock-Free Patterns, `VarHandle` Memory Modes, and `jcstress`
• Week 16 - Native Extensions, Releasing the GIL, FFI
• Week 9 - Channels, Deeply
• Week 9 - Threading, Send, Sync, and the Memory Model

consensus

• Distributed consensus

container-primitives

• Month 3-Namespaces, cgroups v2, eBPF
• Week 10 - Control Groups v2
• Week 11 - eBPF: Foundations
• Week 12 - eBPF in Production: Observability Tools
• Week 9 - Namespaces

containerd

• Appendix C-Contributing to the Container Ecosystem
• Month 2-The Node: kubelet, CRI, kube-proxy, CSI, Devices
• Month 3-Runtimes and Daemons: containerd, CRI-O, podman, Rootless
• Week 10 - CRI-O and the Kubernetes CRI
• Week 11 - `podman` and the Rootless Model
• Week 12 - Sandboxed Runtimes: gVisor and Kata Containers
• Week 5 - Kubelet Internals
• Week 6 - CRI: kubelet ↔ Runtime
• Week 7 - kube-proxy, Services, and the Networking Dataplane
• Week 8 - CSI, Storage, and Device Plugins
• Week 9 - `containerd` Architecture

containers

• Appendix A-Container Hardening Reference
• Appendix B-Reference Patterns
• Appendix C-Contributing to the Container Ecosystem
• Capstone Projects-Three Tracks, One Choice
• Container Internals & Runtimes-A 24-Week Mastery Roadmap
• Containerization & deployment
• Month 1-OCI Foundations: Specs, runc, skopeo, crun
• Month 2-Filesystems and Image Builds
• Month 3-Runtimes and Daemons: containerd, CRI-O, podman, Rootless
• Month 4-Container Security
• Month 5-Container Supply Chain: SBOM, Vulnerability Scanning, Signing, SLSA
• Month 6-Build Your Own: Mini-Docker From Scratch
• Prelude-What Containers Actually Are
• Week 1 - The OCI Image Spec
• Week 10 - CRI-O and the Kubernetes CRI
• Week 11 - `podman` and the Rootless Model
• Week 12 - Sandboxed Runtimes: gVisor and Kata Containers
• Week 13 - The Default Threat Model
• Week 14 - Capabilities for Containers
• Week 15 - Seccomp Profiles for Containers
• Week 16 - LSM for Containers: SELinux and AppArmor
• Week 17 - Software Bill of Materials (SBOM)
• Week 18 - Vulnerability Scanning: Grype, Trivy, Clair
• Week 19 - Signing and Verification: Cosign, Sigstore
• Week 2 - The OCI Runtime Spec, `runc`, and `crun`
• Week 20 - SLSA, Provenance, and Reproducibility
• Week 21 - Scaffolding: Project Setup, OCI Bundle Reading
• Week 22 - Namespaces and Process Isolation
• Week 23 - Cgroups v2, Capabilities, Seccomp, OverlayFS
• Week 24 - Polish, Defense, Distribution
• Week 3 - `skopeo` Deep Dive: Multi-Arch, Signing, Sync
• Week 4 - Image Internals: Manifest Lists, Index, Annotations, Sparse Pulls
• Week 5 - OverlayFS and Storage Drivers
• Week 6 - `buildah`: Building Images Without Dockerfiles
• Week 7 - Multi-Stage Builds, Distroless, Minimal Images
• Week 8 - Layer Caching, Build Context, Reproducibility
• Week 9 - `containerd` Architecture
• Worked example - Week 14: Linux capabilities in a real Dockerfile

containers-from-scratch

• 00 - Introduction
• 01 - Setup
• 02 - Running Containers
• 03 - Images and Tags
• 04 - Container Lifecycle
• 05 - Building Images with Dockerfile
• 06 - Volumes and Bind Mounts
• 07 - Networks and Ports
• 08 - Docker Compose
• 09 - Slimming Images
• 10 - Security Basics
• 11 - Image Registries
• 12 - Reading Other People's Dockerfiles
• 13 - Picking a Project
• 14 - Anatomy of a Containerized OSS Project
• 15 - Your First Contribution
• Containers From Scratch - Beginner to OSS Contributor

context

• Month 3-Concurrency Mastery: Channels, Atomics, Context, Patterns
• Week 10 - `sync` Primitives and `sync/atomic`
• Week 11 - `context.Context`, Cancellation, errgroup, singleflight
• Week 12 - Worker Pools, Leak Detection, Deadlock Prevention
• Week 9 - Channels, Deeply

contributing

• Appendix C - Contributing to OpenJDK
• Appendix C - Deep-Dive Session: CPython Internals and the AI Runtime Stack
• Appendix C-Contributing to Go: A Playbook
• Appendix C-Contributing to Kubernetes
• Appendix C-Contributing to `rustc`: A Playbook
• Appendix C-Contributing to the AI Systems Ecosystem
• Appendix C-Contributing to the Container Ecosystem
• Appendix C-Contributing to the Linux Kernel: A Playbook

control-plane

• Month 1-The Control Plane: etcd, kube-apiserver, scheduler, controllers
• Week 1 - etcd and the Raft Consensus Foundation
• Week 2 - The kube-apiserver
• Week 3 - The Scheduler
• Week 4 - Built-in Controllers and `client-go` Foundations

controller

• Month 3-Controllers and Operators: client-go, controller-runtime, CRDs
• Week 10 - `controller-runtime` and Kubebuilder
• Week 11 - CRDs: Schema, Versioning, Validation
• Week 12 - Operator Patterns: Finalizers, External Resources, Multi-Cluster
• Week 9 - `client-go` Internals and a Bare Controller

controller-manager

• Month 1-The Control Plane: etcd, kube-apiserver, scheduler, controllers
• Week 1 - etcd and the Raft Consensus Foundation
• Week 2 - The kube-apiserver
• Week 3 - The Scheduler
• Week 4 - Built-in Controllers and `client-go` Foundations

cosign

• Month 5-Container Supply Chain: SBOM, Vulnerability Scanning, Signing, SLSA
• Week 17 - Software Bill of Materials (SBOM)
• Week 18 - Vulnerability Scanning: Grype, Trivy, Clair
• Week 19 - Signing and Verification: Cosign, Sigstore
• Week 20 - SLSA, Provenance, and Reproducibility

cpython

• Appendix C - Deep-Dive Session: CPython Internals and the AI Runtime Stack
• Month 3 - Runtime and Performance: CPython Internals, GIL, GC, the Allocator
• Prelude - The Philosophy Behind the Syllabus
• Week 10 - Memory: Refcounts, Cyclic GC, the `pymalloc` Allocator
• Week 11 - The GIL, Free-Threaded Python, and the Concurrency Model
• Week 12 - The Optimization Ladder: Algorithm → Vectorize → Native → JIT
• Week 9 - The CPython VM: Objects, Bytecode, the Eval Loop

crd

• Month 3-Controllers and Operators: client-go, controller-runtime, CRDs
• Week 10 - `controller-runtime` and Kubebuilder
• Week 11 - CRDs: Schema, Versioning, Validation
• Week 12 - Operator Patterns: Finalizers, External Resources, Multi-Cluster
• Week 9 - `client-go` Internals and a Bare Controller

cri

• Month 2-The Node: kubelet, CRI, kube-proxy, CSI, Devices
• Week 5 - Kubelet Internals
• Week 6 - CRI: kubelet ↔ Runtime
• Week 7 - kube-proxy, Services, and the Networking Dataplane
• Week 8 - CSI, Storage, and Device Plugins

criterion

• Appendix A-Production Hardening Reference

cross-references

• Cross-References-`tutoriaal` and Sibling Curricula

crun

• Month 3-Runtimes and Daemons: containerd, CRI-O, podman, Rootless
• Week 10 - CRI-O and the Kubernetes CRI
• Week 11 - `podman` and the Rootless Model
• Week 12 - Sandboxed Runtimes: gVisor and Kata Containers
• Week 9 - `containerd` Architecture

csi

• Month 4-Networking and Storage at Scale
• Week 13 - The CNI Spec and Pod Networking
• Week 14 - Cilium and eBPF Networking
• Week 15 - Service Meshes: Istio, Linkerd, Cilium Service Mesh
• Week 16 - CSI at Scale: Snapshots, Backup, Cloning

ctypes

• Month 3 - Runtime and Performance: CPython Internals, GIL, GC, the Allocator
• Week 10 - Memory: Refcounts, Cyclic GC, the `pymalloc` Allocator
• Week 11 - The GIL, Free-Threaded Python, and the Concurrency Model
• Week 12 - The Optimization Ladder: Algorithm → Vectorize → Native → JIT
• Week 9 - The CPython VM: Objects, Bytecode, the Eval Loop

cuda

• Month 2-GPU Programming: Architecture, CUDA, Memory, Triton
• Week 5 - GPU Hardware Architecture
• Week 6 - Your First CUDA Kernels
• Week 7 - Memory Optimization: Coalescing, Shared Memory, Tensor Cores
• Week 8 - Triton: GPU Kernels From Python

daemon

• Month 3-Runtimes and Daemons: containerd, CRI-O, podman, Rootless
• Week 10 - CRI-O and the Kubernetes CRI
• Week 11 - `podman` and the Rootless Model
• Week 12 - Sandboxed Runtimes: gVisor and Kata Containers
• Week 9 - `containerd` Architecture

data-structures

• Appendix B - Build-From-Scratch Data Structures and Patterns
• Appendix B-Build-From-Scratch Data Structures Reference
• Appendix B-Build-From-Scratch Data Structures and Patterns

dataclass

• Month 2 - Intermediate Idioms: Decorators, Context Managers, Dataclasses, Typing
• Week 5 - Object Model Deep Dive: Classes, Descriptors, Metaclasses
• Week 6 - Decorators, `functools`, and `contextlib`
• Week 7 - Dataclasses, `attrs`, Pydantic, and the Validation Boundary
• Week 8 - The Type System: Generics, Protocols, Variance, and `typing.*`

date

• Appendix B - The Legacy Java Field Guide

day2

• Month 5-Platform Engineering and Day-2 Operations
• Week 17 - GitOps: ArgoCD and Flux
• Week 18 - IaC From Within K8s: Crossplane and Terraform
• Week 19 - HPA, VPA, KEDA: Autoscaling
• Week 20 - Admission Control: Webhooks, OPA Gatekeeper, Kyverno

dcgm

• Appendix A-Hardening, Observability, and Fleet Operations

ddd

• Month 5 - Patterns and Architecture: Pythonic Design, Testing, Observability, Service Shape
• Month 5-Production-Grade Distributed Systems Engineering
• Week 17 - DDD in Go: Hexagonal Architecture, Bounded Contexts
• Week 17 - Pythonic Design Patterns
• Week 18 - Data Structures Beyond `list`/`dict`
• Week 18 - Observability: `slog`, `pprof`, `trace`, OpenTelemetry
• Week 19 - Testing, Property-Based Testing, Mutation Testing, Fakes vs. Mocks
• Week 19 - gRPC: Streaming, Interceptors, Deadlines, Retries, Outlier Ejection
• Week 20 - Observability, FastAPI, Production Service Shape
• Week 20 - Testing Strategy: Five Surfaces, Race-Clean

ddp

• Month 4-Distributed Training: NCCL, DDP, FSDP, Tensor & Pipeline Parallelism, FP8
• Week 13 - Communication Primitives: NCCL, Allreduce, Topology
• Week 14 - Data Parallelism: DDP, ZeRO, FSDP
• Week 15 - Tensor Parallelism and Pipeline Parallelism
• Week 16 - Mixed Precision, FP8, Numerical Stability at Scale

debugging

• Appendix B-Troubleshooting Reference Flows

decorators

• Month 2 - Intermediate Idioms: Decorators, Context Managers, Dataclasses, Typing
• Week 5 - Object Model Deep Dive: Classes, Descriptors, Metaclasses
• Week 6 - Decorators, `functools`, and `contextlib`
• Week 7 - Dataclasses, `attrs`, Pydantic, and the Validation Boundary
• Week 8 - The Type System: Generics, Protocols, Variance, and `typing.*`

deep-dive

• Appendix C - Deep-Dive Session: CPython Internals and the AI Runtime Stack

deployment

• Containerization & deployment

descriptors

• Month 2 - Intermediate Idioms: Decorators, Context Managers, Dataclasses, Typing
• Week 5 - Object Model Deep Dive: Classes, Descriptors, Metaclasses
• Week 6 - Decorators, `functools`, and `contextlib`
• Week 7 - Dataclasses, `attrs`, Pydantic, and the Validation Boundary
• Week 8 - The Type System: Generics, Protocols, Variance, and `typing.*`

distributed

• Month 4-Distributed Training: NCCL, DDP, FSDP, Tensor & Pipeline Parallelism, FP8
• Week 13 - Communication Primitives: NCCL, Allreduce, Topology
• Week 14 - Data Parallelism: DDP, ZeRO, FSDP
• Week 15 - Tensor Parallelism and Pipeline Parallelism
• Week 16 - Mixed Precision, FP8, Numerical Stability at Scale

distributed-systems

• Distributed consensus
• Month 6 - Capstone (Weeks 21–24)
• Month 6-Mastery: Consensus, Distributed Storage, Performance Tuning, Defense
• Month 6-Mastery: Custom Data Structures, `no_std`, Compiler Internals, Capstone
• Week 21 - Consensus Algorithms: Raft (and a Glance at Paxos)
• Week 21 - Design and Foundation
• Week 21 - Implementing Complex Data Structures From Scratch
• Week 22 - Core Implementation
• Week 22 - Distributed Storage Patterns
• Week 22 - `no_std`, Custom Allocators, Embedded Targets
• Week 23 - Compiler Internals: MIR, Borrow Check, Codegen
• Week 23 - Failure, Observability, and Operations
• Week 23 - Performance Tuning: Profile, Tune, Re-Profile
• Week 24 - Capstone Integration, Defense, Final Hardening
• Week 24 - Capstone Integration, Profiling, Hardening, Defense
• Week 24 - Defense

distribution-spec

• Month 1-OCI Foundations: Specs, runc, skopeo, crun
• Week 1 - The OCI Image Spec
• Week 2 - The OCI Runtime Spec, `runc`, and `crun`
• Week 3 - `skopeo` Deep Dive: Multi-Arch, Signing, Sync
• Week 4 - Image Internals: Manifest Lists, Index, Annotations, Sparse Pulls

dockerfile

• Month 2-Filesystems and Image Builds
• Week 5 - OverlayFS and Storage Drivers
• Week 6 - `buildah`: Building Images Without Dockerfiles
• Week 7 - Multi-Stage Builds, Distroless, Minimal Images
• Week 8 - Layer Caching, Build Context, Reproducibility

durability

• Curriculum Audit-`tutoriaal`

ebpf

• Appendix A-Hardening and Performance Tuning Reference
• Month 3-Namespaces, cgroups v2, eBPF
• Week 10 - Control Groups v2
• Week 11 - eBPF: Foundations
• Week 12 - eBPF in Production: Observability Tools
• Week 9 - Namespaces

eevdf

• Month 2-Memory Management and Scheduling
• Week 5 - Virtual Memory, Paging, and the Page Cache
• Week 6 - Swapping, OOM, Memory Pressure (PSI)
• Week 7 - The CPU Scheduler (CFS, EEVDF)
• Week 8 - Disk I/O Scheduling, Filesystems Beyond ext4

error-handling

• Month 5-Production Architecture: Hexagonal, Zero-Copy I/O, Observability, Testing
• Week 17 - Hexagonal Architecture and Domain Modeling in Rust
• Week 18 - Zero-Copy I/O and the Poll-Based Model
• Week 19 - Observability: tracing, metrics, OpenTelemetry
• Week 20 - Testing Strategy: Unit, Property, Fuzz, Miri, Integration

errors

• Error handling

escape-analysis

• Month 1-Runtime Foundations: Toolchain, GMP, Stacks, Escape Analysis
• Week 1 - The Toolchain and the Build Pipeline
• Week 2 - The GMP Scheduler Model
• Week 3 - Stack Management
• Week 4 - Escape Analysis and the Inliner

etcd

• Month 1-The Control Plane: etcd, kube-apiserver, scheduler, controllers
• Week 1 - etcd and the Raft Consensus Foundation
• Week 2 - The kube-apiserver
• Week 3 - The Scheduler
• Week 4 - Built-in Controllers and `client-go` Foundations

exceptions

• Error handling

extern-c

• Month 4-Unsafe Rust, FFI, and Macros
• Week 13 - Unsafe Rust: Raw Pointers, NonNull, MaybeUninit, UB
• Week 14 - FFI: Calling C, Being Called By C
• Week 15 - Declarative Macros (`macro_rules!`)
• Week 16 - Procedural Macros

ffi

• FFI - calling C from everything
• Month 3 - Runtime and Performance: CPython Internals, GIL, GC, the Allocator
• Month 4-Reflection, Code Generation, Plugins
• Month 4-Unsafe Rust, FFI, and Macros
• Week 10 - Memory: Refcounts, Cyclic GC, the `pymalloc` Allocator
• Week 11 - The GIL, Free-Threaded Python, and the Concurrency Model
• Week 12 - The Optimization Ladder: Algorithm → Vectorize → Native → JIT
• Week 13 - Reflection: `reflect`, Performance, and Discipline
• Week 13 - Unsafe Rust: Raw Pointers, NonNull, MaybeUninit, UB
• Week 14 - FFI: Calling C, Being Called By C
• Week 14 - `go/ast`, `go/parser`, `go/types`: Static Analysis
• Week 15 - Declarative Macros (`macro_rules!`)
• Week 15 - `go generate` and AST-Based Code Generation
• Week 16 - Plugins: `plugin`, `go-plugin`, gRPC-Based Extensions
• Week 16 - Procedural Macros
• Week 9 - The CPython VM: Objects, Bytecode, the Eval Loop

file-system

• Month 1-Kernel Foundations: Boot, Syscalls, VFS, Processes
• Week 1 - Boot, Init, Systemd
• Week 2 - Syscalls and the Kernel/Userspace Boundary
• Week 3 - The Virtual File System (VFS)
• Week 4 - Processes, Threads, and Signals

filesystem

• Month 2-Filesystems and Image Builds
• Week 5 - OverlayFS and Storage Drivers
• Week 6 - `buildah`: Building Images Without Dockerfiles
• Week 7 - Multi-Stage Builds, Distroless, Minimal Images
• Week 8 - Layer Caching, Build Context, Reproducibility

finalize

• Appendix B - The Legacy Java Field Guide

flamegraph

• Appendix A-Production Hardening Reference

foundations

• Month 1-Foundations: Compute Hierarchy, Tensors, Autograd, Training Loops
• Week 1 - The Compute Hierarchy and the Cost Model
• Week 2 - Linear Algebra Refresh, BLAS, NumPy
• Week 3 - Tensors, Autograd, the Gradient Tape
• Week 4 - The Honest Training Loop

free-threaded

• Month 4 - Concurrency and Parallelism: asyncio, Threads, Processes, Free-Threaded, Subinterpreters
• Week 13 - `asyncio` Foundations: Event Loop, Tasks, Coroutines
• Week 14 - Structured Concurrency, Cancellation, ExceptionGroups, `anyio`
• Week 15 - Threads, Processes, Subinterpreters, `concurrent.futures`
• Week 16 - Native Extensions, Releasing the GIL, FFI

fsdp

• Month 4-Distributed Training: NCCL, DDP, FSDP, Tensor & Pipeline Parallelism, FP8
• Week 13 - Communication Primitives: NCCL, Allreduce, Topology
• Week 14 - Data Parallelism: DDP, ZeRO, FSDP
• Week 15 - Tensor Parallelism and Pipeline Parallelism
• Week 16 - Mixed Precision, FP8, Numerical Stability at Scale

futex

• Month 2-Memory Management and Scheduling
• Week 5 - Virtual Memory, Paging, and the Page Cache
• Week 6 - Swapping, OOM, Memory Pressure (PSI)
• Week 7 - The CPU Scheduler (CFS, EEVDF)
• Week 8 - Disk I/O Scheduling, Filesystems Beyond ext4

fuzz

• Testing

g1

• Month 3 - Memory & Garbage Collection (Weeks 9–12)
• Week 10 - The Generational Hypothesis and the Modern GCs
• Week 11 - Heap Sizing, GOMEMLIMIT-Equivalents, and Container Awareness
• Week 12 - JFR, Heap Dumps, and Allocation Profiling
• Week 9 - Object Layout, Headers, and Cache Effects

gat

• Month 2-The Type System: Lifetimes, Traits, Smart Pointers, Drop
• Week 5 - Advanced Lifetimes, Variance, and HRTBs
• Week 6 - Traits, Coherence, and Monomorphization
• Week 7 - Smart Pointers and Interior Mutability
• Week 8 - Drop, the Drop Checker, and Destructor Discipline

gateway-api

• Month 4-Networking and Storage at Scale
• Week 13 - The CNI Spec and Pod Networking
• Week 14 - Cilium and eBPF Networking
• Week 15 - Service Meshes: Istio, Linkerd, Cilium Service Mesh
• Week 16 - CSI at Scale: Snapshots, Backup, Cloning

gc

• Garbage collection
• Month 2-Memory, the Garbage Collector, and Interface Internals
• Month 3 - Memory & Garbage Collection (Weeks 9–12)
• Week 10 - The Generational Hypothesis and the Modern GCs
• Week 11 - Heap Sizing, GOMEMLIMIT-Equivalents, and Container Awareness
• Week 12 - JFR, Heap Dumps, and Allocation Profiling
• Week 5 - Memory Layout, Padding, Alignment
• Week 6 - The Garbage Collector
• Week 7 - Interface Values, itabs, and Dispatch Cost
• Week 8 - Allocation Profiling, `sync.Pool`, GC Tuning
• Week 9 - Object Layout, Headers, and Cache Effects

generics

• Month 2-The Type System: Lifetimes, Traits, Smart Pointers, Drop
• Month 4-Reflection, Code Generation, Plugins
• Type systems
• Week 13 - Reflection: `reflect`, Performance, and Discipline
• Week 14 - `go/ast`, `go/parser`, `go/types`: Static Analysis
• Week 15 - `go generate` and AST-Based Code Generation
• Week 16 - Plugins: `plugin`, `go-plugin`, gRPC-Based Extensions
• Week 5 - Advanced Lifetimes, Variance, and HRTBs
• Week 6 - Traits, Coherence, and Monomorphization
• Week 7 - Smart Pointers and Interior Mutability
• Week 8 - Drop, the Drop Checker, and Destructor Discipline

gerrit

• Appendix C-Contributing to Go: A Playbook

gil

• Month 4 - Concurrency and Parallelism: asyncio, Threads, Processes, Free-Threaded, Subinterpreters
• Week 13 - `asyncio` Foundations: Event Loop, Tasks, Coroutines
• Week 14 - Structured Concurrency, Cancellation, ExceptionGroups, `anyio`
• Week 15 - Threads, Processes, Subinterpreters, `concurrent.futures`
• Week 16 - Native Extensions, Releasing the GIL, FFI

gitops

• Containerization & deployment

glossary

• Beginner glossary
• Glossary

gmp

• Month 1-Runtime Foundations: Toolchain, GMP, Stacks, Escape Analysis
• Week 1 - The Toolchain and the Build Pipeline
• Week 2 - The GMP Scheduler Model
• Week 3 - Stack Management
• Week 4 - Escape Analysis and the Inliner

go

• Appendix A-Production Hardening Reference
• Appendix B-Build-From-Scratch Data Structures and Patterns
• Appendix C-Contributing to Go: A Playbook
• Capstone Projects-Three Tracks, One Choice
• Go Mastery Blueprint-A 24-Week Master-Level Syllabus
• Month 1-Runtime Foundations: Toolchain, GMP, Stacks, Escape Analysis
• Month 2-Memory, the Garbage Collector, and Interface Internals
• Month 3-Concurrency Mastery: Channels, Atomics, Context, Patterns
• Month 4-Reflection, Code Generation, Plugins
• Month 5-Production-Grade Distributed Systems Engineering
• Month 6-Mastery: Consensus, Distributed Storage, Performance Tuning, Defense
• Prelude-The Philosophy Behind the Syllabus
• Week 1 - The Toolchain and the Build Pipeline
• Week 10 - `sync` Primitives and `sync/atomic`
• Week 11 - `context.Context`, Cancellation, errgroup, singleflight
• Week 12 - Worker Pools, Leak Detection, Deadlock Prevention
• Week 13 - Reflection: `reflect`, Performance, and Discipline
• Week 14 - `go/ast`, `go/parser`, `go/types`: Static Analysis
• Week 15 - `go generate` and AST-Based Code Generation
• Week 16 - Plugins: `plugin`, `go-plugin`, gRPC-Based Extensions
• Week 17 - DDD in Go: Hexagonal Architecture, Bounded Contexts
• Week 18 - Observability: `slog`, `pprof`, `trace`, OpenTelemetry
• Week 19 - gRPC: Streaming, Interceptors, Deadlines, Retries, Outlier Ejection
• Week 2 - The GMP Scheduler Model
• Week 20 - Testing Strategy: Five Surfaces, Race-Clean
• Week 21 - Consensus Algorithms: Raft (and a Glance at Paxos)
• Week 22 - Distributed Storage Patterns
• Week 23 - Performance Tuning: Profile, Tune, Re-Profile
• Week 24 - Capstone Integration, Defense, Final Hardening
• Week 3 - Stack Management
• Week 4 - Escape Analysis and the Inliner
• Week 5 - Memory Layout, Padding, Alignment
• Week 6 - The Garbage Collector
• Week 7 - Interface Values, itabs, and Dispatch Cost
• Week 8 - Allocation Profiling, `sync.Pool`, GC Tuning
• Week 9 - Channels, Deeply
• Worked example - Week 6: reading a `GODEBUG=gctrace=1` output

go-build

• Build systems & toolchains

go-from-scratch

• 00 - Introduction
• 01 - Setup
• 02 - First Real Program
• 03 - Decisions and Loops
• 04 - Functions
• 05 - Making Your Own Types
• 06 - Many Things at Once
• 07 - Errors
• 08 - Pointers and Memory
• 09 - Concurrency 101
• 10 - Tests
• 11 - Packages and Modules
• 12 - Reading Other People's Code
• 13 - Picking a Project to Contribute To
• 14 - Anatomy of a Small OSS Repo
• 15 - Your First Contribution
• Go From Scratch - Beginner to OSS Contributor

gomemlimit

• Month 2-Memory, the Garbage Collector, and Interface Internals
• Week 5 - Memory Layout, Padding, Alignment
• Week 6 - The Garbage Collector
• Week 7 - Interface Values, itabs, and Dispatch Cost
• Week 8 - Allocation Profiling, `sync.Pool`, GC Tuning

goroutine

• Month 3-Concurrency Mastery: Channels, Atomics, Context, Patterns
• Week 10 - `sync` Primitives and `sync/atomic`
• Week 11 - `context.Context`, Cancellation, errgroup, singleflight
• Week 12 - Worker Pools, Leak Detection, Deadlock Prevention
• Week 9 - Channels, Deeply

goroutines

• Async models

gpu

• Month 2-GPU Programming: Architecture, CUDA, Memory, Triton
• Week 5 - GPU Hardware Architecture
• Week 6 - Your First CUDA Kernels
• Week 7 - Memory Optimization: Coalescing, Shared Memory, Tensor Cores
• Week 8 - Triton: GPU Kernels From Python

graal

• Month 2 - JVM & Bytecode (Weeks 5–8)
• Week 5 - Class Loading and Bytecode
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 8 - JMH and Microbenchmarking

gradle

• Build systems & toolchains

grpc

• Month 5 - Production & Distributed Systems (Weeks 17–20)
• Month 5-Production-Grade Distributed Systems Engineering
• Networking
• Week 17 - DDD in Go: Hexagonal Architecture, Bounded Contexts
• Week 17 - Spring Boot 3 and Quarkus
• Week 18 - Observability: Logs, Metrics, Traces
• Week 18 - Observability: `slog`, `pprof`, `trace`, OpenTelemetry
• Week 19 - Persistence, RPC, and Resilience
• Week 19 - gRPC: Streaming, Interceptors, Deadlines, Retries, Outlier Ejection
• Week 20 - Containers, Native Images, and Deployment
• Week 20 - Testing Strategy: Five Surfaces, Race-Clean

happens-before

• Memory models

hardening

• Appendix A - Production Hardening
• Appendix A - Production Hardening Toolkit
• Appendix A-Container Hardening Reference
• Appendix A-Hardening and Performance Tuning Reference
• Appendix A-Hardening, Observability, and Fleet Operations
• Appendix A-Kubernetes Hardening Reference
• Appendix A-Production Hardening Reference
• Appendix A-Production Hardening Reference
• Month 5-Security and Hardening
• Week 17 - Discretionary and Mandatory Access Control
• Week 18 - Capabilities, Seccomp, no_new_privs
• Week 19 - Encryption at Rest: LUKS, dm-crypt, dm-verity
• Week 20 - Audit, Integrity Measurement, and Compliance

hashtable

• Appendix B - The Legacy Java Field Guide

heap

• Month 2-Memory, the Garbage Collector, and Interface Internals
• Month 3 - Memory & Garbage Collection (Weeks 9–12)
• Week 10 - The Generational Hypothesis and the Modern GCs
• Week 11 - Heap Sizing, GOMEMLIMIT-Equivalents, and Container Awareness
• Week 12 - JFR, Heap Dumps, and Allocation Profiling
• Week 5 - Memory Layout, Padding, Alignment
• Week 6 - The Garbage Collector
• Week 7 - Interface Values, itabs, and Dispatch Cost
• Week 8 - Allocation Profiling, `sync.Pool`, GC Tuning
• Week 9 - Object Layout, Headers, and Cache Effects

hotspot

• Appendix C - Contributing to OpenJDK

http

• Networking

idioms

• Month 1 - Foundations: The Data Model, Idioms, and Packaging
• Month 2 - Intermediate Idioms: Decorators, Context Managers, Dataclasses, Typing
• Week 1 - Syntax, Values, Names, and the Data Model
• Week 2 - Control Flow, Functions, Errors, and the Call Model
• Week 3 - Collections, Comprehensions, Iterators, and Generators
• Week 4 - Modules, Packaging, Virtual Environments, and the Import System
• Week 5 - Object Model Deep Dive: Classes, Descriptors, Metaclasses
• Week 6 - Decorators, `functools`, and `contextlib`
• Week 7 - Dataclasses, `attrs`, Pydantic, and the Validation Boundary
• Week 8 - The Type System: Generics, Protocols, Variance, and `typing.*`

image-spec

• Month 1-OCI Foundations: Specs, runc, skopeo, crun
• Week 1 - The OCI Image Spec
• Week 2 - The OCI Runtime Spec, `runc`, and `crun`
• Week 3 - `skopeo` Deep Dive: Multi-Arch, Signing, Sync
• Week 4 - Image Internals: Manifest Lists, Index, Annotations, Sparse Pulls

index

• Cross-References-`tutoriaal` and Sibling Curricula

inductor

• Month 3-Framework Internals: PyTorch, torch.compile, JAX/XLA, Custom Ops
• Week 10 - torch.compile, TorchDynamo, Inductor
• Week 11 - JAX, XLA, HLO
• Week 12 - Custom Operators: From CUDA Kernel to `torch.ops`
• Week 9 - PyTorch Internals: Tensor, Dispatcher, ATen

inference

• Capstone Projects-Three Tracks, One Choice
• Month 5-Inference Systems: KV-Cache, Paged Attention, Continuous Batching, Quantization, Speculative Decoding
• Month 6 - AI Systems at a Senior Level: RAG, Agents, Evals, Training, Serving
• Week 17 - LLM Inference, the KV-Cache, Attention Math
• Week 18 - Paged Attention, Continuous Batching, vLLM
• Week 19 - Quantization: INT8, INT4, FP8, AWQ, GPTQ, SmoothQuant
• Week 20 - Speculative Decoding, Disaggregation, Inference Frontiers
• Week 21 - LLM-App Foundations: Prompts, Tokens, Streaming, Cost
• Week 22 - Retrieval-Augmented Generation: Doing It Properly
• Week 23 - Agents, Tools, Durable Execution, Cost & Safety
• Week 24 - Training, Serving, Rollout, and the Capstone Defense

infrastructure

• Month 6-ML Infrastructure, Safety & Eval Infra, Capstone Defense
• Week 21 - ML on Kubernetes: KServe, KubeRay, Volcano, GPU Operators
• Week 22 - Observability, Cost, Eval Pipelines, MLOps
• Week 23 - Safety, Red-Teaming, Alignment Infrastructure
• Week 24 - Capstone Integration & Defense

ingress

• Month 4-Networking and Storage at Scale
• Week 13 - The CNI Spec and Pod Networking
• Week 14 - Cilium and eBPF Networking
• Week 15 - Service Meshes: Istio, Linkerd, Cilium Service Mesh
• Week 16 - CSI at Scale: Snapshots, Backup, Cloning

integration

• Testing

interfaces

• Type systems

interop

• FFI - calling C from everything

io-multiplexing

• Networking

io-uring

• Async models

isolation

• Month 3-Namespaces, cgroups v2, eBPF
• Week 10 - Control Groups v2
• Week 11 - eBPF: Foundations
• Week 12 - eBPF in Production: Observability Tools
• Week 9 - Namespaces

j2ee

• Appendix B - The Legacy Java Field Guide

java

• Appendix A - Production Hardening
• Appendix B - The Legacy Java Field Guide
• Appendix C - Contributing to OpenJDK
• Capstone Projects
• Java Mastery Blueprint - A 24-Week Master-Level Syllabus
• Month 1 - Language & Toolchain (Weeks 1–4)
• Month 2 - JVM & Bytecode (Weeks 5–8)
• Month 3 - Memory & Garbage Collection (Weeks 9–12)
• Month 4 - Concurrency & Project Loom (Weeks 13–16)
• Month 5 - Production & Distributed Systems (Weeks 17–20)
• Month 6 - Capstone (Weeks 21–24)
• Prelude - The Philosophy Behind the Syllabus
• Week 1 - Modern Syntax and the Type System
• Week 10 - The Generational Hypothesis and the Modern GCs
• Week 11 - Heap Sizing, GOMEMLIMIT-Equivalents, and Container Awareness
• Week 12 - JFR, Heap Dumps, and Allocation Profiling
• Week 13 - The Java Memory Model and `java.util.concurrent` Foundations
• Week 14 - Executors, `CompletableFuture`, and the Pre-Loom World
• Week 15 - Virtual Threads, Structured Concurrency, and Scoped Values
• Week 16 - Lock-Free Patterns, `VarHandle` Memory Modes, and `jcstress`
• Week 17 - Spring Boot 3 and Quarkus
• Week 18 - Observability: Logs, Metrics, Traces
• Week 19 - Persistence, RPC, and Resilience
• Week 2 - Build Tools, Dependencies, and JPMS
• Week 20 - Containers, Native Images, and Deployment
• Week 21 - Design and Foundation
• Week 22 - Core Implementation
• Week 23 - Failure, Observability, and Operations
• Week 24 - Defense
• Week 3 - Collections, Streams, and `java.time`
• Week 4 - Testing, Logging, and the Definition-of-Done
• Week 5 - Class Loading and Bytecode
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 8 - JMH and Microbenchmarking
• Week 9 - Object Layout, Headers, and Cache Effects
• Worked example - Week 16: a lock-free counter, then the ABA bug
• Worked example - Week 5: reading bytecode
• Worked example - Week 8: a JMH benchmark, line by line

java-from-scratch

• 00 - Introduction
• 01 - Setup
• 02 - First Real Program
• 03 - Decisions and Loops
• 04 - Methods
• 05 - Classes and Objects
• 06 - Collections
• 07 - Exceptions
• 08 - Records, Sealed Classes, Pattern Matching
• 09 - Generics
• 10 - Tests
• 11 - Packages, Modules, Maven
• 12 - Reading Other People's Code
• 13 - Picking a Project to Contribute To
• 14 - Anatomy of a Java OSS Repo
• 15 - Your First Contribution
• Java From Scratch - Beginner to OSS Contributor

jax

• Month 3-Framework Internals: PyTorch, torch.compile, JAX/XLA, Custom Ops
• Week 10 - torch.compile, TorchDynamo, Inductor
• Week 11 - JAX, XLA, HLO
• Week 12 - Custom Operators: From CUDA Kernel to `torch.ops`
• Week 9 - PyTorch Internals: Tensor, Dispatcher, ATen

jbs

• Appendix C - Contributing to OpenJDK

jcstress

• Month 4 - Concurrency & Project Loom (Weeks 13–16)
• Week 13 - The Java Memory Model and `java.util.concurrent` Foundations
• Week 14 - Executors, `CompletableFuture`, and the Pre-Loom World
• Week 15 - Virtual Threads, Structured Concurrency, and Scoped Values
• Week 16 - Lock-Free Patterns, `VarHandle` Memory Modes, and `jcstress`

jfr

• Appendix A - Production Hardening
• Month 3 - Memory & Garbage Collection (Weeks 9–12)
• Week 10 - The Generational Hypothesis and the Modern GCs
• Week 11 - Heap Sizing, GOMEMLIMIT-Equivalents, and Container Awareness
• Week 12 - JFR, Heap Dumps, and Allocation Profiling
• Week 9 - Object Layout, Headers, and Cache Effects

jit

• Month 2 - JVM & Bytecode (Weeks 5–8)
• Week 5 - Class Loading and Bytecode
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 8 - JMH and Microbenchmarking

jmh

• Appendix A - Production Hardening
• Month 2 - JVM & Bytecode (Weeks 5–8)
• Week 5 - Class Loading and Bytecode
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 8 - JMH and Microbenchmarking

jmm

• Month 4 - Concurrency & Project Loom (Weeks 13–16)
• Week 13 - The Java Memory Model and `java.util.concurrent` Foundations
• Week 14 - Executors, `CompletableFuture`, and the Pre-Loom World
• Week 15 - Virtual Threads, Structured Concurrency, and Scoped Values
• Week 16 - Lock-Free Patterns, `VarHandle` Memory Modes, and `jcstress`

jni

• Appendix B - The Legacy Java Field Guide

jpms

• Month 1 - Language & Toolchain (Weeks 1–4)
• Week 1 - Modern Syntax and the Type System
• Week 2 - Build Tools, Dependencies, and JPMS
• Week 3 - Collections, Streams, and `java.time`
• Week 4 - Testing, Logging, and the Definition-of-Done

junit4

• Appendix B - The Legacy Java Field Guide

junit5

• Month 1 - Language & Toolchain (Weeks 1–4)
• Week 1 - Modern Syntax and the Type System
• Week 2 - Build Tools, Dependencies, and JPMS
• Week 3 - Collections, Streams, and `java.time`
• Week 4 - Testing, Logging, and the Definition-of-Done

jvm

• Month 2 - JVM & Bytecode (Weeks 5–8)
• Prelude - The Philosophy Behind the Syllabus
• Week 5 - Class Loading and Bytecode
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 8 - JMH and Microbenchmarking

kbuild

• Build systems & toolchains

kernel

• Month 1-Kernel Foundations: Boot, Syscalls, VFS, Processes
• Prelude-The Philosophy Behind the Syllabus
• Week 1 - Boot, Init, Systemd
• Week 2 - Syscalls and the Kernel/Userspace Boundary
• Week 3 - The Virtual File System (VFS)
• Week 4 - Processes, Threads, and Signals

kernel-module

• Capstone Projects-Three Tracks, One Choice
• Month 6-Kernel Modules, Performance Mastery, Capstone
• Week 21 - Loadable Kernel Modules (LKM)
• Week 22 - Tracing and Performance Mastery: ftrace, perf, BPF
• Week 23 - Performance Tuning at Scale
• Week 24 - Capstone Integration & Defense

kubebuilder

• Month 3-Controllers and Operators: client-go, controller-runtime, CRDs
• Week 10 - `controller-runtime` and Kubebuilder
• Week 11 - CRDs: Schema, Versioning, Validation
• Week 12 - Operator Patterns: Finalizers, External Resources, Multi-Cluster
• Week 9 - `client-go` Internals and a Bare Controller

kubelet

• Month 2-The Node: kubelet, CRI, kube-proxy, CSI, Devices
• Week 5 - Kubelet Internals
• Week 6 - CRI: kubelet ↔ Runtime
• Week 7 - kube-proxy, Services, and the Networking Dataplane
• Week 8 - CSI, Storage, and Device Plugins

kubernetes

• Appendix A-Kubernetes Hardening Reference
• Appendix B-Troubleshooting Reference Flows
• Appendix C-Contributing to Kubernetes
• Capstone Projects-Three Tracks, One Choice
• Containerization & deployment
• Kubernetes Platform Engineering-A 24-Week Mastery Roadmap
• Month 1-The Control Plane: etcd, kube-apiserver, scheduler, controllers
• Month 2-The Node: kubelet, CRI, kube-proxy, CSI, Devices
• Month 3-Controllers and Operators: client-go, controller-runtime, CRDs
• Month 4-Networking and Storage at Scale
• Month 5-Platform Engineering and Day-2 Operations
• Month 6-Kubernetes The Hard Way + Capstone
• Prelude-What Kubernetes Actually Is
• Week 1 - etcd and the Raft Consensus Foundation
• Week 10 - `controller-runtime` and Kubebuilder
• Week 11 - CRDs: Schema, Versioning, Validation
• Week 12 - Operator Patterns: Finalizers, External Resources, Multi-Cluster
• Week 13 - The CNI Spec and Pod Networking
• Week 14 - Cilium and eBPF Networking
• Week 15 - Service Meshes: Istio, Linkerd, Cilium Service Mesh
• Week 16 - CSI at Scale: Snapshots, Backup, Cloning
• Week 17 - GitOps: ArgoCD and Flux
• Week 18 - IaC From Within K8s: Crossplane and Terraform
• Week 19 - HPA, VPA, KEDA: Autoscaling
• Week 2 - The kube-apiserver
• Week 20 - Admission Control: Webhooks, OPA Gatekeeper, Kyverno
• Week 21 - Bootstrap: VMs, Certificates, etcd
• Week 22 - Control Plane and Worker Nodes
• Week 23 - RBAC, Multi-Tenancy, mTLS Everywhere
• Week 24 - Defense, Documentation, and the Capstone Demo
• Week 3 - The Scheduler
• Week 4 - Built-in Controllers and `client-go` Foundations
• Week 5 - Kubelet Internals
• Week 6 - CRI: kubelet ↔ Runtime
• Week 7 - kube-proxy, Services, and the Networking Dataplane
• Week 8 - CSI, Storage, and Device Plugins
• Week 9 - `client-go` Internals and a Bare Controller
• Worked example - Week 14: a NetworkPolicy → what eBPF actually does

kubernetes-from-scratch

• 00 - Introduction
• 01 - Setup
• 02 - Pods
• 03 - Deployments
• 04 - Services
• 05 - ConfigMaps and Secrets
• 06 - Namespaces
• 07 - Labels and Selectors
• 08 - Volumes and Storage
• 09 - Ingress
• 10 - Helm
• 11 - kubectl Power Tools
• 12 - Reading Other People's Manifests
• 13 - Picking a Project
• 14 - Anatomy of a K8s-Related OSS Project
• 15 - Your First Contribution
• Kubernetes From Scratch - Beginner to OSS Contributor

kubernetes-the-hard-way

• Month 6-Kubernetes The Hard Way + Capstone
• Week 21 - Bootstrap: VMs, Certificates, etcd
• Week 22 - Control Plane and Worker Nodes
• Week 23 - RBAC, Multi-Tenancy, mTLS Everywhere
• Week 24 - Defense, Documentation, and the Capstone Demo

language

• Month 1 - Foundations: The Data Model, Idioms, and Packaging
• Week 1 - Syntax, Values, Names, and the Data Model
• Week 2 - Control Flow, Functions, Errors, and the Call Model
• Week 3 - Collections, Comprehensions, Iterators, and Generators
• Week 4 - Modules, Packaging, Virtual Environments, and the Import System

legacy

• Appendix B - The Legacy Java Field Guide

lifetime

• Month 1-Foundations: Toolchain, Memory Layout, Ownership, Errors
• Month 2-The Type System: Lifetimes, Traits, Smart Pointers, Drop
• Week 1 - The Toolchain and the Compiler Pipeline
• Week 2 - Memory Layout: Stack, Heap, Data, BSS, TLS
• Week 3 - Ownership, Borrowing, and Region Inference
• Week 4 - The Error Model
• Week 5 - Advanced Lifetimes, Variance, and HRTBs
• Week 6 - Traits, Coherence, and Monomorphization
• Week 7 - Smart Pointers and Interior Mutability
• Week 8 - Drop, the Drop Checker, and Destructor Discipline

linear-algebra

• Month 1-Foundations: Compute Hierarchy, Tensors, Autograd, Training Loops
• Week 1 - The Compute Hierarchy and the Cost Model
• Week 2 - Linear Algebra Refresh, BLAS, NumPy
• Week 3 - Tensors, Autograd, the Gradient Tape
• Week 4 - The Honest Training Loop

linux

• Appendix A-Hardening and Performance Tuning Reference
• Appendix B-Build-From-Scratch Linux Toolbox
• Appendix C-Contributing to the Linux Kernel: A Playbook
• Capstone Projects-Three Tracks, One Choice
• Linux Systems & Kernel Engineering-A 24-Week Mastery Roadmap
• Month 1-Kernel Foundations: Boot, Syscalls, VFS, Processes
• Month 2-Memory Management and Scheduling
• Month 3-Namespaces, cgroups v2, eBPF
• Month 4-Linux Networking: Netfilter, IPVS, XDP, Bridges, OVS
• Month 5-Security and Hardening
• Month 6-Kernel Modules, Performance Mastery, Capstone
• Prelude-The Philosophy Behind the Syllabus
• Week 1 - Boot, Init, Systemd
• Week 10 - Control Groups v2
• Week 11 - eBPF: Foundations
• Week 12 - eBPF in Production: Observability Tools
• Week 13 - The Network Stack: Sockets, NAPI, conntrack
• Week 14 - Netfilter / nftables / iptables, IPVS
• Week 15 - XDP and AF_XDP
• Week 16 - Bridges, VLANs, OVS
• Week 17 - Discretionary and Mandatory Access Control
• Week 18 - Capabilities, Seccomp, no_new_privs
• Week 19 - Encryption at Rest: LUKS, dm-crypt, dm-verity
• Week 2 - Syscalls and the Kernel/Userspace Boundary
• Week 20 - Audit, Integrity Measurement, and Compliance
• Week 21 - Loadable Kernel Modules (LKM)
• Week 22 - Tracing and Performance Mastery: ftrace, perf, BPF
• Week 23 - Performance Tuning at Scale
• Week 24 - Capstone Integration & Defense
• Week 3 - The Virtual File System (VFS)
• Week 4 - Processes, Threads, and Signals
• Week 5 - Virtual Memory, Paging, and the Page Cache
• Week 6 - Swapping, OOM, Memory Pressure (PSI)
• Week 7 - The CPU Scheduler (CFS, EEVDF)
• Week 8 - Disk I/O Scheduling, Filesystems Beyond ext4
• Week 9 - Namespaces
• Worked example - Week 10: cgroups v2 on your laptop, end to end

linux-from-scratch

• 00 - Introduction
• 01 - Setup
• 02 - The Shell: ls, cd, pwd
• 03 - Files and Directories
• 04 - Reading Files
• 05 - Searching
• 06 - Permissions and Users
• 07 - Pipes and Redirection
• 08 - Processes
• 09 - Shell Scripting Basics
• 10 - Editing in the Terminal
• 11 - Package Managers
• 12 - Networking Essentials
• 13 - Picking a Project
• 14 - Anatomy of a Small Linux-Adjacent Project
• 15 - Your First Contribution
• Linux From Scratch - Beginner to Command-Line Contributor

lkm

• Month 6-Kernel Modules, Performance Mastery, Capstone
• Week 21 - Loadable Kernel Modules (LKM)
• Week 22 - Tracing and Performance Mastery: ftrace, perf, BPF
• Week 23 - Performance Tuning at Scale
• Week 24 - Capstone Integration & Defense

lkml

• Appendix C-Contributing to the Linux Kernel: A Playbook

lockfree

• Appendix B-Build-From-Scratch Data Structures Reference
• Appendix B-Build-From-Scratch Data Structures and Patterns

locks

• Concurrency

loom

• Async models
• Month 4 - Concurrency & Project Loom (Weeks 13–16)
• Week 13 - The Java Memory Model and `java.util.concurrent` Foundations
• Week 14 - Executors, `CompletableFuture`, and the Pre-Loom World
• Week 15 - Virtual Threads, Structured Concurrency, and Scoped Values
• Week 16 - Lock-Free Patterns, `VarHandle` Memory Modes, and `jcstress`

low-level

• Month 6-Build Your Own: Mini-Docker From Scratch
• Week 21 - Scaffolding: Project Setup, OCI Bundle Reading
• Week 22 - Namespaces and Process Isolation
• Week 23 - Cgroups v2, Capabilities, Seccomp, OverlayFS
• Week 24 - Polish, Defense, Distribution

lru

• Appendix B-Build-From-Scratch Data Structures and Patterns

lsm

• Month 5-Security and Hardening
• Week 17 - Discretionary and Mandatory Access Control
• Week 18 - Capabilities, Seccomp, no_new_privs
• Week 19 - Encryption at Rest: LUKS, dm-crypt, dm-verity
• Week 20 - Audit, Integrity Measurement, and Compliance

macros

• Month 4-Unsafe Rust, FFI, and Macros
• Week 13 - Unsafe Rust: Raw Pointers, NonNull, MaybeUninit, UB
• Week 14 - FFI: Calling C, Being Called By C
• Week 15 - Declarative Macros (`macro_rules!`)
• Week 16 - Procedural Macros

mat

• Appendix A - Production Hardening

math

• Month 1-Foundations: Compute Hierarchy, Tensors, Autograd, Training Loops
• Week 1 - The Compute Hierarchy and the Cost Model
• Week 2 - Linear Algebra Refresh, BLAS, NumPy
• Week 3 - Tensors, Autograd, the Gradient Tape
• Week 4 - The Honest Training Loop

maven

• Build systems & toolchains

megatron

• Month 4-Distributed Training: NCCL, DDP, FSDP, Tensor & Pipeline Parallelism, FP8
• Week 13 - Communication Primitives: NCCL, Allreduce, Topology
• Week 14 - Data Parallelism: DDP, ZeRO, FSDP
• Week 15 - Tensor Parallelism and Pipeline Parallelism
• Week 16 - Mixed Precision, FP8, Numerical Stability at Scale

memory

• Garbage collection
• Month 2-Memory Management and Scheduling
• Month 2-Memory, the Garbage Collector, and Interface Internals
• Month 3 - Memory & Garbage Collection (Weeks 9–12)
• Week 10 - The Generational Hypothesis and the Modern GCs
• Week 11 - Heap Sizing, GOMEMLIMIT-Equivalents, and Container Awareness
• Week 12 - JFR, Heap Dumps, and Allocation Profiling
• Week 5 - Memory Layout, Padding, Alignment
• Week 5 - Virtual Memory, Paging, and the Page Cache
• Week 6 - Swapping, OOM, Memory Pressure (PSI)
• Week 6 - The Garbage Collector
• Week 7 - Interface Values, itabs, and Dispatch Cost
• Week 7 - The CPU Scheduler (CFS, EEVDF)
• Week 8 - Allocation Profiling, `sync.Pool`, GC Tuning
• Week 8 - Disk I/O Scheduling, Filesystems Beyond ext4
• Week 9 - Object Layout, Headers, and Cache Effects

memory-model

• Concurrency
• Memory models
• Month 3-Concurrency Mastery: Channels, Atomics, Context, Patterns
• Month 3-Concurrency and Async: Atomics, Lock-Free, Pin, Tokio, Smol
• Week 10 - Channels, Lock-Free Patterns, and `loom`
• Week 10 - `sync` Primitives and `sync/atomic`
• Week 11 - Async Foundations: `Future`, `Pin`, `Unpin`, the State Machine
• Week 11 - `context.Context`, Cancellation, errgroup, singleflight
• Week 12 - Runtimes: Tokio Internals, Smol, Embassy
• Week 12 - Worker Pools, Leak Detection, Deadlock Prevention
• Week 9 - Channels, Deeply
• Week 9 - Threading, Send, Sync, and the Memory Model

mental-model

• Prelude - The Philosophy Behind the Syllabus
• Prelude - The Philosophy Behind the Syllabus
• Prelude-The Philosophy Behind the Syllabus
• Prelude-The Philosophy Behind the Syllabus
• Prelude-The Philosophy Behind the Syllabus
• Prelude-The Shape of the Discipline
• Prelude-What Containers Actually Are
• Prelude-What Kubernetes Actually Is

mesh

• Capstone Projects
• Capstone Projects-Three Tracks, One Choice
• Capstone Projects-Three Tracks, One Choice
• Month 6 - Capstone (Weeks 21–24)
• Week 21 - Design and Foundation
• Week 22 - Core Implementation
• Week 23 - Failure, Observability, and Operations
• Week 24 - Defense

methodhandle

• Month 2 - JVM & Bytecode (Weeks 5–8)
• Week 5 - Class Loading and Bytecode
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 8 - JMH and Microbenchmarking

methodology

• Performance methodology

metrics

• Observability

micrometer

• Month 5 - Production & Distributed Systems (Weeks 17–20)
• Week 17 - Spring Boot 3 and Quarkus
• Week 18 - Observability: Logs, Metrics, Traces
• Week 19 - Persistence, RPC, and Resilience
• Week 20 - Containers, Native Images, and Deployment

migration

• Appendix B - The Legacy Java Field Guide

multiprocessing

• Month 4 - Concurrency and Parallelism: asyncio, Threads, Processes, Free-Threaded, Subinterpreters
• Week 13 - `asyncio` Foundations: Event Loop, Tasks, Coroutines
• Week 14 - Structured Concurrency, Cancellation, ExceptionGroups, `anyio`
• Week 15 - Threads, Processes, Subinterpreters, `concurrent.futures`
• Week 16 - Native Extensions, Releasing the GIL, FFI

namespaces

• Month 3-Namespaces, cgroups v2, eBPF
• Month 4-Container Security
• Week 10 - Control Groups v2
• Week 11 - eBPF: Foundations
• Week 12 - eBPF in Production: Observability Tools
• Week 13 - The Default Threat Model
• Week 14 - Capabilities for Containers
• Week 15 - Seccomp Profiles for Containers
• Week 16 - LSM for Containers: SELinux and AppArmor
• Week 9 - Namespaces

native

• FFI - calling C from everything

native-image

• Month 2 - JVM & Bytecode (Weeks 5–8)
• Week 5 - Class Loading and Bytecode
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 8 - JMH and Microbenchmarking

netfilter

• Month 4-Linux Networking: Netfilter, IPVS, XDP, Bridges, OVS
• Week 13 - The Network Stack: Sockets, NAPI, conntrack
• Week 14 - Netfilter / nftables / iptables, IPVS
• Week 15 - XDP and AF_XDP
• Week 16 - Bridges, VLANs, OVS

networking

• Month 4-Linux Networking: Netfilter, IPVS, XDP, Bridges, OVS
• Month 4-Networking and Storage at Scale
• Networking
• Week 13 - The CNI Spec and Pod Networking
• Week 13 - The Network Stack: Sockets, NAPI, conntrack
• Week 14 - Cilium and eBPF Networking
• Week 14 - Netfilter / nftables / iptables, IPVS
• Week 15 - Service Meshes: Istio, Linkerd, Cilium Service Mesh
• Week 15 - XDP and AF_XDP
• Week 16 - Bridges, VLANs, OVS
• Week 16 - CSI at Scale: Snapshots, Backup, Cloning

nsight

• Appendix A-Hardening, Observability, and Fleet Operations

object-layout

• Month 3 - Memory & Garbage Collection (Weeks 9–12)
• Week 10 - The Generational Hypothesis and the Modern GCs
• Week 11 - Heap Sizing, GOMEMLIMIT-Equivalents, and Container Awareness
• Week 12 - JFR, Heap Dumps, and Allocation Profiling
• Week 9 - Object Layout, Headers, and Cache Effects

observability

• Appendix A - Production Hardening
• Appendix A - Production Hardening Toolkit
• Appendix A-Container Hardening Reference
• Appendix A-Hardening and Performance Tuning Reference
• Appendix A-Hardening, Observability, and Fleet Operations
• Appendix A-Kubernetes Hardening Reference
• Appendix A-Production Hardening Reference
• Appendix A-Production Hardening Reference
• Month 5 - Production & Distributed Systems (Weeks 17–20)
• Month 5-Platform Engineering and Day-2 Operations
• Month 5-Production Architecture: Hexagonal, Zero-Copy I/O, Observability, Testing
• Month 5-Production-Grade Distributed Systems Engineering
• Observability
• Week 17 - DDD in Go: Hexagonal Architecture, Bounded Contexts
• Week 17 - GitOps: ArgoCD and Flux
• Week 17 - Hexagonal Architecture and Domain Modeling in Rust
• Week 17 - Spring Boot 3 and Quarkus
• Week 18 - IaC From Within K8s: Crossplane and Terraform
• Week 18 - Observability: Logs, Metrics, Traces
• Week 18 - Observability: `slog`, `pprof`, `trace`, OpenTelemetry
• Week 18 - Zero-Copy I/O and the Poll-Based Model
• Week 19 - HPA, VPA, KEDA: Autoscaling
• Week 19 - Observability: tracing, metrics, OpenTelemetry
• Week 19 - Persistence, RPC, and Resilience
• Week 19 - gRPC: Streaming, Interceptors, Deadlines, Retries, Outlier Ejection
• Week 20 - Admission Control: Webhooks, OPA Gatekeeper, Kyverno
• Week 20 - Containers, Native Images, and Deployment
• Week 20 - Testing Strategy: Five Surfaces, Race-Clean
• Week 20 - Testing Strategy: Unit, Property, Fuzz, Miri, Integration

oci

• Appendix C-Contributing to the Container Ecosystem
• Month 1-OCI Foundations: Specs, runc, skopeo, crun
• Prelude-What Containers Actually Are
• Week 1 - The OCI Image Spec
• Week 2 - The OCI Runtime Spec, `runc`, and `crun`
• Week 3 - `skopeo` Deep Dive: Multi-Arch, Signing, Sync
• Week 4 - Image Internals: Manifest Lists, Index, Annotations, Sparse Pulls

openjdk

• Appendix C - Contributing to OpenJDK

openjdk-style

• Appendix C-Contributing to Go: A Playbook

opentelemetry

• Appendix A - Production Hardening Toolkit
• Month 5 - Production & Distributed Systems (Weeks 17–20)
• Week 17 - Spring Boot 3 and Quarkus
• Week 18 - Observability: Logs, Metrics, Traces
• Week 19 - Persistence, RPC, and Resilience
• Week 20 - Containers, Native Images, and Deployment

operator

• Month 3-Controllers and Operators: client-go, controller-runtime, CRDs
• Week 10 - `controller-runtime` and Kubebuilder
• Week 11 - CRDs: Schema, Versioning, Validation
• Week 12 - Operator Patterns: Finalizers, External Resources, Multi-Cluster
• Week 9 - `client-go` Internals and a Bare Controller

optimization

• Performance methodology

ordering

• Memory models

overlayfs

• Month 2-Filesystems and Image Builds
• Week 5 - OverlayFS and Storage Drivers
• Week 6 - `buildah`: Building Images Without Dockerfiles
• Week 7 - Multi-Stage Builds, Distroless, Minimal Images
• Week 8 - Layer Caching, Build Context, Reproducibility

overview

• AI Systems Engineering-A 24-Week Beginner-to-Advanced Mastery Roadmap
• Container Internals & Runtimes-A 24-Week Mastery Roadmap
• Deep Dives-Self-Contained Reference Chapters
• Deep Dives-Self-Contained Reference Chapters
• Go Mastery Blueprint-A 24-Week Master-Level Syllabus
• Java Mastery Blueprint - A 24-Week Master-Level Syllabus
• Kubernetes Platform Engineering-A 24-Week Mastery Roadmap
• Linux Systems & Kernel Engineering-A 24-Week Mastery Roadmap
• Python Mastery Blueprint - A 24-Week Beginner-to-Senior Syllabus (AI-Systems Track)
• Rust Mastery Blueprint-A 24-Week Master-Level Syllabus
• tutoriaal-companion learning material for AI_EXPERT_ROADMAP.md

ownership

• Month 1-Foundations: Toolchain, Memory Layout, Ownership, Errors
• Prelude-The Philosophy Behind the Syllabus
• Week 1 - The Toolchain and the Compiler Pipeline
• Week 2 - Memory Layout: Stack, Heap, Data, BSS, TLS
• Week 3 - Ownership, Borrowing, and Region Inference
• Week 4 - The Error Model

packaging

• Month 1 - Foundations: The Data Model, Idioms, and Packaging
• Week 1 - Syntax, Values, Names, and the Data Model
• Week 2 - Control Flow, Functions, Errors, and the Call Model
• Week 3 - Collections, Comprehensions, Iterators, and Generators
• Week 4 - Modules, Packaging, Virtual Environments, and the Import System

page-cache

• Month 2-Memory Management and Scheduling
• Week 5 - Virtual Memory, Paging, and the Page Cache
• Week 6 - Swapping, OOM, Memory Pressure (PSI)
• Week 7 - The CPU Scheduler (CFS, EEVDF)
• Week 8 - Disk I/O Scheduling, Filesystems Beyond ext4

paged-attention

• Month 5-Inference Systems: KV-Cache, Paged Attention, Continuous Batching, Quantization, Speculative Decoding
• Week 17 - LLM Inference, the KV-Cache, Attention Math
• Week 18 - Paged Attention, Continuous Batching, vLLM
• Week 19 - Quantization: INT8, INT4, FP8, AWQ, GPTQ, SmoothQuant
• Week 20 - Speculative Decoding, Disaggregation, Inference Frontiers

panama

• FFI - calling C from everything

panama-equivalent

• Month 4-Unsafe Rust, FFI, and Macros
• Week 13 - Unsafe Rust: Raw Pointers, NonNull, MaybeUninit, UB
• Week 14 - FFI: Calling C, Being Called By C
• Week 15 - Declarative Macros (`macro_rules!`)
• Week 16 - Procedural Macros

panic

• Error handling

parallelism

• Concurrency

patches

• Appendix C-Contributing to the Linux Kernel: A Playbook

pattern-matching

• Month 1 - Language & Toolchain (Weeks 1–4)
• Week 1 - Modern Syntax and the Type System
• Week 2 - Build Tools, Dependencies, and JPMS
• Week 3 - Collections, Streams, and `java.time`
• Week 4 - Testing, Logging, and the Definition-of-Done

patterns

• Appendix B - Build-From-Scratch Data Structures and Patterns
• Appendix B-Reference Patterns
• Month 5 - Patterns and Architecture: Pythonic Design, Testing, Observability, Service Shape
• Week 17 - Pythonic Design Patterns
• Week 18 - Data Structures Beyond `list`/`dict`
• Week 19 - Testing, Property-Based Testing, Mutation Testing, Fakes vs. Mocks
• Week 20 - Observability, FastAPI, Production Service Shape

paxos

• Distributed consensus

perf

• Appendix A-Hardening and Performance Tuning Reference

performance

• Garbage collection
• Month 3 - Runtime and Performance: CPython Internals, GIL, GC, the Allocator
• Performance methodology
• Week 10 - Memory: Refcounts, Cyclic GC, the `pymalloc` Allocator
• Week 11 - The GIL, Free-Threaded Python, and the Concurrency Model
• Week 12 - The Optimization Ladder: Algorithm → Vectorize → Native → JIT
• Week 9 - The CPython VM: Objects, Bytecode, the Eval Loop

philosophy

• Prelude - The Philosophy Behind the Syllabus
• Prelude - The Philosophy Behind the Syllabus
• Prelude-The Philosophy Behind the Syllabus
• Prelude-The Philosophy Behind the Syllabus
• Prelude-The Philosophy Behind the Syllabus
• Prelude-The Shape of the Discipline
• Prelude-What Containers Actually Are
• Prelude-What Kubernetes Actually Is

pin

• Month 3-Concurrency and Async: Atomics, Lock-Free, Pin, Tokio, Smol
• Week 10 - Channels, Lock-Free Patterns, and `loom`
• Week 11 - Async Foundations: `Future`, `Pin`, `Unpin`, the State Machine
• Week 12 - Runtimes: Tokio Internals, Smol, Embassy
• Week 9 - Threading, Send, Sync, and the Memory Model

pip

• Build systems & toolchains

pipeline-parallel

• Month 4-Distributed Training: NCCL, DDP, FSDP, Tensor & Pipeline Parallelism, FP8
• Week 13 - Communication Primitives: NCCL, Allreduce, Topology
• Week 14 - Data Parallelism: DDP, ZeRO, FSDP
• Week 15 - Tensor Parallelism and Pipeline Parallelism
• Week 16 - Mixed Precision, FP8, Numerical Stability at Scale

platform

• Month 5-Platform Engineering and Day-2 Operations
• Week 17 - GitOps: ArgoCD and Flux
• Week 18 - IaC From Within K8s: Crossplane and Terraform
• Week 19 - HPA, VPA, KEDA: Autoscaling
• Week 20 - Admission Control: Webhooks, OPA Gatekeeper, Kyverno

plugin

• Month 4-Reflection, Code Generation, Plugins
• Week 13 - Reflection: `reflect`, Performance, and Discipline
• Week 14 - `go/ast`, `go/parser`, `go/types`: Static Analysis
• Week 15 - `go generate` and AST-Based Code Generation
• Week 16 - Plugins: `plugin`, `go-plugin`, gRPC-Based Extensions

pod-lifecycle

• Month 2-The Node: kubelet, CRI, kube-proxy, CSI, Devices
• Week 5 - Kubelet Internals
• Week 6 - CRI: kubelet ↔ Runtime
• Week 7 - kube-proxy, Services, and the Networking Dataplane
• Week 8 - CSI, Storage, and Device Plugins

pprof

• Appendix A-Production Hardening Reference

process

• Month 1-Kernel Foundations: Boot, Syscalls, VFS, Processes
• Week 1 - Boot, Init, Systemd
• Week 2 - Syscalls and the Kernel/Userspace Boundary
• Week 3 - The Virtual File System (VFS)
• Week 4 - Processes, Threads, and Signals

production

• Month 5 - Production & Distributed Systems (Weeks 17–20)
• Month 5-Production Architecture: Hexagonal, Zero-Copy I/O, Observability, Testing
• Month 5-Production-Grade Distributed Systems Engineering
• Week 17 - DDD in Go: Hexagonal Architecture, Bounded Contexts
• Week 17 - Hexagonal Architecture and Domain Modeling in Rust
• Week 17 - Spring Boot 3 and Quarkus
• Week 18 - Observability: Logs, Metrics, Traces
• Week 18 - Observability: `slog`, `pprof`, `trace`, OpenTelemetry
• Week 18 - Zero-Copy I/O and the Poll-Based Model
• Week 19 - Observability: tracing, metrics, OpenTelemetry
• Week 19 - Persistence, RPC, and Resilience
• Week 19 - gRPC: Streaming, Interceptors, Deadlines, Retries, Outlier Ejection
• Week 20 - Containers, Native Images, and Deployment
• Week 20 - Testing Strategy: Five Surfaces, Race-Clean
• Week 20 - Testing Strategy: Unit, Property, Fuzz, Miri, Integration

profiling

• Appendix A-Production Hardening Reference
• Month 3 - Runtime and Performance: CPython Internals, GIL, GC, the Allocator
• Observability
• Performance methodology
• Week 10 - Memory: Refcounts, Cyclic GC, the `pymalloc` Allocator
• Week 11 - The GIL, Free-Threaded Python, and the Concurrency Model
• Week 12 - The Optimization Ladder: Algorithm → Vectorize → Native → JIT
• Week 9 - The CPython VM: Objects, Bytecode, the Eval Loop

property-test

• Testing

protocol

• Month 2 - Intermediate Idioms: Decorators, Context Managers, Dataclasses, Typing
• Week 5 - Object Model Deep Dive: Classes, Descriptors, Metaclasses
• Week 6 - Decorators, `functools`, and `contextlib`
• Week 7 - Dataclasses, `attrs`, Pydantic, and the Validation Boundary
• Week 8 - The Type System: Generics, Protocols, Variance, and `typing.*`

protocols

• Type systems

ptx

• Month 2-GPU Programming: Architecture, CUDA, Memory, Triton
• Week 5 - GPU Hardware Architecture
• Week 6 - Your First CUDA Kernels
• Week 7 - Memory Optimization: Coalescing, Shared Memory, Tensor Cores
• Week 8 - Triton: GPU Kernels From Python

py-spy

• Appendix A - Production Hardening Toolkit

python

• Appendix A - Production Hardening Toolkit
• Appendix B - Build-From-Scratch Data Structures and Patterns
• Appendix C - Deep-Dive Session: CPython Internals and the AI Runtime Stack
• Capstone Projects - Three Tracks
• Month 1 - Foundations: The Data Model, Idioms, and Packaging
• Month 2 - Intermediate Idioms: Decorators, Context Managers, Dataclasses, Typing
• Month 3 - Runtime and Performance: CPython Internals, GIL, GC, the Allocator
• Month 4 - Concurrency and Parallelism: asyncio, Threads, Processes, Free-Threaded, Subinterpreters
• Month 5 - Patterns and Architecture: Pythonic Design, Testing, Observability, Service Shape
• Month 6 - AI Systems at a Senior Level: RAG, Agents, Evals, Training, Serving
• Prelude - The Philosophy Behind the Syllabus
• Python Mastery Blueprint - A 24-Week Beginner-to-Senior Syllabus (AI-Systems Track)
• Week 1 - Syntax, Values, Names, and the Data Model
• Week 10 - Memory: Refcounts, Cyclic GC, the `pymalloc` Allocator
• Week 11 - The GIL, Free-Threaded Python, and the Concurrency Model
• Week 12 - The Optimization Ladder: Algorithm → Vectorize → Native → JIT
• Week 13 - `asyncio` Foundations: Event Loop, Tasks, Coroutines
• Week 14 - Structured Concurrency, Cancellation, ExceptionGroups, `anyio`
• Week 15 - Threads, Processes, Subinterpreters, `concurrent.futures`
• Week 16 - Native Extensions, Releasing the GIL, FFI
• Week 17 - Pythonic Design Patterns
• Week 18 - Data Structures Beyond `list`/`dict`
• Week 19 - Testing, Property-Based Testing, Mutation Testing, Fakes vs. Mocks
• Week 2 - Control Flow, Functions, Errors, and the Call Model
• Week 20 - Observability, FastAPI, Production Service Shape
• Week 21 - LLM-App Foundations: Prompts, Tokens, Streaming, Cost
• Week 22 - Retrieval-Augmented Generation: Doing It Properly
• Week 23 - Agents, Tools, Durable Execution, Cost & Safety
• Week 24 - Training, Serving, Rollout, and the Capstone Defense
• Week 3 - Collections, Comprehensions, Iterators, and Generators
• Week 4 - Modules, Packaging, Virtual Environments, and the Import System
• Week 5 - Object Model Deep Dive: Classes, Descriptors, Metaclasses
• Week 6 - Decorators, `functools`, and `contextlib`
• Week 7 - Dataclasses, `attrs`, Pydantic, and the Validation Boundary
• Week 8 - The Type System: Generics, Protocols, Variance, and `typing.*`
• Week 9 - The CPython VM: Objects, Bytecode, the Eval Loop

python-from-scratch

• 00 - Introduction
• 01 - Setup
• 02 - First Real Program
• 03 - Decisions and Loops
• 04 - Functions
• 05 - Classes
• 06 - Collections
• 07 - Errors and Exceptions
• 08 - Iterators, Generators, Comprehensions
• 09 - Files and the Standard Library
• 10 - Tests
• 11 - Modules, Packages, pip, venv
• 12 - Reading Other People's Code
• 13 - Picking a Project to Contribute To
• 14 - Anatomy of a Small Python OSS Repo
• 15 - Your First Contribution
• Python From Scratch - Beginner to OSS Contributor

pytorch

• Appendix C-Contributing to the AI Systems Ecosystem
• Month 3-Framework Internals: PyTorch, torch.compile, JAX/XLA, Custom Ops
• Month 6 - AI Systems at a Senior Level: RAG, Agents, Evals, Training, Serving
• Week 10 - torch.compile, TorchDynamo, Inductor
• Week 11 - JAX, XLA, HLO
• Week 12 - Custom Operators: From CUDA Kernel to `torch.ops`
• Week 21 - LLM-App Foundations: Prompts, Tokens, Streaming, Cost
• Week 22 - Retrieval-Augmented Generation: Doing It Properly
• Week 23 - Agents, Tools, Durable Execution, Cost & Safety
• Week 24 - Training, Serving, Rollout, and the Capstone Defense
• Week 9 - PyTorch Internals: Tensor, Dispatcher, ATen

quantization

• Month 5-Inference Systems: KV-Cache, Paged Attention, Continuous Batching, Quantization, Speculative Decoding
• Week 17 - LLM Inference, the KV-Cache, Attention Math
• Week 18 - Paged Attention, Continuous Batching, vLLM
• Week 19 - Quantization: INT8, INT4, FP8, AWQ, GPTQ, SmoothQuant
• Week 20 - Speculative Decoding, Disaggregation, Inference Frontiers

quarkus

• Month 5 - Production & Distributed Systems (Weeks 17–20)
• Week 17 - Spring Boot 3 and Quarkus
• Week 18 - Observability: Logs, Metrics, Traces
• Week 19 - Persistence, RPC, and Resilience
• Week 20 - Containers, Native Images, and Deployment

race-detector

• Month 3-Concurrency Mastery: Channels, Atomics, Context, Patterns
• Week 10 - `sync` Primitives and `sync/atomic`
• Week 11 - `context.Context`, Cancellation, errgroup, singleflight
• Week 12 - Worker Pools, Leak Detection, Deadlock Prevention
• Week 9 - Channels, Deeply

raft

• Capstone Projects
• Capstone Projects-Three Tracks, One Choice
• Capstone Projects-Three Tracks, One Choice
• Distributed consensus
• Month 6 - Capstone (Weeks 21–24)
• Month 6-Mastery: Consensus, Distributed Storage, Performance Tuning, Defense
• Month 6-Mastery: Custom Data Structures, `no_std`, Compiler Internals, Capstone
• Week 21 - Consensus Algorithms: Raft (and a Glance at Paxos)
• Week 21 - Design and Foundation
• Week 21 - Implementing Complex Data Structures From Scratch
• Week 22 - Core Implementation
• Week 22 - Distributed Storage Patterns
• Week 22 - `no_std`, Custom Allocators, Embedded Targets
• Week 23 - Compiler Internals: MIR, Borrow Check, Codegen
• Week 23 - Failure, Observability, and Operations
• Week 23 - Performance Tuning: Profile, Tune, Re-Profile
• Week 24 - Capstone Integration, Defense, Final Hardening
• Week 24 - Capstone Integration, Profiling, Hardening, Defense
• Week 24 - Defense

reconcile-loop

• Month 3-Controllers and Operators: client-go, controller-runtime, CRDs
• Week 10 - `controller-runtime` and Kubebuilder
• Week 11 - CRDs: Schema, Versioning, Validation
• Week 12 - Operator Patterns: Finalizers, External Resources, Multi-Cluster
• Week 9 - `client-go` Internals and a Bare Controller

records

• Month 1 - Language & Toolchain (Weeks 1–4)
• Week 1 - Modern Syntax and the Type System
• Week 2 - Build Tools, Dependencies, and JPMS
• Week 3 - Collections, Streams, and `java.time`
• Week 4 - Testing, Logging, and the Definition-of-Done

recovery

• Error handling

reference

• Appendix B-Build-From-Scratch Reference
• Appendix B-Reference Patterns
• Beginner glossary
• Glossary

reflection

• Month 4-Reflection, Code Generation, Plugins
• Week 13 - Reflection: `reflect`, Performance, and Discipline
• Week 14 - `go/ast`, `go/parser`, `go/types`: Static Analysis
• Week 15 - `go generate` and AST-Based Code Generation
• Week 16 - Plugins: `plugin`, `go-plugin`, gRPC-Based Extensions

replication

• Distributed consensus

result

• Error handling

ringbuffer

• Appendix B-Build-From-Scratch Data Structures and Patterns

roadmap

• Deep Dives-Self-Contained Reference Chapters
• tutoriaal-companion learning material for AI_EXPERT_ROADMAP.md

rootless

• Month 4-Container Security
• Week 13 - The Default Threat Model
• Week 14 - Capabilities for Containers
• Week 15 - Seccomp Profiles for Containers
• Week 16 - LSM for Containers: SELinux and AppArmor

runc

• Month 3-Runtimes and Daemons: containerd, CRI-O, podman, Rootless
• Week 10 - CRI-O and the Kubernetes CRI
• Week 11 - `podman` and the Rootless Model
• Week 12 - Sandboxed Runtimes: gVisor and Kata Containers
• Week 9 - `containerd` Architecture

runtime

• Appendix C-Contributing to Go: A Playbook
• Async models
• Capstone Projects-Three Tracks, One Choice
• Garbage collection
• Month 1-Runtime Foundations: Toolchain, GMP, Stacks, Escape Analysis
• Month 3 - Runtime and Performance: CPython Internals, GIL, GC, the Allocator
• Month 3-Runtimes and Daemons: containerd, CRI-O, podman, Rootless
• Month 6-Build Your Own: Mini-Docker From Scratch
• Week 1 - The Toolchain and the Build Pipeline
• Week 10 - CRI-O and the Kubernetes CRI
• Week 10 - Memory: Refcounts, Cyclic GC, the `pymalloc` Allocator
• Week 11 - The GIL, Free-Threaded Python, and the Concurrency Model
• Week 11 - `podman` and the Rootless Model
• Week 12 - Sandboxed Runtimes: gVisor and Kata Containers
• Week 12 - The Optimization Ladder: Algorithm → Vectorize → Native → JIT
• Week 2 - The GMP Scheduler Model
• Week 21 - Scaffolding: Project Setup, OCI Bundle Reading
• Week 22 - Namespaces and Process Isolation
• Week 23 - Cgroups v2, Capabilities, Seccomp, OverlayFS
• Week 24 - Polish, Defense, Distribution
• Week 3 - Stack Management
• Week 4 - Escape Analysis and the Inliner
• Week 9 - The CPython VM: Objects, Bytecode, the Eval Loop
• Week 9 - `containerd` Architecture

runtime-spec

• Month 1-OCI Foundations: Specs, runc, skopeo, crun
• Week 1 - The OCI Image Spec
• Week 2 - The OCI Runtime Spec, `runc`, and `crun`
• Week 3 - `skopeo` Deep Dive: Multi-Arch, Signing, Sync
• Week 4 - Image Internals: Manifest Lists, Index, Annotations, Sparse Pulls

rust

• Appendix A-Production Hardening Reference
• Appendix B-Build-From-Scratch Data Structures Reference
• Appendix C-Contributing to `rustc`: A Playbook
• Capstone Projects-Three Tracks, One Choice
• Month 1-Foundations: Toolchain, Memory Layout, Ownership, Errors
• Month 2-The Type System: Lifetimes, Traits, Smart Pointers, Drop
• Month 3-Concurrency and Async: Atomics, Lock-Free, Pin, Tokio, Smol
• Month 4-Unsafe Rust, FFI, and Macros
• Month 5-Production Architecture: Hexagonal, Zero-Copy I/O, Observability, Testing
• Month 6-Mastery: Custom Data Structures, `no_std`, Compiler Internals, Capstone
• Prelude-The Philosophy Behind the Syllabus
• Rust Mastery Blueprint-A 24-Week Master-Level Syllabus
• Week 1 - The Toolchain and the Compiler Pipeline
• Week 10 - Channels, Lock-Free Patterns, and `loom`
• Week 11 - Async Foundations: `Future`, `Pin`, `Unpin`, the State Machine
• Week 12 - Runtimes: Tokio Internals, Smol, Embassy
• Week 13 - Unsafe Rust: Raw Pointers, NonNull, MaybeUninit, UB
• Week 14 - FFI: Calling C, Being Called By C
• Week 15 - Declarative Macros (`macro_rules!`)
• Week 16 - Procedural Macros
• Week 17 - Hexagonal Architecture and Domain Modeling in Rust
• Week 18 - Zero-Copy I/O and the Poll-Based Model
• Week 19 - Observability: tracing, metrics, OpenTelemetry
• Week 2 - Memory Layout: Stack, Heap, Data, BSS, TLS
• Week 20 - Testing Strategy: Unit, Property, Fuzz, Miri, Integration
• Week 21 - Implementing Complex Data Structures From Scratch
• Week 22 - `no_std`, Custom Allocators, Embedded Targets
• Week 23 - Compiler Internals: MIR, Borrow Check, Codegen
• Week 24 - Capstone Integration, Profiling, Hardening, Defense
• Week 3 - Ownership, Borrowing, and Region Inference
• Week 4 - The Error Model
• Week 5 - Advanced Lifetimes, Variance, and HRTBs
• Week 6 - Traits, Coherence, and Monomorphization
• Week 7 - Smart Pointers and Interior Mutability
• Week 8 - Drop, the Drop Checker, and Destructor Discipline
• Week 9 - Threading, Send, Sync, and the Memory Model

rust-from-scratch

• 00 - Introduction
• 01 - Setup
• 02 - First Real Program
• 03 - Decisions and Loops
• 04 - Functions
• 05 - Structs and Enums
• 06 - Ownership and Borrowing
• 07 - Collections
• 08 - Error Handling
• 09 - Traits and Generics
• 10 - Tests
• 11 - Crates and Cargo
• 12 - Reading Other People's Code
• 13 - Picking a Project
• 14 - Anatomy of a Rust OSS Repo
• 15 - Your First Contribution
• Rust From Scratch - Beginner to OSS Contributor

rustc

• Appendix C-Contributing to `rustc`: A Playbook

sbom

• Month 5-Container Supply Chain: SBOM, Vulnerability Scanning, Signing, SLSA
• Week 17 - Software Bill of Materials (SBOM)
• Week 18 - Vulnerability Scanning: Grype, Trivy, Clair
• Week 19 - Signing and Verification: Cosign, Sigstore
• Week 20 - SLSA, Provenance, and Reproducibility

scalene

• Appendix A - Production Hardening Toolkit

scheduler

• Month 1-Runtime Foundations: Toolchain, GMP, Stacks, Escape Analysis
• Month 1-The Control Plane: etcd, kube-apiserver, scheduler, controllers
• Month 2-Memory Management and Scheduling
• Week 1 - The Toolchain and the Build Pipeline
• Week 1 - etcd and the Raft Consensus Foundation
• Week 2 - The GMP Scheduler Model
• Week 2 - The kube-apiserver
• Week 3 - Stack Management
• Week 3 - The Scheduler
• Week 4 - Built-in Controllers and `client-go` Foundations
• Week 4 - Escape Analysis and the Inliner
• Week 5 - Virtual Memory, Paging, and the Page Cache
• Week 6 - Swapping, OOM, Memory Pressure (PSI)
• Week 7 - The CPU Scheduler (CFS, EEVDF)
• Week 8 - Disk I/O Scheduling, Filesystems Beyond ext4

scoped-values

• Month 4 - Concurrency & Project Loom (Weeks 13–16)
• Week 13 - The Java Memory Model and `java.util.concurrent` Foundations
• Week 14 - Executors, `CompletableFuture`, and the Pre-Loom World
• Week 15 - Virtual Threads, Structured Concurrency, and Scoped Values
• Week 16 - Lock-Free Patterns, `VarHandle` Memory Modes, and `jcstress`

scratch

• Appendix B-Build-From-Scratch Reference

sealed-classes

• Month 1 - Language & Toolchain (Weeks 1–4)
• Week 1 - Modern Syntax and the Type System
• Week 2 - Build Tools, Dependencies, and JPMS
• Week 3 - Collections, Streams, and `java.time`
• Week 4 - Testing, Logging, and the Definition-of-Done

seccomp

• Month 4-Container Security
• Month 5-Security and Hardening
• Week 13 - The Default Threat Model
• Week 14 - Capabilities for Containers
• Week 15 - Seccomp Profiles for Containers
• Week 16 - LSM for Containers: SELinux and AppArmor
• Week 17 - Discretionary and Mandatory Access Control
• Week 18 - Capabilities, Seccomp, no_new_privs
• Week 19 - Encryption at Rest: LUKS, dm-crypt, dm-verity
• Week 20 - Audit, Integrity Measurement, and Compliance

security

• Appendix A-Container Hardening Reference
• Appendix A-Kubernetes Hardening Reference
• Month 4-Container Security
• Month 5-Security and Hardening
• Week 13 - The Default Threat Model
• Week 14 - Capabilities for Containers
• Week 15 - Seccomp Profiles for Containers
• Week 16 - LSM for Containers: SELinux and AppArmor
• Week 17 - Discretionary and Mandatory Access Control
• Week 18 - Capabilities, Seccomp, no_new_privs
• Week 19 - Encryption at Rest: LUKS, dm-crypt, dm-verity
• Week 20 - Audit, Integrity Measurement, and Compliance

selinux

• Month 5-Security and Hardening
• Week 17 - Discretionary and Mandatory Access Control
• Week 18 - Capabilities, Seccomp, no_new_privs
• Week 19 - Encryption at Rest: LUKS, dm-crypt, dm-verity
• Week 20 - Audit, Integrity Measurement, and Compliance

send

• Month 3-Concurrency and Async: Atomics, Lock-Free, Pin, Tokio, Smol
• Week 10 - Channels, Lock-Free Patterns, and `loom`
• Week 11 - Async Foundations: `Future`, `Pin`, `Unpin`, the State Machine
• Week 12 - Runtimes: Tokio Internals, Smol, Embassy
• Week 9 - Threading, Send, Sync, and the Memory Model

service

• Month 4-Networking and Storage at Scale
• Week 13 - The CNI Spec and Pod Networking
• Week 14 - Cilium and eBPF Networking
• Week 15 - Service Meshes: Istio, Linkerd, Cilium Service Mesh
• Week 16 - CSI at Scale: Snapshots, Backup, Cloning

shenandoah

• Month 3 - Memory & Garbage Collection (Weeks 9–12)
• Week 10 - The Generational Hypothesis and the Modern GCs
• Week 11 - Heap Sizing, GOMEMLIMIT-Equivalents, and Container Awareness
• Week 12 - JFR, Heap Dumps, and Allocation Profiling
• Week 9 - Object Layout, Headers, and Cache Effects

sigs

• Appendix C-Contributing to Kubernetes

sigstore

• Month 5-Container Supply Chain: SBOM, Vulnerability Scanning, Signing, SLSA
• Week 17 - Software Bill of Materials (SBOM)
• Week 18 - Vulnerability Scanning: Grype, Trivy, Clair
• Week 19 - Signing and Verification: Cosign, Sigstore
• Week 20 - SLSA, Provenance, and Reproducibility

skara

• Appendix C - Contributing to OpenJDK

slab

• Month 2-Memory Management and Scheduling
• Week 5 - Virtual Memory, Paging, and the Page Cache
• Week 6 - Swapping, OOM, Memory Pressure (PSI)
• Week 7 - The CPU Scheduler (CFS, EEVDF)
• Week 8 - Disk I/O Scheduling, Filesystems Beyond ext4

slsa

• Month 5-Container Supply Chain: SBOM, Vulnerability Scanning, Signing, SLSA
• Week 17 - Software Bill of Materials (SBOM)
• Week 18 - Vulnerability Scanning: Grype, Trivy, Clair
• Week 19 - Signing and Verification: Cosign, Sigstore
• Week 20 - SLSA, Provenance, and Reproducibility

sockets

• Month 4-Linux Networking: Netfilter, IPVS, XDP, Bridges, OVS
• Networking
• Week 13 - The Network Stack: Sockets, NAPI, conntrack
• Week 14 - Netfilter / nftables / iptables, IPVS
• Week 15 - XDP and AF_XDP
• Week 16 - Bridges, VLANs, OVS

speculative-decoding

• Month 5-Inference Systems: KV-Cache, Paged Attention, Continuous Batching, Quantization, Speculative Decoding
• Week 17 - LLM Inference, the KV-Cache, Attention Math
• Week 18 - Paged Attention, Continuous Batching, vLLM
• Week 19 - Quantization: INT8, INT4, FP8, AWQ, GPTQ, SmoothQuant
• Week 20 - Speculative Decoding, Disaggregation, Inference Frontiers

spring-boot

• Month 5 - Production & Distributed Systems (Weeks 17–20)
• Week 17 - Spring Boot 3 and Quarkus
• Week 18 - Observability: Logs, Metrics, Traces
• Week 19 - Persistence, RPC, and Resilience
• Week 20 - Containers, Native Images, and Deployment

sre

• Month 5-Platform Engineering and Day-2 Operations
• Observability
• Week 17 - GitOps: ArgoCD and Flux
• Week 18 - IaC From Within K8s: Crossplane and Terraform
• Week 19 - HPA, VPA, KEDA: Autoscaling
• Week 20 - Admission Control: Webhooks, OPA Gatekeeper, Kyverno

streaming

• Capstone Projects
• Capstone Projects-Three Tracks, One Choice
• Capstone Projects-Three Tracks, One Choice
• Month 6 - Capstone (Weeks 21–24)
• Week 21 - Design and Foundation
• Week 22 - Core Implementation
• Week 23 - Failure, Observability, and Operations
• Week 24 - Defense

structured-concurrency

• Month 4 - Concurrency & Project Loom (Weeks 13–16)
• Week 13 - The Java Memory Model and `java.util.concurrent` Foundations
• Week 14 - Executors, `CompletableFuture`, and the Pre-Loom World
• Week 15 - Virtual Threads, Structured Concurrency, and Scoped Values
• Week 16 - Lock-Free Patterns, `VarHandle` Memory Modes, and `jcstress`

supply-chain

• Month 5-Container Supply Chain: SBOM, Vulnerability Scanning, Signing, SLSA
• Week 17 - Software Bill of Materials (SBOM)
• Week 18 - Vulnerability Scanning: Grype, Trivy, Clair
• Week 19 - Signing and Verification: Cosign, Sigstore
• Week 20 - SLSA, Provenance, and Reproducibility

syllabus

• AI Systems Engineering-A 24-Week Beginner-to-Advanced Mastery Roadmap
• Container Internals & Runtimes-A 24-Week Mastery Roadmap
• Deep Dives-Self-Contained Reference Chapters
• Go Mastery Blueprint-A 24-Week Master-Level Syllabus
• Java Mastery Blueprint - A 24-Week Master-Level Syllabus
• Kubernetes Platform Engineering-A 24-Week Mastery Roadmap
• Linux Systems & Kernel Engineering-A 24-Week Mastery Roadmap
• Python Mastery Blueprint - A 24-Week Beginner-to-Senior Syllabus (AI-Systems Track)
• Rust Mastery Blueprint-A 24-Week Master-Level Syllabus

sync

• Month 3-Concurrency and Async: Atomics, Lock-Free, Pin, Tokio, Smol
• Week 10 - Channels, Lock-Free Patterns, and `loom`
• Week 11 - Async Foundations: `Future`, `Pin`, `Unpin`, the State Machine
• Week 12 - Runtimes: Tokio Internals, Smol, Embassy
• Week 9 - Threading, Send, Sync, and the Memory Model

sysadmin

• Appendix B-Build-From-Scratch Linux Toolbox

syscall

• Month 1-Kernel Foundations: Boot, Syscalls, VFS, Processes
• Week 1 - Boot, Init, Systemd
• Week 2 - Syscalls and the Kernel/Userspace Boundary
• Week 3 - The Virtual File System (VFS)
• Week 4 - Processes, Threads, and Signals

tcp

• Month 4-Linux Networking: Netfilter, IPVS, XDP, Bridges, OVS
• Networking
• Week 13 - The Network Stack: Sockets, NAPI, conntrack
• Week 14 - Netfilter / nftables / iptables, IPVS
• Week 15 - XDP and AF_XDP
• Week 16 - Bridges, VLANs, OVS

tensor-core

• Month 2-GPU Programming: Architecture, CUDA, Memory, Triton
• Week 5 - GPU Hardware Architecture
• Week 6 - Your First CUDA Kernels
• Week 7 - Memory Optimization: Coalescing, Shared Memory, Tensor Cores
• Week 8 - Triton: GPU Kernels From Python

testing

• Month 5 - Patterns and Architecture: Pythonic Design, Testing, Observability, Service Shape
• Month 5-Production-Grade Distributed Systems Engineering
• Testing
• Week 17 - DDD in Go: Hexagonal Architecture, Bounded Contexts
• Week 17 - Pythonic Design Patterns
• Week 18 - Data Structures Beyond `list`/`dict`
• Week 18 - Observability: `slog`, `pprof`, `trace`, OpenTelemetry
• Week 19 - Testing, Property-Based Testing, Mutation Testing, Fakes vs. Mocks
• Week 19 - gRPC: Streaming, Interceptors, Deadlines, Retries, Outlier Ejection
• Week 20 - Observability, FastAPI, Production Service Shape
• Week 20 - Testing Strategy: Five Surfaces, Race-Clean

threads

• Concurrency

tokio

• Async models
• Month 3-Concurrency and Async: Atomics, Lock-Free, Pin, Tokio, Smol
• Week 10 - Channels, Lock-Free Patterns, and `loom`
• Week 11 - Async Foundations: `Future`, `Pin`, `Unpin`, the State Machine
• Week 12 - Runtimes: Tokio Internals, Smol, Embassy
• Week 9 - Threading, Send, Sync, and the Memory Model

toolbox

• Appendix B-Build-From-Scratch Linux Toolbox

toolchain

• Build systems & toolchains
• Month 1-Runtime Foundations: Toolchain, GMP, Stacks, Escape Analysis
• Week 1 - The Toolchain and the Build Pipeline
• Week 2 - The GMP Scheduler Model
• Week 3 - Stack Management
• Week 4 - Escape Analysis and the Inliner

tools

• Appendix B-Build-From-Scratch Linux Toolbox

trace

• Appendix A-Production Hardening Reference

tracing

• Appendix A-Production Hardening Reference
• Month 5-Production Architecture: Hexagonal, Zero-Copy I/O, Observability, Testing
• Observability
• Week 17 - Hexagonal Architecture and Domain Modeling in Rust
• Week 18 - Zero-Copy I/O and the Poll-Based Model
• Week 19 - Observability: tracing, metrics, OpenTelemetry
• Week 20 - Testing Strategy: Unit, Property, Fuzz, Miri, Integration

traits

• Month 2-The Type System: Lifetimes, Traits, Smart Pointers, Drop
• Type systems
• Week 5 - Advanced Lifetimes, Variance, and HRTBs
• Week 6 - Traits, Coherence, and Monomorphization
• Week 7 - Smart Pointers and Interior Mutability
• Week 8 - Drop, the Drop Checker, and Destructor Discipline

tricolor

• Month 2-Memory, the Garbage Collector, and Interface Internals
• Week 5 - Memory Layout, Padding, Alignment
• Week 6 - The Garbage Collector
• Week 7 - Interface Values, itabs, and Dispatch Cost
• Week 8 - Allocation Profiling, `sync.Pool`, GC Tuning

triton

• Month 2-GPU Programming: Architecture, CUDA, Memory, Triton
• Week 5 - GPU Hardware Architecture
• Week 6 - Your First CUDA Kernels
• Week 7 - Memory Optimization: Coalescing, Shared Memory, Tensor Cores
• Week 8 - Triton: GPU Kernels From Python

troubleshooting

• Appendix B-Troubleshooting Reference Flows

tuning

• Appendix A-Hardening and Performance Tuning Reference

type-checking

• Type systems

type-system

• Month 2-The Type System: Lifetimes, Traits, Smart Pointers, Drop
• Week 5 - Advanced Lifetimes, Variance, and HRTBs
• Week 6 - Traits, Coherence, and Monomorphization
• Week 7 - Smart Pointers and Interior Mutability
• Week 8 - Drop, the Drop Checker, and Destructor Discipline

types

• Type systems

typing

• Month 1 - Foundations: The Data Model, Idioms, and Packaging
• Week 1 - Syntax, Values, Names, and the Data Model
• Week 2 - Control Flow, Functions, Errors, and the Call Model
• Week 3 - Collections, Comprehensions, Iterators, and Generators
• Week 4 - Modules, Packaging, Virtual Environments, and the Import System

unit-test

• Testing

unsafe

• Month 4-Unsafe Rust, FFI, and Macros
• Week 13 - Unsafe Rust: Raw Pointers, NonNull, MaybeUninit, UB
• Week 14 - FFI: Calling C, Being Called By C
• Week 15 - Declarative Macros (`macro_rules!`)
• Week 16 - Procedural Macros

upgrade

• Month 5-Platform Engineering and Day-2 Operations
• Week 17 - GitOps: ArgoCD and Flux
• Week 18 - IaC From Within K8s: Crossplane and Terraform
• Week 19 - HPA, VPA, KEDA: Autoscaling
• Week 20 - Admission Control: Webhooks, OPA Gatekeeper, Kyverno

varhandle

• Month 2 - JVM & Bytecode (Weeks 5–8)
• Week 5 - Class Loading and Bytecode
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 8 - JMH and Microbenchmarking

vector

• Appendix B - The Legacy Java Field Guide

virtual-thread

• Month 4 - Concurrency & Project Loom (Weeks 13–16)
• Week 13 - The Java Memory Model and `java.util.concurrent` Foundations
• Week 14 - Executors, `CompletableFuture`, and the Pre-Loom World
• Week 15 - Virtual Threads, Structured Concurrency, and Scoped Values
• Week 16 - Lock-Free Patterns, `VarHandle` Memory Modes, and `jcstress`

vllm

• Appendix C-Contributing to the AI Systems Ecosystem
• Month 5-Inference Systems: KV-Cache, Paged Attention, Continuous Batching, Quantization, Speculative Decoding
• Week 17 - LLM Inference, the KV-Cache, Attention Math
• Week 18 - Paged Attention, Continuous Batching, vLLM
• Week 19 - Quantization: INT8, INT4, FP8, AWQ, GPTQ, SmoothQuant
• Week 20 - Speculative Decoding, Disaggregation, Inference Frontiers

week-1

• Week 1 - Boot, Init, Systemd
• Week 1 - Modern Syntax and the Type System
• Week 1 - Syntax, Values, Names, and the Data Model
• Week 1 - The Compute Hierarchy and the Cost Model
• Week 1 - The OCI Image Spec
• Week 1 - The Toolchain and the Build Pipeline
• Week 1 - The Toolchain and the Compiler Pipeline
• Week 1 - etcd and the Raft Consensus Foundation

week-10

• Week 10 - CRI-O and the Kubernetes CRI
• Week 10 - Channels, Lock-Free Patterns, and `loom`
• Week 10 - Control Groups v2
• Week 10 - Memory: Refcounts, Cyclic GC, the `pymalloc` Allocator
• Week 10 - The Generational Hypothesis and the Modern GCs
• Week 10 - `controller-runtime` and Kubebuilder
• Week 10 - `sync` Primitives and `sync/atomic`
• Week 10 - torch.compile, TorchDynamo, Inductor

week-11

• Week 11 - Async Foundations: `Future`, `Pin`, `Unpin`, the State Machine
• Week 11 - CRDs: Schema, Versioning, Validation
• Week 11 - Heap Sizing, GOMEMLIMIT-Equivalents, and Container Awareness
• Week 11 - JAX, XLA, HLO
• Week 11 - The GIL, Free-Threaded Python, and the Concurrency Model
• Week 11 - `context.Context`, Cancellation, errgroup, singleflight
• Week 11 - `podman` and the Rootless Model
• Week 11 - eBPF: Foundations

week-12

• Week 12 - Custom Operators: From CUDA Kernel to `torch.ops`
• Week 12 - JFR, Heap Dumps, and Allocation Profiling
• Week 12 - Operator Patterns: Finalizers, External Resources, Multi-Cluster
• Week 12 - Runtimes: Tokio Internals, Smol, Embassy
• Week 12 - Sandboxed Runtimes: gVisor and Kata Containers
• Week 12 - The Optimization Ladder: Algorithm → Vectorize → Native → JIT
• Week 12 - Worker Pools, Leak Detection, Deadlock Prevention
• Week 12 - eBPF in Production: Observability Tools

week-13

• Week 13 - Communication Primitives: NCCL, Allreduce, Topology
• Week 13 - Reflection: `reflect`, Performance, and Discipline
• Week 13 - The CNI Spec and Pod Networking
• Week 13 - The Default Threat Model
• Week 13 - The Java Memory Model and `java.util.concurrent` Foundations
• Week 13 - The Network Stack: Sockets, NAPI, conntrack
• Week 13 - Unsafe Rust: Raw Pointers, NonNull, MaybeUninit, UB
• Week 13 - `asyncio` Foundations: Event Loop, Tasks, Coroutines

week-14

• Week 14 - Capabilities for Containers
• Week 14 - Cilium and eBPF Networking
• Week 14 - Data Parallelism: DDP, ZeRO, FSDP
• Week 14 - Executors, `CompletableFuture`, and the Pre-Loom World
• Week 14 - FFI: Calling C, Being Called By C
• Week 14 - Netfilter / nftables / iptables, IPVS
• Week 14 - Structured Concurrency, Cancellation, ExceptionGroups, `anyio`
• Week 14 - `go/ast`, `go/parser`, `go/types`: Static Analysis

week-15

• Week 15 - Declarative Macros (`macro_rules!`)
• Week 15 - Seccomp Profiles for Containers
• Week 15 - Service Meshes: Istio, Linkerd, Cilium Service Mesh
• Week 15 - Tensor Parallelism and Pipeline Parallelism
• Week 15 - Threads, Processes, Subinterpreters, `concurrent.futures`
• Week 15 - Virtual Threads, Structured Concurrency, and Scoped Values
• Week 15 - XDP and AF_XDP
• Week 15 - `go generate` and AST-Based Code Generation

week-16

• Week 16 - Bridges, VLANs, OVS
• Week 16 - CSI at Scale: Snapshots, Backup, Cloning
• Week 16 - LSM for Containers: SELinux and AppArmor
• Week 16 - Lock-Free Patterns, `VarHandle` Memory Modes, and `jcstress`
• Week 16 - Mixed Precision, FP8, Numerical Stability at Scale
• Week 16 - Native Extensions, Releasing the GIL, FFI
• Week 16 - Plugins: `plugin`, `go-plugin`, gRPC-Based Extensions
• Week 16 - Procedural Macros

week-17

• Week 17 - DDD in Go: Hexagonal Architecture, Bounded Contexts
• Week 17 - Discretionary and Mandatory Access Control
• Week 17 - GitOps: ArgoCD and Flux
• Week 17 - Hexagonal Architecture and Domain Modeling in Rust
• Week 17 - LLM Inference, the KV-Cache, Attention Math
• Week 17 - Pythonic Design Patterns
• Week 17 - Software Bill of Materials (SBOM)
• Week 17 - Spring Boot 3 and Quarkus

week-18

• Week 18 - Capabilities, Seccomp, no_new_privs
• Week 18 - Data Structures Beyond `list`/`dict`
• Week 18 - IaC From Within K8s: Crossplane and Terraform
• Week 18 - Observability: Logs, Metrics, Traces
• Week 18 - Observability: `slog`, `pprof`, `trace`, OpenTelemetry
• Week 18 - Paged Attention, Continuous Batching, vLLM
• Week 18 - Vulnerability Scanning: Grype, Trivy, Clair
• Week 18 - Zero-Copy I/O and the Poll-Based Model

week-19

• Week 19 - Encryption at Rest: LUKS, dm-crypt, dm-verity
• Week 19 - HPA, VPA, KEDA: Autoscaling
• Week 19 - Observability: tracing, metrics, OpenTelemetry
• Week 19 - Persistence, RPC, and Resilience
• Week 19 - Quantization: INT8, INT4, FP8, AWQ, GPTQ, SmoothQuant
• Week 19 - Signing and Verification: Cosign, Sigstore
• Week 19 - Testing, Property-Based Testing, Mutation Testing, Fakes vs. Mocks
• Week 19 - gRPC: Streaming, Interceptors, Deadlines, Retries, Outlier Ejection

week-2

• Week 2 - Build Tools, Dependencies, and JPMS
• Week 2 - Control Flow, Functions, Errors, and the Call Model
• Week 2 - Linear Algebra Refresh, BLAS, NumPy
• Week 2 - Memory Layout: Stack, Heap, Data, BSS, TLS
• Week 2 - Syscalls and the Kernel/Userspace Boundary
• Week 2 - The GMP Scheduler Model
• Week 2 - The OCI Runtime Spec, `runc`, and `crun`
• Week 2 - The kube-apiserver

week-20

• Week 20 - Admission Control: Webhooks, OPA Gatekeeper, Kyverno
• Week 20 - Audit, Integrity Measurement, and Compliance
• Week 20 - Containers, Native Images, and Deployment
• Week 20 - Observability, FastAPI, Production Service Shape
• Week 20 - SLSA, Provenance, and Reproducibility
• Week 20 - Speculative Decoding, Disaggregation, Inference Frontiers
• Week 20 - Testing Strategy: Five Surfaces, Race-Clean
• Week 20 - Testing Strategy: Unit, Property, Fuzz, Miri, Integration

week-21

• Week 21 - Bootstrap: VMs, Certificates, etcd
• Week 21 - Consensus Algorithms: Raft (and a Glance at Paxos)
• Week 21 - Design and Foundation
• Week 21 - Implementing Complex Data Structures From Scratch
• Week 21 - LLM-App Foundations: Prompts, Tokens, Streaming, Cost
• Week 21 - Loadable Kernel Modules (LKM)
• Week 21 - ML on Kubernetes: KServe, KubeRay, Volcano, GPU Operators
• Week 21 - Scaffolding: Project Setup, OCI Bundle Reading

week-22

• Week 22 - Control Plane and Worker Nodes
• Week 22 - Core Implementation
• Week 22 - Distributed Storage Patterns
• Week 22 - Namespaces and Process Isolation
• Week 22 - Observability, Cost, Eval Pipelines, MLOps
• Week 22 - Retrieval-Augmented Generation: Doing It Properly
• Week 22 - Tracing and Performance Mastery: ftrace, perf, BPF
• Week 22 - `no_std`, Custom Allocators, Embedded Targets

week-23

• Week 23 - Agents, Tools, Durable Execution, Cost & Safety
• Week 23 - Cgroups v2, Capabilities, Seccomp, OverlayFS
• Week 23 - Compiler Internals: MIR, Borrow Check, Codegen
• Week 23 - Failure, Observability, and Operations
• Week 23 - Performance Tuning at Scale
• Week 23 - Performance Tuning: Profile, Tune, Re-Profile
• Week 23 - RBAC, Multi-Tenancy, mTLS Everywhere
• Week 23 - Safety, Red-Teaming, Alignment Infrastructure

week-24

• Week 24 - Capstone Integration & Defense
• Week 24 - Capstone Integration & Defense
• Week 24 - Capstone Integration, Defense, Final Hardening
• Week 24 - Capstone Integration, Profiling, Hardening, Defense
• Week 24 - Defense
• Week 24 - Defense, Documentation, and the Capstone Demo
• Week 24 - Polish, Defense, Distribution
• Week 24 - Training, Serving, Rollout, and the Capstone Defense

week-3

• Week 3 - Collections, Comprehensions, Iterators, and Generators
• Week 3 - Collections, Streams, and `java.time`
• Week 3 - Ownership, Borrowing, and Region Inference
• Week 3 - Stack Management
• Week 3 - Tensors, Autograd, the Gradient Tape
• Week 3 - The Scheduler
• Week 3 - The Virtual File System (VFS)
• Week 3 - `skopeo` Deep Dive: Multi-Arch, Signing, Sync

week-4

• Week 4 - Built-in Controllers and `client-go` Foundations
• Week 4 - Escape Analysis and the Inliner
• Week 4 - Image Internals: Manifest Lists, Index, Annotations, Sparse Pulls
• Week 4 - Modules, Packaging, Virtual Environments, and the Import System
• Week 4 - Processes, Threads, and Signals
• Week 4 - Testing, Logging, and the Definition-of-Done
• Week 4 - The Error Model
• Week 4 - The Honest Training Loop

week-5

• Week 5 - Advanced Lifetimes, Variance, and HRTBs
• Week 5 - Class Loading and Bytecode
• Week 5 - GPU Hardware Architecture
• Week 5 - Kubelet Internals
• Week 5 - Memory Layout, Padding, Alignment
• Week 5 - Object Model Deep Dive: Classes, Descriptors, Metaclasses
• Week 5 - OverlayFS and Storage Drivers
• Week 5 - Virtual Memory, Paging, and the Page Cache

week-6

• Week 6 - CRI: kubelet ↔ Runtime
• Week 6 - Decorators, `functools`, and `contextlib`
• Week 6 - Swapping, OOM, Memory Pressure (PSI)
• Week 6 - The Garbage Collector
• Week 6 - The JIT: C1, C2, Graal, Tiered Compilation
• Week 6 - Traits, Coherence, and Monomorphization
• Week 6 - Your First CUDA Kernels
• Week 6 - `buildah`: Building Images Without Dockerfiles

week-7

• Week 7 - Dataclasses, `attrs`, Pydantic, and the Validation Boundary
• Week 7 - Interface Values, itabs, and Dispatch Cost
• Week 7 - Memory Optimization: Coalescing, Shared Memory, Tensor Cores
• Week 7 - Method Handles, VarHandles, and Reflection
• Week 7 - Multi-Stage Builds, Distroless, Minimal Images
• Week 7 - Smart Pointers and Interior Mutability
• Week 7 - The CPU Scheduler (CFS, EEVDF)
• Week 7 - kube-proxy, Services, and the Networking Dataplane

week-8

• Week 8 - Allocation Profiling, `sync.Pool`, GC Tuning
• Week 8 - CSI, Storage, and Device Plugins
• Week 8 - Disk I/O Scheduling, Filesystems Beyond ext4
• Week 8 - Drop, the Drop Checker, and Destructor Discipline
• Week 8 - JMH and Microbenchmarking
• Week 8 - Layer Caching, Build Context, Reproducibility
• Week 8 - The Type System: Generics, Protocols, Variance, and `typing.*`
• Week 8 - Triton: GPU Kernels From Python

week-9

• Week 9 - Channels, Deeply
• Week 9 - Namespaces
• Week 9 - Object Layout, Headers, and Cache Effects
• Week 9 - PyTorch Internals: Tensor, Dispatcher, ATen
• Week 9 - The CPython VM: Objects, Bytecode, the Eval Loop
• Week 9 - Threading, Send, Sync, and the Memory Model
• Week 9 - `client-go` Internals and a Bare Controller
• Week 9 - `containerd` Architecture

xdp

• Month 4-Linux Networking: Netfilter, IPVS, XDP, Bridges, OVS
• Week 13 - The Network Stack: Sockets, NAPI, conntrack
• Week 14 - Netfilter / nftables / iptables, IPVS
• Week 15 - XDP and AF_XDP
• Week 16 - Bridges, VLANs, OVS

xla

• Month 3-Framework Internals: PyTorch, torch.compile, JAX/XLA, Custom Ops
• Week 10 - torch.compile, TorchDynamo, Inductor
• Week 11 - JAX, XLA, HLO
• Week 12 - Custom Operators: From CUDA Kernel to `torch.ops`
• Week 9 - PyTorch Internals: Tensor, Dispatcher, ATen

zero

• Month 4-Distributed Training: NCCL, DDP, FSDP, Tensor & Pipeline Parallelism, FP8
• Week 13 - Communication Primitives: NCCL, Allreduce, Topology
• Week 14 - Data Parallelism: DDP, ZeRO, FSDP
• Week 15 - Tensor Parallelism and Pipeline Parallelism
• Week 16 - Mixed Precision, FP8, Numerical Stability at Scale

zgc

• Month 3 - Memory & Garbage Collection (Weeks 9–12)
• Week 10 - The Generational Hypothesis and the Modern GCs
• Week 11 - Heap Sizing, GOMEMLIMIT-Equivalents, and Container Awareness
• Week 12 - JFR, Heap Dumps, and Allocation Profiling
• Week 9 - Object Layout, Headers, and Cache Effects