Contents

Part 0 — Start here

• 0.1 Who this is for
• 0.2 The learning flow
• 0.3 Build your lab (a free, disposable Linux box)
• 0.4 The little computer-science you need
• 0.5 How to read a manifest/command you've never seen
• 0.6 How not to get stuck
• 0.7 The series: OS → networking → security → HTTPS
• 0.8 The Go labs: the OS from inside a program

PHASE 1 — Operating system concepts, in depth

Part 1 — What an operating system actually does

1. The OS as a resource manager and a liar (abstraction)
2. Kernel space vs. user space, and the system call
3. A program's whole life, from ./app to exit code

Part 2 — Processes, threads, and the CPU 4. What a process actually is 5. Process states and the process lifecycle 6. fork() and exec(): how new processes are born 7. Threads: sharing everything except the stack 8. Scheduling: who gets the CPU, and for how long 9. Interrupts, context switches, and why they're not free

Part 3 — Memory management 10. Virtual memory: every process's private lie 11. Paging, page faults, and the TLB 12. The memory hierarchy: registers to disk, and why it exists 13. Memory allocation and the OOM killer

Part 4 — I/O and storage 14. The I/O stack: from read() to the disk platter 15. Filesystems: inodes, directories, and journaling 16. Caching, buffering, and disk scheduling

Part 5 — Concurrency and inter-process communication 17. Race conditions at the OS level 18. Locks, semaphores, and deadlock 19. Pipes, sockets, shared memory, and message queues 20. Signals: the OS's tap on the shoulder

Part 6 — Boot and the kernel 21. From power button to login prompt 22. Init systems, kernel modules, and device drivers

PHASE 2 — Linux fundamentals

Part 7 — The filesystem hierarchy and navigation 23. Everything is a file (almost) 24. The Filesystem Hierarchy Standard, and why /etc isn't random 25. Permissions, ownership, and links

Part 8 — Essential commands, in depth 26. File and directory operations you'll use daily 27. Text processing: grep, sed, awk, and pipes 28. Redirection and the pipeline as a design pattern 29. Finding things: find, locate, which, grep -r 30. Package management: how software gets onto a Linux box

Part 9 — Process management in practice 31. Watching and controlling processes: ps, top, htop, kill 32. Job control: foreground, background, and nohup 33. systemd and services: how "always running" actually works 34. Logs: journalctl and where output really goes

Part 10 — Users, permissions, and basic hardening 35. Users, groups, and sudo 36. The permission model, beyond chmod 777

Part 11 — Networking on Linux 37. How a Linux box sees the network 38. The tools: ss, curl, dig, tcpdump, and a firewall's basics

Part 12 — Shell scripting and automation 39. Bash scripting fundamentals 40. Cron, environment variables, and glueing things together

Part 13 — Performance and troubleshooting 41. Reading load average, vmstat, and iostat correctly 42. strace, lsof, and answering "why is this stuck" 43. Resource limits: ulimit and your first taste of cgroups

PHASE 3 — Containerization: Docker and Kubernetes

Part 14 — Container fundamentals 44. What a container actually is (namespaces + cgroups + a filesystem) 45. Containers vs. virtual machines, honestly compared 46. Images and layers: why containers start in milliseconds

Part 15 — Docker in depth 47. Running your first containers, and understanding what happened 48. Writing a good Dockerfile 49. Volumes and data: what survives a container's death 50. Container networking: how containers talk to the world 51. Docker Compose: running more than one container together 52. Registries and image security basics

Part 16 — Kubernetes fundamentals 53. Why Kubernetes exists (the problem Docker alone doesn't solve) 54. The control plane and the node: Kubernetes' architecture 55. Pods, Deployments, and ReplicaSets 56. Services and how traffic finds a pod 57. Configuration: ConfigMaps, Secrets, and environment 58. Scheduling and scaling

Part 17 — Kubernetes in practice 59. Reading cluster state and debugging a pod that won't start 60. Deployment patterns: rolling updates, health checks, rollbacks 61. Helm and packaging Kubernetes applications

Part 18 — Capstone projects 62. Project 1: build and profile a small program, OS-level 63. Project 2: containerize a real application properly 64. Project 3: deploy that application to Kubernetes with health checks 65. Project 4: diagnose and fix a planted incident, end to end

Part 19 — Advanced Linux operations and expert practice 66. Production Linux mental models: fleet, drift, and failure domains 67. systemd beyond start/stop: dependencies, timers, sandboxing, and debugging 68. Storage operations: LVM, RAID, filesystem growth, backups, and recovery 69. Advanced Linux networking: namespaces, routing, nftables, and packet paths 70. Observability and performance: perf, flame graphs, eBPF, and OpenTelemetry 71. Linux security hardening: SELinux/AppArmor, auditd, capabilities, and least privilege 72. Incident response and refactoring on real Linux systems

Part 20 — Systems programming in Go: the OS from inside a program 73. Go meets the kernel: system calls, threads, and the runtime 74. Processes from Go: exec, exit codes, signals, and PID 1 75. CPU limits: GOMAXPROCS, cgroups, and throttling 76. Memory limits: the Go heap, GOMEMLIMIT, and the OOM killer 77. Files that survive crashes: page cache, fsync, and atomic replacement 78. File descriptors and the netpoller: holding thousands of connections 79. Reading /proc from Go: build your own ps 80. A container runtime in 150 lines of Go 81. Profiling Go on Linux: pprof, the execution tracer, and perf 82. Capstone: shipping a well-behaved Go service (image, systemd, Kubernetes)

Part 21 — Where to go next 83. Honest gaps and a study plan 84. Staying current

Appendices

• A. Glossary (plain language)
• B. Command cheat sheet
• C. Troubleshooting playbook ("the server is slow" flowchart)
• D. Further reading, and how this guide's facts were verified
• E. Answers to "Check yourself"