Computer Systems: A Programmer’s Perspective (2nd Edition)
For Computer Systems, Computer Organization and Architecture courses in CS, EE, and ECE departments.
Few students studying computer science or computer engineering will ever have the opportunity to build a computer system. On the other hand, most students will be required to use and program computers on a near daily basis. Computer Systems: A Programmer’s Perspective introduces the important and enduring concepts that underlie computer systems by showing how these ideas affect the correctness, performance, and utility of application programs. The text’s hands-on approach (including a comprehensive set of labs) helps students understand the “under-the-hood” operation of a modern computer system and prepares them for future courses in systems topics such as compilers, computer architecture, operating systems, and networking.
Visit the CSS:AP web page http://csapp.cs.cmu.edu for more information and resources.
Rating: 
(out of 21 reviews)
List Price: $ 108.00
Price: $ 70.00
Computer Systems
Completely revised and updated, Computer Systems, Fourth Edition offers a clear, detailed, step-by-step introduction to the central concepts in computer organization, assembly language, and computer architecture. It invites students to explore the many dimensions of computer systems through a top-down approach to levels of abstraction. By examining how the different levels of abstraction relate to one another, the text helps students look at computer systems and their components as a unified concept. The new Fourth Edition is based on the Pep/8 assembler and simulator, which was designed to teach the basics of the classic von Neumann machine. Pep/8 now includes a new symbolic trace feature that displays global variables and the run-time stack in real time as the student single steps through the program. Throughout the text Warford emphasizes the importance of mastering fundamental computer concepts, which provides a basis for understanding both current and future technology, while also stressing the importance of keen problem solving skills. Computer Systems, Fourth Edition covers all of the core topics in the Architecture and Organization category of the ACM-IEEE Curriculum 2001 Guidelines for Computer Science.
Rating: 
(out of 5 reviews)
List Price: $ 129.95
Price: $ 38.97
Rating:
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:
[1] Computer Organization and Design Second Edition : The Hardware/Software Interface by David A. Patterson, John L. Hennessy
[2] UNIX Internals: The New Frontiers by Uresh Vahalia
[3] Linux Kernel Development by Robert Love
[4] Linkers and Loaders by John R. Levine
[5] GNU Binutils (GAS, objdump, ar, nm etc) Documentation
Excellent job. I really appreciate the work and content of this book.
Rating:
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
Rating:
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.
Rating:
This book covers everything from basic C programming to IA32 assembly language to the ridiculously mundane IEEE representation of floating point numbers to threads.This is a great resource for engineers who are interested in comprehensive, hands-on, and rigorous understanding of system-level programming.
Rating:
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
Systems 957
A.2 Error-Handling
Wrappers 959
Rating:
This book serves as a nice introduction to computer architecture, though those wishing to learn assembly language that they can actually apply in real-world applications will be disappointed, as the assembly language that’s taught applies only to the virtual computer that is used with the book. The virtual computer, called the Pep/6, aids the student in learning about different addressing modes, language translation, etc. The book covers many other topics including boolean logic, language translation principles, different base numbering systems, etc. The book moves at a comfortable pace, and, coupled with good teaching, can potentially teach the student a good deal.
Rating:
This book is pretty good, but can be quite frustating if you try to study it in on your own. When reading books, sometimes authors would refer to certain tables or columns to better explain the context of the subject discussed. In this book, however, the author doesnt give any hint or idea of where to look when using certain reference.
So lets say you are still in the middle of absorbing certain texts, ,suddenly the author mentions certain things that seem to be out of context, and you have no idea that the author is actually refering to certain table or figure(eg. figure 4.5 or etc.). The author doesnt mention anything, its just there out of the blue. The table or figure mentioned, could be in the next page or ..somewhere at beginning of the chapter.
You are left to find it out yourself.In other words, the author doesnt tell you which figure he is talking about, he just say in this table, or figure etc… etc…and the worse thing is that its not always on the same page….could be really far at beginning or next few pages..lol
Rating:
I regularly teach CS1 and CS2, (as well as CSX)in the NYS SUNY system. We have a course between CS1 and CS2 (CS1.5?) This is a breadth course which also has a required programming component. I like the Warford text, as it provides a pretty good introduction to topics across the spectrum. I am not in love with the order, since I cover logic after data representation and the text has it at the end. Also, as with another review I saw, this text unfortunately does not use a real live assembly language. Since learning a pretend one is just as hard as learning a real one, I usually substitute a module on the intel-chip assembly language in place of the text coverage. All that said, this is the best book I could find. Most breadth- coverage texts are at level CS0, this one definitely is not.
Rating:
I thought it was reasonably easy to follow. This book was not a prima donna among CS books, but it does the trick.
Rating:
As a programmer I’m really enjoying this book. It’s an excellent book about computer architecture. I also teaches assembly language.
If you are not already a programmer this is not the right book.
This book uses C++ high level, and assumes you have some experience with a high level programming language (not necessarily C++)