Chapter 40 Further Reading: Your Assembly Future

Foundational Systems Books

"Computer Systems: A Programmer's Perspective" (CS:APP) by Bryant and O'Hallaron (3rd edition) The companion volume to this book for someone who wants a second perspective on the same material presented differently. CS:APP covers assembly, linking, memory hierarchy, concurrency, and networking in a unified framework. Its treatment of the memory hierarchy (Part III, Chapters 6-9) and its linking chapter (Chapter 7) are particularly valuable for understanding what happens between assembly and execution. The "bomb lab" and "attack lab" assignments are widely used in university courses.

"Operating Systems: Three Easy Pieces" (OSTEP) by Arpaci-Dusseau and Arpaci-Dusseau https://pages.cs.wisc.edu/~remzi/OSTEP/ — free online. The conceptual framework for everything MinOS implemented, explained with remarkable clarity. Virtualization (processes, address spaces, scheduling), Concurrency (locks, condition variables, semaphores), and Persistence (I/O, filesystems) are covered as three orthogonal problems. Reading OSTEP after building MinOS gives you the conceptual vocabulary to describe what you built.

Security and Exploitation

"The Art of Exploitation" (2nd edition) by Jon Erickson The most approachable deep treatment of x86 exploitation, shellcode engineering, and format string attacks. Includes a live Linux environment (bootable CD/USB) for hands-on practice. Erickson's explanation of the stack at the byte level complements what Part VII covered. Essential reading if the security chapters engaged you and you want to go further before tackling CTF challenges.

"Hacking: The Art of Exploitation" is paired well with pwn.college https://pwn.college/ (Arizona State University) The structured CTF education platform referenced in Chapter 40. The "Program Security" module is the direct continuation of Chapters 35-37. Challenges progress systematically from basic buffer overflows through advanced exploitation techniques, with immediate automated feedback. The Discord community is active and helpful for hints without full spoilers.

"A Survey of Symbolic Execution Techniques" (ACM Computing Surveys 2018) https://dl.acm.org/doi/10.1145/3182657 For those interested in automated vulnerability discovery: symbolic execution (as implemented in tools like angr and KLEE) uses assembly-level semantics to reason about all possible program paths. Understanding assembly is a prerequisite for understanding what these tools do and why they sometimes fail.

Compiler Engineering

"Engineering a Compiler" by Cooper and Torczon (3rd edition) The rigorous academic treatment of compilation: lexing, parsing, IR construction, data flow analysis, register allocation (graph coloring), and instruction scheduling. The register allocation chapter explains why compilers spill registers to the stack when they do, and why the specific registers they choose for spilling affect performance. The instruction selection chapter explains what happens between LLVM IR and x86-64 output.

LLVM Getting Started and Kaleidoscope Tutorial https://llvm.org/docs/GettingStarted.html https://llvm.org/docs/tutorial/MyFirstLanguageFrontend/ The Kaleidoscope tutorial walks through building a complete JIT-compiled language (a simple calculator language) using the LLVM C++ API. By the end, you have a language that emits optimized x86-64 machine code. The tutorial is production-quality documentation; the complete implementation is about 1,200 lines of C++.

Linux Kernel Development

"Linux Kernel Development" (3rd edition) by Robert Love The practical introduction to kernel internals: process management, scheduling, system calls, interrupts, memory management, and device drivers. Love writes as a kernel developer (he wrote the O(1) scheduler). This book bridges the gap between what you implemented in MinOS and what the production kernel does, without requiring you to read millions of lines of kernel source cold.

Linux Kernel Newbies Wiki and the kernel's own documentation https://kernelnewbies.org/ https://www.kernel.org/doc/html/latest/ kernelnewbies.org maintains a guide specifically for first-time contributors. The kernel's own documentation (under Documentation/ in the source tree) includes process/submitting-patches.rst (the definitive guide to sending patches), process/coding-style.rst, and architecture-specific guides. These are not supplementary — they are required reading before sending a first patch.

Architecture References

"Computer Organization and Design: RISC-V Edition" by Patterson and Hennessy The standard computer architecture textbook, now in a RISC-V edition. Covers pipeline stages, branch prediction hardware, cache organization, out-of-order execution, and memory hierarchy at the microarchitecture level. If Chapter 17 (out-of-order execution) or Chapter 6 (memory hierarchy) engaged you and you want deeper understanding of the hardware implementation, this is the next step.

"The RISC-V Reader: An Open Architecture Atlas" by Patterson and Waterman Written by RISC-V's architects. At 238 pages, it is intentionally short and focused. The ISA comparison appendices between RISC-V, x86-64, and ARM64 are immediately useful for someone who knows x86-64 deeply and wants to understand what design choices RISC-V made differently and why.

Intel 64 and IA-32 Software Developer's Manual (Intel SDM) https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html The authoritative source for every x86-64 question. Download the combined PDF (5,000+ pages) or use the searchable HTML version. Volume 1 covers architecture; Volume 2 covers instruction reference; Volume 3 covers system programming (paging, protection, interrupts, VMX). When any assembly behavior is ambiguous, this document has the answer.

Communities and Ongoing Learning

CTFtime.org and the CTF writeup ecosystem https://ctftime.org/ The hub for CTF competitions worldwide. The writeup archive is the most valuable part: after each competition ends, participants publish detailed solutions. Reading writeups for challenges you could not solve is the fastest way to learn techniques you would not have discovered independently. Filter by category (pwn) and difficulty level.

lore.kernel.org — The Linux kernel mailing list archive https://lore.kernel.org/ The complete, searchable archive of Linux kernel mailing lists. Read how experienced contributors respond to patches, how review feedback is worded, what makes a good commit message, and what makes patches get rejected. Spending two hours reading the linux-kernel or linux-arch lists is more educational than any guide to kernel contribution process.