A Strong Opening: Kernel Space, User Space, and Context Switching

How Linux Works by Brian Ward starts in exactly the right. Before it ever touches a command or a config file, it explains kernel mode versus user mode, what a context switch actually is, and how time slices let one CPU juggle dozens of processes at once. For a book about how Linux works, starting from this foundation, kernel space versus user space, is the right call, and it made everything that came after easier to place mentally.

From there it moves into basic commands, the Filesystem hierarchy Standard (FHS), devices, disks, and filesystems, building up in a logical order rather than throwing commands at you with no context for why the filesystem is laid out the way it is.

The Filesystem Chapter Goes Deeper Than I Expected

The filesystem chapter is one of my favorites in the entire book. It doesn't stop at “here's how to mount a disk” it gives a pseudo-overview of how an inode-based system actually organizes data, draws a comparison to how a database indexes records, walks through several real filesystems side by side so you can see the trade-offs between them instead of just being told one is “better”. That comparative what made the chapter stick with me.

How Linux Boots: GRUB, vmlinuz, and the initramfs Check-and-Egg Problem

Another standout chapter covers how the Linux kernel actually boots: GRUB, the process, the compressed kernel image (vmlinuz), and initramfs, and more importantly, why initramfs exists at all. The book lays out the chicken-and-egg problem clearly: GRUB needs to load the kernel image off a filesystem, but the driver needed to read that filesystem is inside the very kernel image it's trying to load. initramfs is the way around that problem, and the book's explanation of it is brief but exactly as detailed as it needs to be, enough to actually understand what's happening rather than just memorizing the boot sequence.

Entering User Space: init, systemd, and SysV

Once the kernel has booted, the book shifts into user space and introduces the init program, comparing systemd and SysV init directly, their differences, and the strengths and weaknesses of each. This was another excellent chapter. It's satisfying to finally understand that PID 1, the very first user-space process, is what spwans every other process on the system afterward.

One thing I skipped over earlier that deserves a mention: the book's explanation of fork() and exec(), how a new process actually comes into existence, what happens to process when its parent dies before it (an orphaned process), and the fact that every process on a Linux system is, in a very real sense the child of another process. That parent-child relationship is a small insight, but it's one of those things that reframes how you think about “a process” once you've read it, and the book introduces it early enough that it colors everything that comes after.

Where Is Starts to Become a “Shotgun Book”

From this point on, the book methodically works through nearly every subsystem Linux has, and it goes deep. To its credit, it's upfront about this: when a section especially detailed, it tells you outright that you're free to skip ahead, I didn't take that advice, and I kept reading cover to cover, but doing so is what made me realize this books falls into a category I've started calling a “shotgun book”.

A shotgun book is my own term for a book whose scope becomes so broad that you stop being able to read it like a normal book and start needing to use it as a reference instead. Outside of computing, Politics by Andrew Heywood is a good example of the same pattern: it's a genuinely good book, but it covers such a wide spread topics that keeping any single one of them firmly in memory becomes difficult.

To be clear, I don't think a good book has to be one you can memorize cover to cover. That's not the issue. the issue with a shotgun book specifically is retention over time: by the time you finish one chapter and land in the next, the conceptual distance between them is often large enough that the previous chapter starts fading before it's had a chance to settle. The name comes from exactly that feeling, each chapter fires off a spread of terms and topics without lingering on any single one long enough for it to fully land, and by the end of the book, that pattern has repeated so many times that a lot of the earlier material has already gone hazy. And yes I know there's a term for that, but what can I do? I like my terms more than others.

Networking: One of the Strongest Chapters in the Book

Despite my criticism of some of the later chapters, the networking chapter is one of the strongest parts of the book. Like the opening chapters, it starts from first principles instead of assuming you already know how computer networks work. Rather than immediately introducing commands or configuration files, it begins by answering the more important questions: What is a network? How do computers communicate with one another? Why do we even need protocols in the first place?

From there, it gradually builds on those fundamentals, explaining the layered nature of networking before moving into IP addresses, subnet masks, routing, and how packets find their way across different networks. The explanation of routers and Network Address Translation (NAT) was especially well done. Instead of presenting NAT as just another networking term to memorize, the book explains why it exists, what problem it solves, and how it allows multiple devices on a private network to share a single public IP address. By the end of the chapter, I felt like I understood not only how these technologies work, but also why they were designed the way they are.

Virtualization: A Strong Finish

The final chapter on virtualization is another highlight. Much like the networking chapter, it starts with the fundamentals before introducing the different approaches to virtualization. Rather than treating virtual machines as a black box, it explains the role of the hypervisor, how virtual hardware is presented to a guest operating system, and why virtualization became such an important technology in modern computing.

By this point in the book, you've already learned enough about the Linux kernel, processes, memory, storage, and hardware that virtualization feels like a natural conclusion instead of an unrelated topic. It's a fitting final chapter that ties together many of the concepts introduced earlier and leaves you with a broader understanding of how Linux fits into today's computing landscape.

Final Thoughts

Overall, I really enjoyed (for most of the parts, i think; yeah) How Linux Works. Most of its chapters are exceptionally strong, starting from the fundamentals and building upward with clear explanations instead of expecting prior knowledge. More importantly, the book doesn't just tell you what Linux does; it spends time explaining why it works the way it does, and that approach gives you a much deeper understanding of the system as a whole.

That said, I still think some chapters become so detailed that they're better treated as reference material (Shotgun pages) than something to read straight through. Those sections occasionally made me want to skip ahead, even though I ended up reading the book cover to cover.

Even with that criticism, I would still recommend this book to anyone who wants to understand Linux beyond simply using it. If your goal is to build a solid mental model of how the operating system works, from the kernel and boot process all the way to networking and virtualization, it's one of the best books I've read on the subject.