Introduction to Computer Organisation ARM Edition (Robert G. Plantz)（Z-Library）

【One-Line Pitch】 A patient, hands-on bridge from high-level code to real hardware: learn ARM A64 assembly on a Raspberry Pi while tracing how C/C++ actually becomes machine instructions. Best for programmers who know a little code and want to stop treating the CPU as a black box. 【Book Arc】 - **Opening (~0%–10%)**: Frames the whole project — the three subsystems (CPU, memory, I/O) and their buses — and explains why the book uses C plus ARM A64 assembly on a Raspberry Pi rather than Python. Solves the "where do I even start" problem and sets up the toolchain. - **Early (~10%–35%)**: Builds the mathematical and logical vocabulary: binary/hex storage formats, unsigned and two's-complement arithmetic, Boolean algebra and minimization, then logic gates and combinational circuits. This is the language you need before hardware makes sense. - **Middle (~35%–60%)**: Moves into software execution — how a program is created, compiled, linked, and fetched/executed — and introduces the memory hierarchy and CPU architecture. Connects the abstract math to actual instruction execution. - **Late (~60%–85%)**: The core assembly-language work: control-flow constructs, subfunctions and stack frames, recursion, bitwise/multiply/divide instructions, arrays and records, and a C++ object-oriented chapter. This is where high-level constructs get demystified line by line. - **Ending (~85%–100%)**: Applies everything to fractional numbers (fixed- and floating-point, IEEE 754), then I/O — memory-mapped devices, GPIO programming on Raspberry Pi 3/4/5, polled I/O — and closes with exceptions and interrupts on AArch64. 【Key Takeaways】 - **The book is organized in three deliberate layers** (Early): mathematics/logic, then hardware, then software — each layer supplies the vocabulary for the next, so skipping ahead costs you the conceptual scaffolding. - **Assembly is taught as a lens on C/C++**, not as an end in itself (Middle): you compile C, inspect the generated assembly, then write the same constructs by hand, which makes compiler output readable rather than mysterious. - **Two's complement and fixed-width integers have real limits** (Early): the circular nature of integer codes explains overflow and sign behavior that high-level languages hide. - **Boolean algebra pays off in hardware** (Early): minimization via algebraic rules and Karnaugh maps is presented as the practical path from truth tables to gate-level circuits. - **Subfunctions and stack frames are the heart of the calling convention** (Late): argument passing, scope, static locals, and recursion are all explained at the assembly level, which is where most beginners get lost. - **Floating-point is approximate by design** (Ending): rounding error, absorption, cancellation, and non-associativity are treated as consequences of IEEE 754 representation, not as bugs. - **I/O is where software meets physical timing** (Ending): memory-mapped I/O and GPIO on the Raspberry Pi show why device access must be explicitly programmed, with polled I/O sketched and interrupt/DMA approaches noted. - **"Your Turn" exercises are the actual learning mechanism** (throughout): solutions are provided online, so the exercises function as practice rather than assessment. 【Reading Tips】 - Deep-read the early math/logic chapters if your binary and Boolean skills are rusty — later assembly explanations assume them; skim only if you're already fluent. - Keep a Raspberry Pi (64-bit Raspberry Pi OS) and the GNU toolchain beside you; the book is written to be typed along with, and the debugger is used to visualize registers and memory. - Treat the C/C++ chapters as translation exercises: compile a small program, then read the assembly the compiler produced before writing your own version. - Don't panic about C++ — the book states its C/C++ usage is simple and explained as it goes, so prior C++ experience is not required. - Use the chapter organization notes to jump between the three parts if you're revising, but read Chapter 1 and the toolchain setup first. 【Coverage Limits】 This guide is synthesized from stratified excerpts and the book's front matter and chapter listing; the excerpts do not cover the detailed content of individual chapters, so specific code examples, instruction syntax, and exercise solutions are not summarized here.