Write Great Code, Volume 1, 2nd Edition

by Randall Hyde

Understanding the Machine, the first volume in the landmark Write Great Code Series by Randall Hyde, explains the underlying mechanics of how a computer works.

Like the highly regarded first edition, this second edition of Understanding the Machine covers machine organization and computer science topics like the CPU, machine architecture, memory and cache organization, I/O and peripheral devices, and how the decoding and execution of machine instructions affects software performance. This edition has been updated to cover 64-bit machines, newer peripheral devices, larger memory systems, large-scale SSDs, and newer CPUs like those used in personal computers and tablets.

Genres: Programming, Computer Science, Technical, Technology, Coding, Software, Computers

470 pages, Paperback

First published November 1, 2004

Reviews

[Julio Biason · Rating 1 out of 5]

"Great code" is machine dependent and written in assembly. Or, at least, that's what this book makes you believe till the very last chapter, when it starts backtracking about writing code directly into CPU code.

Now, don't get me wrong, it's not a terrible book -- it's a damn complete book about computer architecture, even being so out-of-date that there is no word about SSDs (when talking about storage), no mention about MP3s (when discussing about audio hardware), the top CPU discussed is Pentium, there is no word about UTF-8 (and mentions ASCII is used all around) and recommending search things on AltaVista.

The problem is discussing all this when the topic is "great code": Great code is not machine dependent; great code is not highly optimized code that runs extremely fast and uses very little memory; there are trade offs that you have to take in account when coding: Sure, you don't write something that uses all the available memory, but you write in a language that allows you to easily extend the code later and which your code reads exactly what you meant it to say. That's great code, not code that uses some multimedia extensions that is available since a very specific generation of CPUs.

The book also goes into great lengths to explain stuff that is hardly useful. For example, there is a whole implementation of the floating point standard (IEEE 754), which is not optimized -- so, no great code -- and that's absolutely unnecessary, since this is done directly into the CPU (and, if it isn't, you have libraries ready for that).

It could be that the "Great Code" will come in the later volumes, but ignoring what is great code (I mean, real great code) and just building a base for later is plainly greedy.

[Taha Hasan · Rating 4 out of 5]

Although many of the things in this book is already taught in the universities,but the way the author covers the chapters by giving the in depth detail is magnus opus.How the code is organized in the memory and how effectively we can optimize the memory corresponding to the language which is used to compile the program.The architecture details which is mandatory for writing an optimized code.This book doesn't teach you how to write a great code but tells you the enough details regarding the memory and architecture which truck load of programmers miss in making a program.A gem for students and professionals as well.

[D351 · Rating 5 out of 5]

This book is crazy in-depth. I learned a whole lot.

[Dan Drake · Rating 3 out of 5]

There's a lot of useful and interesting bits in this book, but overall it came across as too much of a hodgepodge of topics. Assembly language and...object oriented language design? What do abstract base classes have to do with "understanding the machine"? Do we need the gory details of the various SCSI standards? How MIDI files work? It seems like Hyde isn't sure if he's writing a book about computer architecture, or operating systems, or programming language design.

I was hoping for something a bit more focused. The parts that more directly connect high-level programming language with the low-level language and data structures were good, but many other parts seemed superfluous.

[Lojza Tran · Rating 4 out of 5]

In general, the book is great introduction to basic concepts of computing. There are some stuff that make this book not perfect: I read the first edition, which is pretty old (2004), not all the things are explained in the book (e.g. assembly instructions).

[Xander Warszawski · Rating 5 out of 5]

Skimmed through this one since it covers everything about computer organization/architecture I've seen at uni. Meaning this is actually a great reference for this!

[Eugene ghaiklor Obrezkov · Rating 3 out of 5]

I have mixed feelings about this book. From the knowledge perspective it is a nice one, no doubts in that. But...

Usually, I split books about computers in several categories: the casual one, where everything is explained in a way that doesn't require deep understanding of what's going on and these books are easy to read and fun. The other one is the book where it has enough technical details and stuff, but I wouldn't call the book the academic one. And, well, the last category are academic books.

So... this books definitely goes into the second one. Honestly, it wasn't easy and fun to read, and I suppose, the author didn't persuade this kind of styling in the first place.

Some of the chapters were being skipped by me because I had these moments like "oh, I remember this stuff when I was working with X, I know about this" and you just skip it, because the chapter contains just the raw information I already knew. Some of the chapters contained like really deep technical information that wasn't easy to consume with graphics and schematics and you literally needed to scratch your head around.

However, let's bring some positives here. This book contains lots of information and I liked it. If you are interested in how things work from the hardware perspective, and you are not a newcomer in the field, then I'd suggest this book can be useful for you. But I wouldn't call it the first good book to start your journey.

Overall, nice book with lots of information, but sometimes this information is hard to consume and not so easy to follow.

[Elie De Brauwer · Rating 4 out of 5]

The book first starts at an abstract level (numerir representation, character sets, floating point representations, memory addressing...) in which some assembler is touched upon, and then roughly halfway makes a steep turn and becomes a computer architecture book (memory architecture, instruction set architecture, interfacing, ...). The second part brings back some memories to the Tanenbaums, Pattersons and Silberschatzes of this world (which are also referenced). But personally I found myself struggling rather hard with the timeframe of this book. The 2nd edition is a recent work (2021), but it shows that it's a second edition and it feels 1990's and 2000s. Thumbs up for deciding not to go in depth on floppy drives anymore, but thumbs down for the ATAPI's, AGP's, Soundblasters and 32-bit x86. I haven't read the first edition but it feels as if the overhaul could've been better.
Bottomline I enjoyed reading the book, but I do have the impression that the past decade should've deserved its place more. I'm probably a bit disappointed as I was actually hoping to close some 'modern' gaps in this domain.

[Ben · Rating 4 out of 5]

Enter The Machine

This was a great book on understanding the inner-workings of code, and the low level programming that goes on.

I really enjoyed learning of this, and found it very important fundamentals for people in Computer Science, like me!

A lot of this book I already knew, but a really good refresher.

I look forward to finishing this series of books!

Check it out!

4.2/5

[Daniel Cornwall · Rating 3 out of 5]

Found another tech book to read. This is just too nitty-gritty detailed to read. If I find myself programming in assembly language, I'll come back to it.

[Jared · Rating 3 out of 5]

A thorough description of the "machine." Unfortunately, like any technical book, a lot of the information is really outdated, and desperately requires an update.

[Michael · Rating 3 out of 5]

somewhat general

[Nathan Glenn · Rating 5 out of 5]

This book was awesome! Everything a programmer needs to know about computer architecture in order to write efficient code. It has chapters on memory organization, I/O, floating point computation, and much more. I wish he would make a newly updated one, though. It's age shows when it quotes prices on memory and mentions that floppy disks are beginning to die out. The section on magnetic tape was interesting but seriously has no application now.

[Sweemeng Ng · Rating 4 out of 5]

Can't believe I finished this book. This book s pretty old, A few section of this book is really dry! But it give a good view on how software works on the low level, very low level.

Most projects don't require software developer to understand how computer works, unless you work on drivers or operating system. Still for those that is curious how computer work, this book have enough detail. It just very drry at time.

[Paul · Rating 3 out of 5]

While modern high level languages abstract away the filthy details of what happens at the machine level while code is running, it's still important to understand how this stuff works if you plan on writing anything of significant complexity. This book teaches you what you need to know about how a computer works in order to improve the quality of your code.

[Mohamed · Rating 3 out of 5]

Nice refresh for old subjects of computer science.

[Stein Karlsen · Rating 5 out of 5]

Great book, goes really deep into the basics and underlying structure modern software is built upon.