Linux Mastery Path¶
Most people learn Linux as a list of commands: chmod 755, systemctl restart, ps aux, iptables -A. That gets you through a day of
sysadmin work, but it leaves the "why" as a black box — why does a chmod on a directory not do what you'd guess from the file case,
why does killing a process sometimes leave a zombie behind, why does a service that starts fine by hand fail under systemd, why does
ping work but curl time out on the same host. This course is about the layer underneath the commands: the kernel data structures,
the on-disk formats, and the OS mechanisms that make the commands behave the way they do.
It's scoped deliberately narrow: this is Linux-the-operating-system, not Linux-the-shell-scripting-language (see
Shell/Bash Mastery Path for that) and not Linux-in-production (see
Server Ops Mastery Path for reverse proxies, deployments, HA and on-call).
Here you'll find the filesystem's actual on-disk model, how permissions and processes really work under the hood, what systemd
units and cgroups are doing, how the network stack resolves a name and routes a packet, and the security modules and kernel tools
that sit underneath everyday commands.
It assumes basic command-line comfort (you can cd, ls, and edit a file) but no prior systems knowledge. Every lesson that can
run on a real Linux kernel does — either directly (this course was written and verified on a real Linux virtual machine, not
guessed from documentation) or noted plainly where a mechanism (a specific systemd target, a particular distro's package
internals) couldn't be reproduced in the lab environment used to write it.
How the program is organized¶
| Level | Focus | Modules | What you can do after |
|---|---|---|---|
| 1 · The Kernel, Filesystem & Permissions | What Linux is, boot, the filesystem hierarchy, inodes, permissions, processes 101, package internals | 10 | Read any filesystem path or permission bit and know exactly what it means and why |
| 2 · Processes, Memory & Storage | Signals, scheduling, virtual memory, disks/LVM, mounting, systemd units/services/timers, journald, udev | 10 | Diagnose why a process is slow, stuck, or killed, and manage services correctly |
| 3 · Networking & Security Internals | The network stack, DNS, netfilter, sockets, SSH, SELinux/AppArmor, namespaces/cgroups, hardening | 10 | Trace a connection end-to-end and reason about an isolation or security boundary |
| 4 · Performance, Troubleshooting & Capstone | Tracing tools, I/O scheduling, kernel modules, /proc//sys, boot recovery, distro/version landscape |
10 | Profile a real performance problem and bring a broken system back from a bad boot |
Each level has 9 teaching modules plus a hands-on project (module 10), for 40 lessons total.
How to use this site¶
- Read the "what was run" note at the top of each lesson. Most commands in this course were executed on a real Debian/Ubuntu Linux virtual machine; where a lesson relies on a mechanism that machine didn't expose (a different distro's init quirks, a kernel feature needing privileges the lab didn't have), it says so instead of guessing at the output.
- Run the commands yourself. Nearly everything here works unmodified on any mainstream Linux distribution, in a VM, in WSL, or on a cheap cloud instance. You do not need a production server.
- Do the exercises, especially the "predict, then run" ones — the gap between your prediction and the real result is where the understanding is.
- Do the projects. Each is a complete, runnable artifact (a root filesystem you boot, a diagnosis script, a hand-built container, a hardened server you can tear down and rebuild) that ties its level together.
More from the Mastery Path series¶
Free, structured, module-wise training across 97 other languages, platforms and disciplines — expand a category to browse: