146 of 157 people found the following review helpful
on September 14, 2011
Format: Kindle EditionVerified Purchase
There are too many typos. It's a complete waste of money and time trying to decipher some of the formulas, where variables like x' can sometimes mixed up with x'', where there is poor spacing between different formulas, etc. There are even basic word typos ("buy" for "by").
I'm having to purchase the physical edition.
UPDATE: I bought the physical version. Wow. All those typographical errors in the Kindle version really screwed me over for the upcoming homework. Complete formulas were left out. Avoid.
Example: (|V| o) ....is actually supposed to be (|V|>>0). There are MORE significant examples than this one, where incorrect notation can make or break your understanding.
68 of 71 people found the following review helpful
on March 24, 2005
What a splendid book! I wish I had gone to CMU and take this course. This book is written by CMU professors after teaching Computer Systems course for few years. This book covers broad spectrum of topics from Operating Systems, Compilers, Computer Architecture, Assembly Level Programming, Kernel internals, Linkers, etc from a programmer's perspective (as the title aptly says).
I am searching for words to describe the usefulness of this book. In my experience, I have had hard time learning some of the topics where Operating systems, Processor and Compilers intersect. For example, Linkers and Loaders, program disassembly using reverse-engineering, virtual memory in Kernel etc. After all the hard work, I found the right book which grinds all the famous books in different areas and gives the right juice for the real programmers to taste and digest.
Those famous books are:
 Computer Organization and Design Second Edition : The Hardware/Software Interface by David A. Patterson, John L. Hennessy
 UNIX Internals: The New Frontiers by Uresh Vahalia
 Linux Kernel Development by Robert Love
 Linkers and Loaders by John R. Levine
 GNU Binutils (GAS, objdump, ar, nm etc) Documentation
Excellent job. I really appreciate the work and content of this book.
35 of 37 people found the following review helpful
on November 19, 2003
Have it on my desk since I bought for my computer architecture course (Csci 2021, Univ. of Minnesota - Twin Cities). Such a cool book to learn how computer hardware and software *really* work together, and why finding that out, could make us a more valuable computer scientist/programmer. Also provides a great hand to get you ready for advanced classes like Operating Systems, Compilers. My favorite chapter in the book is about Caches. It's unbelievable to first find out how much cached really matter! Thanks Prof. Bryant and O'Hallaron.
I think the first 7 chapters are what the most important to understand and grasp. Rest of the chapters are important too but they usually will overlap with other topics/classes like operating systems. Also, chapter 4 goes in more detail in processor architecure like pipelined CPU and will probably help more to the computer engineer; although computer scientists do learn a lot out of it and will help write code to exploit modern pipelined CPU's, like the deeply pipelined, Pentium 4. But I think the first 7 chapters are the ones, that sets this book aside from the others. You will need access to LINUX, as most of the discussions rotate around it like the virtual address space, assembly code - GAS and so on use the linux implementations.
After reading, you will be able tp convert decimal nos to binary and even floating point nos to binary format very easily. You will also learn more about twos complement operations and integer and floating point arithmetic, able to understand assembly code (GAS: GNU Assembler code), how procedures are implemented using stacks array allocation, debugging, embedding assembly code in C programs, more about CPU instruction sets and hardware control language and their implementations, pipelining, optimizing programs and expoliting caches, understanding modern CPU's, various storage technologies, linking, symbol tables, object files, shared object files, and more.
Don't forget to visit the book's website before buying the book. It is <[...]
Here is a brief look about what it is all about!
Chapter 1: A Tour of Computer Systems
Chapter 2: Representing and Manipulating Information
Chapter 3: Machine-Level Representation of Programs
Chapter 4: Processor Architecture [MORE FOR COMPUTER ENGINEERS!]
Chapter 5: Optimizing Program Performance
Chapter 6: The Memory Hierarchy [COOL ONE!]
Chapter 7: Linking
Chapter 8: Exceptional Control Flow
Chapter 9: Measuring Program Execution Time
Chapter 10: Virtual Memory
Chapter 11: System-Level I/O
Chapter 12: Network Programming
Chapter 13: Concurrent Programming
25 of 27 people found the following review helpful
on June 8, 2011
Format: Kindle Edition
I am a software engineer who already have 5 years experience. When I was at University of Penn., we used this book(1st edition) as supplement. However, I found it is just deserved to be used as main textbook: clean, friendly writing style, concrete examples to explain abstract system concepts, and interesting exercises with detailed solution. It's the number one system textbooks in my mind. Even though I have worked for 5 years, this books remain it's place on my bookshelf.
The only little problem of this book, both the strength and weakness, is that it chooses x86 architecture to explain the system concepts. x86 is great architecture, but from an embedded system developer point of view, I will strongly recommend the authors to introduce some embedded processors topics(like ARM): they are small, powerful enough to drive most of mobile devices, and consumes "much" less power, and more importantly, they are the rising stars in the post PC world.
20 of 23 people found the following review helpful
on May 25, 2005
I just completed a college course using this textbook... the course was tough, but the book was very good and useful. This is one textbook I won't be selling any time soon!
The practice problems provided in the book were usually very good, and the programming problems distributed with it were fun and educational, including topics like Buffer Overflows, Memory Optimizations, and Debugging with GDB, among others.
There are *some* problems with this book, but it doesn't suffer from the devastating flaws that plague most computer science textbooks. Some sections lack thorough explanations and examples, and the writting is a bit unclear at times. Some solutions to the practice problems are vague and don't really provide much insight on how to solve the problems. Luckily, these flaws only creep up in a few places.
Compared to most technical textbooks, however, this one really shines. It's not quite perfect, so I think 4 stars is appropriate.
8 of 8 people found the following review helpful
This book is a very unusual one because it explains computer architecture from the standpoint of the C/C++ programmer. That is, its object is to allow the programmer to understand how the architecture of the computer on which he/she programs effects the performance and execution of these programs. Things such as virtual memory, parallelization, optimization, and even logical and mathematical operations are effected by the architecture of the computer itself. For example - big endian versus little endian machines. You'd believe you wouldn't have to think about how your computer is organized at this level - that is one of the reasons you program in a high level language anyways, right? Wrong. If you have data stored in big endian format that is mathematically operated upon in a little endian machine, or vice versa, you will wind up with something quite different from what you intended. That's the kind of information this book gets into.
Some have labeled this book as "hard". It really is not hard as much as it is densely packed with knowledge. You need to take each concept within each chapter and think about it before you go on to the next. If you do this you'll not only get much out of it during your initial read, you'll have a valuable reference for some time to come.
To get the most of this book you should already be a capable C/C++ programmer and you should also know the building blocks of a computer. The book goes over these things very quickly but it really is not enough if you start out knowing nothing about these subjects. Highly recommended.
The following is the proposed table of contents for the second edition:
1 A Tour of Computer Systems 1
I Program Structure and Execution 25
2 Representing and Manipulating Information 29
3 Machine-Level Representation of Programs 145
4 Processor Architecture 317
5 Optimizing Program Performance 449
6 The Memory Hierarchy 531
II Running Programs on a System 619
7 Linking 623
8 Exceptional Control Flow 667
9 Virtual Memory 741
III Interaction and Communication Between Programs 819
10 System-Level I/O 823
11 Network Programming 847
12 Concurrent Programming 893
A Error Handling 957
A.1 Error Handling in Unix
10 of 11 people found the following review helpful
on March 7, 2012
I'm not one to write huge reviews, but I'd like to at least write a few points about this book.
-This book isn't a technical book you can skim through and catch most of the points.
-Bring a pencil and paper, if you really want to retain any information in this book it's good to take notes and do all practice problems
-You should already have a STRONG understanding of C. If you don't understand pointers to the fullest, you should study C more.
-If you're not a full time student and you're really studying this book, I'd expect it to take two months to get through.
9 of 10 people found the following review helpful
on June 22, 2011
Format: HardcoverVerified Purchase
Can I say its a one-stop to learn a lot about a computing system as a software engineer. The content is detailed. I find a lot of books these days which are very opinionated - xx is s*** because it is so obvious (now!) that it would not be able to do yy etc. but no real insight as to what may have been the case when the implementation was being done. This book, much to my surprise and liking, stays away from that. It does a good job of explaining the nitty-gritties of why/what logic drove a certain design and how it all fits in place. All of the chapters have several ah-ha! facts which is bound to keep one interested in reading it to completion. There are a good number of solved and unsolved (assignment) questions throughout and at the end of a chapter which are very interesting as well. Altogether this is a book that is highly recommended for a software engineer who is trying to add system design skills to their skill set.
PS: The book requires a fair bit of Linux knowledge.
14 of 17 people found the following review helpful
on August 24, 2011
Format: Kindle EditionVerified Purchase
This review is for the Kindle version. I have only read through section 2, and I have found more typographical errors than any other book I have read. There are even careless errors in the practice problems and their solutions. Also, the formatting of some inline math and LaTeX is terrible. As far as the material goes, I'm a student, so I'm probably not a great judge. It's at least clear and comprehensible. Maybe even thorough.
After having read through chapter 6, either the error rate has died down or I just stopped noticing. Also, the accompanying online material is great, especially the labs.
6 of 7 people found the following review helpful
on June 24, 2011
Format: HardcoverVerified Purchase
This is a great book, in fact one of the best I've ever read. It's a bit dense if you haven't had much contact with assembly at first, but it moves forward in a pace good enough for you to follow (with help from external resources, like the Intel manuals, to sometimes see what an instruction is about).
For example, I had to go online to fully understand that the LEAL instruction actually did and was generally used for as well as to discover that the TEST instructions actually AND-ed the operands, but that's ok, because the main focus of the book is not to be an assembly course. It assumes you already know C well and have at least a good grasp of the major assembly instructions for x86.
The book is a bit costy IMO but still it's a great book and well worth it if you want to know how things work "under the hood" in your system and a great guide for those wanting to optimize their code and generally be a better programmer. Also it's very focused on GCC and Unix/Linux, which is awesome.