Write Great Code, Vol. 2 (Randall Hyde)（Z-Library）

【One-Line Pitch】 A practical guide to how compilers turn high-level statements and data structures into machine code, so you can write C/C++/Java-style code that runs efficiently without dropping to assembly. Best for working programmers and CS students who want performance intuition beyond what typical courses teach. 【Book Arc】 - **Opening (~0%–10%)**: Frames the core thesis—compilers are only as good as the source you feed them—and argues why thinking low-level while writing high-level pays off. (Note: early excerpts are largely OCR noise and site boilerplate.) - **Early (~10%–30%)**: Establishes the language-neutral, assembly-aware mindset and the characteristics of "great code," setting expectations for the rest of the book. (Excerpts here are mostly corrupted.) - **Middle (~30%–55%)**: Builds the low-level foundation: 80x86 and PowerPC assembly for the HLL programmer, addressing modes, literal and manifest constants, data declarations, and operand sizing. - **Middle (~55%–65%)**: Explains the compilation pipeline—parsing, intermediate code, optimization, native code generation—plus compiler output forms, object/executable file formats, alignment, and linker effects. - **Late (~65%–75%)**: Moves into tooling and data: analyzing compiler output with assembly dumps, `dumpbin`/`objdump`, disassemblers, then runtime memory organization and what a variable really is (binding, scope, lifetime, storage). - **Ending (~75%+)**: Continues into primitive data types, variable addresses, and (per the table of contents) iterative control structures, functions/procedures, and engineering software; the excerpts do not cover these chapters in detail. 【Key Takeaways】 - **Compilers are only as good as your source** (Opening): the book's central claim—statement and data-structure choices shape the machine code you get. - **You don't need to write assembly to benefit from knowing it** (Early): assembly literacy is a diagnostic lens, not a requirement for daily work. - **Addressing modes and data declarations drive performance** (Middle): how constants, operands, and data are declared maps directly onto efficient or wasteful machine code. - **Know the compilation pipeline** (Middle): parsing, intermediate code, optimization, and code generation explain why some source patterns optimize well and others don't. - **Object and executable formats matter** (Middle): COFF headers, sections, alignment, and linker behavior affect code size and speed. - **Inspect real compiler output** (Late): assembly listings, `dumpbin`, `objdump`, and disassemblers turn guesswork into evidence. - **A variable is a bundle of attributes** (Late): binding, scope, lifetime, and storage class determine where and how data lives at runtime. - **Language-neutral reasoning** (Early–Late): the techniques apply across C, C++, Java, Pascal, and BASIC, not just one ecosystem. 【Reading Tips】 - Deep-read the chapters on addressing modes, data declarations, and compiler output analysis—these are the most actionable. - Skim the assembly-language syntax chapters if you already know 80x86 or PowerPC; use them as reference. - Keep a compiler handy: reproduce the assembly-output examples and compare your own code's generated output. - Treat the table of contents as a map; the excerpts cover roughly the first two-thirds, so plan to read control structures and functions directly in the book. - Focus on transferable mental models (binding, alignment, optimization) rather than memorizing instruction sets. 【Coverage Limits】 The excerpts are heavily corrupted with OCR noise and website boilerplate, and only reliably cover roughly the first two-thirds of the book; later chapters on control structures, functions, and software engineering are visible only via the table of contents.