Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required. Learn more
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Follow the Authors
OK
The Elements of Computing Systems: Building a Modern Computer from First Principles
| Price | New from | Used from |
There is a newer edition of this item:
$34.37
(171)
Only 4 left in stock - order soon.
A textbook with a hands-on approach that leads students through the gradual construction of a complete and working computer system including the hardware platform and the software hierarchy.
In the early days of computer science, the interactions of hardware, software, compilers, and operating system were simple enough to allow students to see an overall picture of how computers worked. With the increasing complexity of computer technology and the resulting specialization of knowledge, such clarity is often lost. Unlike other texts that cover only one aspect of the field, The Elements of Computing Systems gives students an integrated and rigorous picture of applied computer science, as its comes to play in the construction of a simple yet powerful computer system.
Indeed, the best way to understand how computers work is to build one from scratch, and this textbook leads students through twelve chapters and projects that gradually build a basic hardware platform and a modern software hierarchy from the ground up. In the process, the students gain hands-on knowledge of hardware architecture, operating systems, programming languages, compilers, data structures, algorithms, and software engineering. Using this constructive approach, the book exposes a significant body of computer science knowledge and demonstrates how theoretical and applied techniques taught in other courses fit into the overall picture.
Designed to support one- or two-semester courses, the book is based on an abstraction-implementation paradigm; each chapter presents a key hardware or software abstraction, a proposed implementation that makes it concrete, and an actual project. The emerging computer system can be built by following the chapters, although this is only one option, since the projects are self-contained and can be done or skipped in any order. All the computer science knowledge necessary for completing the projects is embedded in the book, the only pre-requisite being a programming experience.
The book's web site provides all tools and materials necessary to build all the hardware and software systems described in the text, including two hundred test programs for the twelve projects. The projects and systems can be modified to meet various teaching needs, and all the supplied software is open-source.
- ISBN-100262640686
- ISBN-13978-0262640688
- PublisherThe MIT Press
- Publication dateMarch 31, 2005
- LanguageEnglish
- Dimensions8 x 0.69 x 9 inches
- Print length344 pages
What do customers buy after viewing this item?
- Lowest Pricein this set of products
Operating Systems: Three Easy PiecesRemzi H Arpaci-DusseauPaperback - Most purchasedin this set of products
Cracking the Coding Interview: 189 Programming Questions and SolutionsPaperback
Computer Systems: A Programmer's Perspective, 3 EditionDavid R. O'Hallaron Randal E. BryantPaperback
Editorial Reviews
Review
A refreshingly new way of looking at computer systems as a whole by considering all aspects of a complete system in an integrated manner.
―Jonathan Bowen, Times Higher Education SupplementAbout the Author
Shimon Schocken is Professor of Computer Science, and Founding Dean, Efi Arazi School of Computer Science, IDC Herzliya, Israel.
Product details
- Publisher : The MIT Press (March 31, 2005)
- Language : English
- Paperback : 344 pages
- ISBN-10 : 0262640686
- ISBN-13 : 978-0262640688
- Reading age : 18 years and up
- Item Weight : 1.32 pounds
- Dimensions : 8 x 0.69 x 9 inches
- Best Sellers Rank: #489,571 in Books (See Top 100 in Books)
- #59 in PC Hardware
- #113 in Computer Hardware Design & Architecture
- #1,721 in Computer Science (Books)
- Customer Reviews:
Important information
To report an issue with this product, click here.
About the authors

Noam Nisan is Professor at the Institute of Computer Science and Engineering, Hebrew University of Jerusalem.

Shimon Schocken is professor and founding dean of the Efi Arazi School of Computer Science at IDC Herzliya, a young Israeli university he helped found in 1995. He was also a tenured professor at NYU (1985-1995) and a visiting professor at Harvard (2005) and Stanford (2012). Shimon enjoys developing innovative courses and open source software to promote free web-based science education. Shimon's other passion is mountain biking, a subject about which he wrote a book in Hebrew, published by Kinerent-Zmora-Modan. website: www.shimonschocken.com
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on Amazon-
Top reviews
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
This book is simply a guide to the project on the website of the same name. Completing the project is the primary intellectual profit of this book.
In chapters 1-5 you build up the hardware of the computer, from logic gates to CPU and RAM. These chapters are a breeze and take maybe 5 hours max. Easy and enjoyable.
In chapters 6-11, you build up the compiler to translate from a high level language (Jack) to machine code. The difficulty rapidly ramps up at this point. The assembler (chapter 6) probably took me 3 hours, but wasn't difficult. Chapters 7 and 8 (the virtual machine translator) are where it gets really hard. Each chapter took me 10 hours, since you're translating from VM code to assembly. Programming in assembly is a pain in the ass no matter how easy you make the assembly language. In chapter 9-10, you build the lexer and parser of the front-end of the compiler. At this point, the book gets even harder. It gives you almost no theory on how to actually build it. I needed to refer to a compiler book to help me along. I would say chapter 10 took me 20 hours alone.
Finally, chapter 11 (where I stopped), it gets nasty. You're writing a syntax-directed translator compiler.
You now write the code generator from jack to VM, and there's a lot of OS functions that it keeps calling whose functionality hasn't even been explained yet. After writing a skeleton translator (in about 10 hours), I figured I'd gotten most of what I can out of the book and stopped.
In chapter 12, you write a whole bunch of OS library functions in jack. There's very little guidance.
Overall, even though things fell apart for me at the end, I still learned so much, and I don't know where else I could have gotten this experience. It was fun (and frustrating), but I feel like I understand computers so much better now.
Highly recommend. I would estimate it takes 10 hours to read the book and 50+ hours to do the project (to the point that I did it, chapter 11).
I grabbed this book because working from the bottom up, from NAND gates to a functional OS, sounded like the best process to learn. I'm on Chapter 6 right now (about half way through the book), and I know I've made the right choice. The best part of this course is that you actually build every single layer of the computer architecture using their free suite of visualization tools. This means that, every time you start a new chapter and take the next step up the ladder of the computer hierarchy to the place you actually live in (i.e. an operating system with a graphical user interface), you understand exactly why you're building what you're building--and how exactly it relates to all the layers beneath it.
I'm not a mathematics guy (I spent seven years in college studying literature; hence why I need this book!), but with some perseverance, several hours spent with a constantly furrowed brow, and a not insignificant amount of cursing, I've been able to puzzle through every single one of the tasks set out by the book so far. If you have some natural curiosity and critical thinking skills, you'll be able to get through this book no matter how non-technical your background is. What's especially helpful is that there are resources outside the book itself: The online forums for this book are (as of April 2014) very active, and you can either wait a day or two to have an expert look at your code and see all the various ways you're screwing up, or you can search to see if your particular question has already been answered (it usually has).
It's not all wine and roses, of course. The UI of the software suite is pretty rough, with a few apparent bugs (I'm using them in a Mac OS, so that might be the root of some of the problems). Also, the hardware description language (HDL) you use in the first half of the book often seems unnecessarily finicky (I hope you didn't put "and" instead of "And" somewhere in your 100 lines of code...). And, though the book mostly follows a path straight up the latter of abstraction, Chapter 4 jumps up to the software (assembly code) level, then follows with Chapter 5, which drops back down into the hardware of the CPU and memory. This structure actually kind of makes sense once you get through both of these chapters (there may be no other way to do it, now that I think about it), but it's pretty disorienting trying to get through the lower layers of software when the hardware is still sitting around in pieces, only half explained. Some context/additional explanation at the beginning of Chapter 4 would have helped with this.
Also note that, when you hit Chapter 6, you'll need some prerequisite high-level coding/scripting experience. It doesn't really matter what language you know; you just need to know one. If you're completely new to coding, I would recommend learning some Python via Codecademy; it'll probably be a month or two detour from the book (depending on how fast you work), but it'll be worth it.
In summary, I can't think of a more efficient way to get a thorough overview of Computer Science than this book. Any shorter of an explanation won't really make sense; any more in-depth of an explanation would probably lose everybody but the people getting college degrees in this stuff. For new students to the field, or for amateurs with an interest, this book hits the sweet spot.
Top reviews from other countries
Another waste of money and this one turned up I was really looking forward to reading But it was the upteen revised edition and had hardly any diagrams again mislead by little to no proper description from the seller remember a picture is worth a thousand words
Amazon is amazing as usual with the order delivery and quality of service.








