Book Review: Structured Computer Organization (6th Edition)
Over the years, I’ve spent quite a bit of time teaching core computing concepts. When I was teaching at universities, there were a few “go-to” books that I liked to use. One such book was Structured Computer Organization by Andrew Tanenbaum and Todd Austin. I recently noticed that it was now in its 6th edition, so I thought it was time to revisit it.
The book was designed to be used in university courses. I’m not sure what the current setup is, but I noticed on Amazon that it was a crazy high price, yet it was also available for direct download from a university GitHub repository. I couldn’t seem to work out if that was intentional or not, so I won’t link to it.
Content
Chapter 1 of the book starts out by describing the concepts of languages, the levels of those languages, and virtual machines.
I particularly enjoyed going back through the key milestones in computer architecture, given I lived through some of them. They describe machine generations from the Zeroth generation (i.e., mechanical computers), through valves, transistors, ICs, VLSI, and low power and “invisible” computers.
The book then describes the “computer zoo” by talking about the different types of systems that exist, and then describes the x86, ARM, and AVR architectures as examples.
This chapter was an interesting computing history.
Chapter 2 got into the core concepts of most systems, describing processors, different types of parallelism, memory, and storage. It finishes by talking about I/O devices, and interestingly, a discussion on character codes. (That’s a topic dear to my heart).
Chapter 3 covers low-level concepts from gates and boolean algebra, through common logic circuits, clocks, latches, registers, and how memory is organized. There is a discussion on CPU chips and buses, followed by examples of the Intel Core i7, TI OMAP4430, and the Atmel ATmega168. The content on the i7 is not too far from the current state. I liked seeing a discussion on how PCI, PCI Express, and USB work.
Chapter 4 gets into the microarchitecture level, with data paths, microinstructions, stacks, JVM, and discusses the speed vs cost tradeoff. Again, the Core i7 and the same other two processors are used as examples.
Chapter 5 describes instruction sets, data types, instruction formats, addressing, types of instructions, flow of control, and then shows a detailed example of The Towers of Hanoi in assembly language for the three processor examples. It then provides details on the IA-64 and Itanium 2 architectures and how they differ.
Chapter 6 dives into operating systems, with virtual memory, hardware virtualization, and covers how I/O is handled from the OS level.
Chapter 7 was a great blast from the past for me. It looked at the assembly language level. I’ve had periods where I needed to write a bunch of assembler, and I always enjoyed it, even though it could be frustrating. I’ve had some fascinating jobs over the years, where this was a necessary skill. For example, I was handsomely paid to write a plotter driver once, for a company with over 400 developers, none of whom had any idea where to start.
It wasn’t always fun though. I remember doing work with 6511 processors, and only having a 6502 assembler. We needed to use those handful of extra instructions, so we ended up writing a basic 6511 assembler ourselves. That was easier than our previous work, where we were writing machine code in hexadecimal, directly into an EPROM burner. The world is so very different today.
Chapter 8 covers parallel computer architectures. I think the most useful parts are the coverage of coprocessors, and UMA, NUMA, and COMA. You won’t find that sort of details in most books on computer systems.
The appendices are full of interesting content as well.
Summary
This is a fascinating book, and it’s great to see how it has evolved over the years. It’s not for everyone though, as most people won’t ever need to understand computer systems at this level. For those that do, this is still a fascinating book.
8 out of 10
2025-05-03