The Elements of Computing Systems: Building a Modern Computer from First Principles

This book is an unparalleled companion in explaining, piece-by-piece, how you can build a somewhat realistic computer from the ground up in a way that is tremendously satisfying. However, it does kind of fall apart at the end, and it's difficult to finish without outside resources. Still, as a concise guide, it is unparalleled, and I am extremely happy I went on this journey, even if it kind of runs out of steam at the end. 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).

Had a hard time understanding how the Facebook and my toaster worked, felt left behind by these kids nowadays with their TikToks and their NFPs or MFTs whatever they are called, but this book brought me up to speed ! Gotta keep learning in these changing times.

I wanted to learn some programming languages and concepts to make my Technical Writer resume meatier. Problem was, any attempt to learn Python, SOAP, or MySQL just lead me to ask a million questions about how this stuff actually worked beneath the straightforward, high-level application stack: How does this code interact with the OS? How do lines of text get turned into binary instructions? How does all this abstract graphics, text, and data actually meet up with electrical signals and semiconductors? It has to at some point, right? It's not magic, right? (And so on). 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.

When I say "survey," I mean a wide-ranging view of what goes into a computing system. This unique book goes into more depth than the word suggests, though, since it presents every level as a project for the student to carry out. This starts with the processor: the authors present an elegant but very stripped-down instruction set, slightly reminiscent of the PDP-8, and an equally stripped-down hardware description language (HDL). The exercise is to implement that processor using that HDL, and verify it using a simulator the authors provide. Next, the student implements the assembler for that instruction set, an interpreter in the spirit of the Java Virtual Machine, a compiler, and a simple operating system. Although each project could be a term course in itself, the authors display a real knack for extracting the essentials of each and boiling them down to a minimal but functional kernel. The results, although they might be toy systems, demonstrate the framework around which larger, industrial systems would be built. I've taught HDL-based logic design, operating systems, and object-oriented design. Each level of system implementation makes sense only in terms of the levels above and below it, but each is normally taught in isolation. This leaves an odd lack of context and motivation. It never explains to a processor designer what hardware support an OS needs, never explains to the OS implementor what the hardware can (and can't) do, or what the application developer requires. This philosophy even lets computer science students graduate in ignorance of or disdainful of the hardware on which their whole career depends. And, at every level, crucial basics like "what is a stack frame?" go unexplained and unexplored. This book is the only one I know that not only explains but demonstrates how the pieces fit together. I suppose there are many ways to use this book. I imagine it as a course for well-prepared and motivated third-year students, the ones who've seen all the basics, need something to forge the pieces into a meaningful whole, and who can still choose more coursework based on what they learn here. It would also be helpful for software types thrown into embedded development or for any engineer who wants a fuller understanding of what the computing platform really is. This has my highest recommendation. -- wiredweird

The book, The Elements of Computing Systems: Building a Modern Computer from First Principles, is a book on Computer Design by Noam Nisan and Shimon Schocken both of the Efi Arazi School of Computer Science at IDC Herzliya University in Israel. It is meant for undergraduate students as a one or two semester introductory course or as a one semester course for non-computer science graduate students. While their first-principles approach is novel it often glosses over some of the finer aspects of logic design. The architecture they developed for their "from scratch" computer system is unlike any real-world microprocessors their students may encounter when they graduate and start working in industry. There are some errors in the text. For example, in Section 4.2, they describe their "Hack" computer as a von Neumann architecture, while, in fact, it is a Harvard architecture since it has separate program and data memories. Von Neumann machines use the same main memory for both data and program storage. These details are given only a one sentence explanation in the text and there is no discussion about hybrid architectures and the reasons one would have for making such design choices. Techniques like gate minimization using Karnaugh Maps is not mentioned. Their ALU design uses the ADD function to perform certain operations where an AND would produce the same result more efficiently and with greater speed. No mention is made of carry ripple and the look-ahead carry methods which would make the design more efficient. Although look-ahead carry designs may be too advanced for an introductory text, an overview paragraph would have been helpful. The Hardware Description Language (HDL) of their own design is often not fast enough to run simulations of complex logic and must be supplemented by using canned routines written in the base language from which their HDL is constructed in order for the hardware simulator to run in reasonable times. Flip-Flops fall into this category and no discussion is given for the different types such as R-S, J-K flip-flops and their advantages and disadvantages. To be fair, an ambitious text which is as broad as this one has to sacrifice details for scope to fit the information into a timeline as short as one or two semesters. All-in-all, despite it's shortcomings, I would recommend this book for use in undergraduate studies only if the information is supplemented with other courses with a narrower scope and greater depth.

I always wanted to understand the entire breadth of computing, in a hands on manner. This book let me do that to precision. The sheer amount of effort put in by the team behind this book is laudable. You first actually build the hardware, then build a compiler and then the OS. These three are really the building blocks, the foundations and the through understanding of these subjects will make you a brilliant (understated) professional. A few tips: Actually work through this book, chapter wise, step wise. Do not skip any step, especially right upto chapter 8. Based upon your programming experience, you may prefer to skip the projects from chapter 9 onwards (not recommended). I worked through the book in sequence right upto chapter 8 and have kept chapters 10,11, 12 as later weekend projects. Simply because I have sufficient programming experience using Lisp and other languages, with some experience in parsing complex inputs. As a side effect, being a Lisp programmer, it helped me understand at a gut level why homoiconic languages are 'actually' better even in context of compiler construction. Is it not a design decision to choose a simple grammar? This book will help you figure it out. Other tips: This book may be hard or easy based upon two things: 1. Your prior digital electronics knowledge. 2. The richness of your prior programming experience. 3. This book will not spoon feed you. 4. The projects are extremely fun because you are nudged only enough. For me this is a book which has turned the tide to explain the foundations of computing It is a MUST WORK THROUGH book. For me its right up there with the other gem "SICP". What it will not go into is 'Networking' and 'Persistent Disk Storage'. But that in no way comes in building the foundations as the other foundational concepts apply to these two areas and others as well. By the way the authors have proposed these as extensions. So you could actually spend a weekend or two, building graphics, networking chips and adding these facilities to your OS. Interesting. Hats off to the team for producing a GEM.

I've been a computer hobbyist since the first days of the Apple ][, and have dabbled in everything from programming to circuit board design. Despite all that time spent, there have always been huge holes in my understanding. In the back of my mind, I've always dreamed of building a simple computer from a handful of chips, designing an operating system for it, and using it to write programs. Unfortunately, the complexity of the task always seemed overwhelming. Assembly language, stack arithmetic, compiler design - all seemed much too intimidating to seriously approach. But no longer. This book guides the reader on a journey from the basics of boolean logic and elementary gates through CPU design, assembly, virtual machines, high level languages, compilers and operating systems. How can such a task be accomplished in one 300-page volume? Simple - you do most of the work yourself. The relatively short chapters introduce each concept and suggest an approach to implementation. The reader is then given a project to complete and test. Intimidated by assembly language? You probably won't be after you've written a symbolic assembler. Confused by compilers? Imagine how you'll feel when you realize you've created one for a simple (but completely usable) high-level language. Some degree of familiarity with a programming language will be needed to complete all of the later projects in this book. I used Java, and it worked like a charm. I'm just about finished with the book, and I'm trying to decide what to do next. I'm actually sad to be almost done! I plan to fulfill that original dream of building an actual computer from scratch - several modern microcontrollers can handle video output and keyboard input, so I think it will be doable. I feel pretty confident that after completing this book I'll be able to create a basic operating system and development toolset, which I can then spend countless hours extending! In summary, if you want to gain an understanding of how computers really work, and if you're willing to learn by doing, this is the best book I've ever seen. I wish I could shake the authors' hands to thank them personally.

I'm hoping and praying these authors do a new edition, but in the meantime, they have been beyond ethical in keeping the web resources up to date, even at this writing. Way beyond that really, because the material on the web is SO much more than "supplemental" -- it includes the entire text, .pdf lessons, and if you're an autodidact or teacher, complete teaching materials! If you check out the wonderful Amazon "look inside" feature, you'll see an out of date website, but it still forwards to the new site (the old one is the ldc dot ac, the new one is nand2tetris dot org). The nand2 is a symbol for the fact that you can start all the way from a nand gate and build your virtual machine to run your own programmed tetris game! For Raspberry and Arduino (or Propeller) buffs like me, although this project is all virtual (no physical circuits), the authors have taken nearly 10 years to perfect the sim interfaces to make the experience far more complete than even building a PC from components, or hacking with our favorite chips and boards. This book is the PC version of the now famous Max Maxfield books that teach us to build a virtual calculator (

Getting through this book takes a considerably amount of time, but very rewarding. I assume you already read the description on what this books is, so I won't repeat that here. I had a pretty good understanding of Boolean algebra and programming... so I can't really speak to how much more of a challenge this would be for somebody that doesn't. The books starts with a little overview of Boolean algebra, but I imagine it would still be significantly more difficult, as the last few chapters absolutely require some existing programming knowledge. Every chapter has exercises that requires work. I wouldn't really recommend this book if you aren't planning on doing these. First and foremost, this is a textbook and should be used with its associated website (www.nand2tetris.org/). It *is* what makes this book as good as it is. The premise of the book is that you start with a NAND viewed as a black box, and everything is built from there. Using NANDs to built the remaining basic gates, using those to build ALUs and CPUs, creating an assembler, virtual machine, and then a compiler. The author states that the idea of 'how' the NAND gate is built is more of the domain of the physicists and electrical engineers... not the computer scientists. So, they assuming the read largely just takes this for grated. They also end up doing something similar with the data flip-flop. Personally, I would have liked to see a little more explanation on how these are implemented to give me a little better sense that I could actually build my own CPU giving the resources, time and drive. But, overall, a book I can't more highly recommend to anybody wanting to understand how computers work.

I've been programming for 20+ years, but never went closer to metal than Basic, or occasionally C, but never anything in depth. Instead I've been playing around in the higher levels of abstraction and building apps, web stuff, and services. This book gave me a depth of understanding for why the lower level abstractions are what they are. (Why use powers of two? I knew binary representation of data is a thing, but it turns out there are very strong hardware optimization motivations) If you're a developer and you want to get a clear picture of how components work with code, this will give you that and more. The companion simulation material (downloadable from their website) is also well thought out, optimized towards the user learning as quickly as possible, and surprisingly robust. I wish I were a better writer so I could give a more glowing and detailed review, but I will definitely recommend this book to mentees and newcomers for the forseeable future. You build logic gates, higher level chips (ALU, RAM), a machine language, a CPU, an assembly language, compilers and a high level language... You literally build a computer. Talk about hands on learning! The subtitle "Nand to Tetris" is no joke. That's literally the breadth of what this book gives you.

This book is an unparalleled companion in explaining, piece-by-piece, how you can build a somewhat realistic computer from the ground up in a way that is tremendously satisfying. However, it does kind of fall apart at the end, and it's difficult to finish without outside resources. Still, as a concise guide, it is unparalleled, and I am extremely happy I went on this journey, even if it kind of runs out of steam at the end. 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).

Had a hard time understanding how the Facebook and my toaster worked, felt left behind by these kids nowadays with their TikToks and their NFPs or MFTs whatever they are called, but this book brought me up to speed ! Gotta keep learning in these changing times.

I wanted to learn some programming languages and concepts to make my Technical Writer resume meatier. Problem was, any attempt to learn Python, SOAP, or MySQL just lead me to ask a million questions about how this stuff actually worked beneath the straightforward, high-level application stack: How does this code interact with the OS? How do lines of text get turned into binary instructions? How does all this abstract graphics, text, and data actually meet up with electrical signals and semiconductors? It has to at some point, right? It's not magic, right? (And so on). 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.

When I say "survey," I mean a wide-ranging view of what goes into a computing system. This unique book goes into more depth than the word suggests, though, since it presents every level as a project for the student to carry out. This starts with the processor: the authors present an elegant but very stripped-down instruction set, slightly reminiscent of the PDP-8, and an equally stripped-down hardware description language (HDL). The exercise is to implement that processor using that HDL, and verify it using a simulator the authors provide. Next, the student implements the assembler for that instruction set, an interpreter in the spirit of the Java Virtual Machine, a compiler, and a simple operating system. Although each project could be a term course in itself, the authors display a real knack for extracting the essentials of each and boiling them down to a minimal but functional kernel. The results, although they might be toy systems, demonstrate the framework around which larger, industrial systems would be built. I've taught HDL-based logic design, operating systems, and object-oriented design. Each level of system implementation makes sense only in terms of the levels above and below it, but each is normally taught in isolation. This leaves an odd lack of context and motivation. It never explains to a processor designer what hardware support an OS needs, never explains to the OS implementor what the hardware can (and can't) do, or what the application developer requires. This philosophy even lets computer science students graduate in ignorance of or disdainful of the hardware on which their whole career depends. And, at every level, crucial basics like "what is a stack frame?" go unexplained and unexplored. This book is the only one I know that not only explains but demonstrates how the pieces fit together. I suppose there are many ways to use this book. I imagine it as a course for well-prepared and motivated third-year students, the ones who've seen all the basics, need something to forge the pieces into a meaningful whole, and who can still choose more coursework based on what they learn here. It would also be helpful for software types thrown into embedded development or for any engineer who wants a fuller understanding of what the computing platform really is. This has my highest recommendation. -- wiredweird

The book, The Elements of Computing Systems: Building a Modern Computer from First Principles, is a book on Computer Design by Noam Nisan and Shimon Schocken both of the Efi Arazi School of Computer Science at IDC Herzliya University in Israel. It is meant for undergraduate students as a one or two semester introductory course or as a one semester course for non-computer science graduate students. While their first-principles approach is novel it often glosses over some of the finer aspects of logic design. The architecture they developed for their "from scratch" computer system is unlike any real-world microprocessors their students may encounter when they graduate and start working in industry. There are some errors in the text. For example, in Section 4.2, they describe their "Hack" computer as a von Neumann architecture, while, in fact, it is a Harvard architecture since it has separate program and data memories. Von Neumann machines use the same main memory for both data and program storage. These details are given only a one sentence explanation in the text and there is no discussion about hybrid architectures and the reasons one would have for making such design choices. Techniques like gate minimization using Karnaugh Maps is not mentioned. Their ALU design uses the ADD function to perform certain operations where an AND would produce the same result more efficiently and with greater speed. No mention is made of carry ripple and the look-ahead carry methods which would make the design more efficient. Although look-ahead carry designs may be too advanced for an introductory text, an overview paragraph would have been helpful. The Hardware Description Language (HDL) of their own design is often not fast enough to run simulations of complex logic and must be supplemented by using canned routines written in the base language from which their HDL is constructed in order for the hardware simulator to run in reasonable times. Flip-Flops fall into this category and no discussion is given for the different types such as R-S, J-K flip-flops and their advantages and disadvantages. To be fair, an ambitious text which is as broad as this one has to sacrifice details for scope to fit the information into a timeline as short as one or two semesters. All-in-all, despite it's shortcomings, I would recommend this book for use in undergraduate studies only if the information is supplemented with other courses with a narrower scope and greater depth.

I always wanted to understand the entire breadth of computing, in a hands on manner. This book let me do that to precision. The sheer amount of effort put in by the team behind this book is laudable. You first actually build the hardware, then build a compiler and then the OS. These three are really the building blocks, the foundations and the through understanding of these subjects will make you a brilliant (understated) professional. A few tips: Actually work through this book, chapter wise, step wise. Do not skip any step, especially right upto chapter 8. Based upon your programming experience, you may prefer to skip the projects from chapter 9 onwards (not recommended). I worked through the book in sequence right upto chapter 8 and have kept chapters 10,11, 12 as later weekend projects. Simply because I have sufficient programming experience using Lisp and other languages, with some experience in parsing complex inputs. As a side effect, being a Lisp programmer, it helped me understand at a gut level why homoiconic languages are 'actually' better even in context of compiler construction. Is it not a design decision to choose a simple grammar? This book will help you figure it out. Other tips: This book may be hard or easy based upon two things: 1. Your prior digital electronics knowledge. 2. The richness of your prior programming experience. 3. This book will not spoon feed you. 4. The projects are extremely fun because you are nudged only enough. For me this is a book which has turned the tide to explain the foundations of computing It is a MUST WORK THROUGH book. For me its right up there with the other gem "SICP". What it will not go into is 'Networking' and 'Persistent Disk Storage'. But that in no way comes in building the foundations as the other foundational concepts apply to these two areas and others as well. By the way the authors have proposed these as extensions. So you could actually spend a weekend or two, building graphics, networking chips and adding these facilities to your OS. Interesting. Hats off to the team for producing a GEM.

I've been a computer hobbyist since the first days of the Apple ][, and have dabbled in everything from programming to circuit board design. Despite all that time spent, there have always been huge holes in my understanding. In the back of my mind, I've always dreamed of building a simple computer from a handful of chips, designing an operating system for it, and using it to write programs. Unfortunately, the complexity of the task always seemed overwhelming. Assembly language, stack arithmetic, compiler design - all seemed much too intimidating to seriously approach. But no longer. This book guides the reader on a journey from the basics of boolean logic and elementary gates through CPU design, assembly, virtual machines, high level languages, compilers and operating systems. How can such a task be accomplished in one 300-page volume? Simple - you do most of the work yourself. The relatively short chapters introduce each concept and suggest an approach to implementation. The reader is then given a project to complete and test. Intimidated by assembly language? You probably won't be after you've written a symbolic assembler. Confused by compilers? Imagine how you'll feel when you realize you've created one for a simple (but completely usable) high-level language. Some degree of familiarity with a programming language will be needed to complete all of the later projects in this book. I used Java, and it worked like a charm. I'm just about finished with the book, and I'm trying to decide what to do next. I'm actually sad to be almost done! I plan to fulfill that original dream of building an actual computer from scratch - several modern microcontrollers can handle video output and keyboard input, so I think it will be doable. I feel pretty confident that after completing this book I'll be able to create a basic operating system and development toolset, which I can then spend countless hours extending! In summary, if you want to gain an understanding of how computers really work, and if you're willing to learn by doing, this is the best book I've ever seen. I wish I could shake the authors' hands to thank them personally.

I'm hoping and praying these authors do a new edition, but in the meantime, they have been beyond ethical in keeping the web resources up to date, even at this writing. Way beyond that really, because the material on the web is SO much more than "supplemental" -- it includes the entire text, .pdf lessons, and if you're an autodidact or teacher, complete teaching materials! If you check out the wonderful Amazon "look inside" feature, you'll see an out of date website, but it still forwards to the new site (the old one is the ldc dot ac, the new one is nand2tetris dot org). The nand2 is a symbol for the fact that you can start all the way from a nand gate and build your virtual machine to run your own programmed tetris game! For Raspberry and Arduino (or Propeller) buffs like me, although this project is all virtual (no physical circuits), the authors have taken nearly 10 years to perfect the sim interfaces to make the experience far more complete than even building a PC from components, or hacking with our favorite chips and boards. This book is the PC version of the now famous Max Maxfield books that teach us to build a virtual calculator (

Getting through this book takes a considerably amount of time, but very rewarding. I assume you already read the description on what this books is, so I won't repeat that here. I had a pretty good understanding of Boolean algebra and programming... so I can't really speak to how much more of a challenge this would be for somebody that doesn't. The books starts with a little overview of Boolean algebra, but I imagine it would still be significantly more difficult, as the last few chapters absolutely require some existing programming knowledge. Every chapter has exercises that requires work. I wouldn't really recommend this book if you aren't planning on doing these. First and foremost, this is a textbook and should be used with its associated website (www.nand2tetris.org/). It *is* what makes this book as good as it is. The premise of the book is that you start with a NAND viewed as a black box, and everything is built from there. Using NANDs to built the remaining basic gates, using those to build ALUs and CPUs, creating an assembler, virtual machine, and then a compiler. The author states that the idea of 'how' the NAND gate is built is more of the domain of the physicists and electrical engineers... not the computer scientists. So, they assuming the read largely just takes this for grated. They also end up doing something similar with the data flip-flop. Personally, I would have liked to see a little more explanation on how these are implemented to give me a little better sense that I could actually build my own CPU giving the resources, time and drive. But, overall, a book I can't more highly recommend to anybody wanting to understand how computers work.

I've been programming for 20+ years, but never went closer to metal than Basic, or occasionally C, but never anything in depth. Instead I've been playing around in the higher levels of abstraction and building apps, web stuff, and services. This book gave me a depth of understanding for why the lower level abstractions are what they are. (Why use powers of two? I knew binary representation of data is a thing, but it turns out there are very strong hardware optimization motivations) If you're a developer and you want to get a clear picture of how components work with code, this will give you that and more. The companion simulation material (downloadable from their website) is also well thought out, optimized towards the user learning as quickly as possible, and surprisingly robust. I wish I were a better writer so I could give a more glowing and detailed review, but I will definitely recommend this book to mentees and newcomers for the forseeable future. You build logic gates, higher level chips (ALU, RAM), a machine language, a CPU, an assembly language, compilers and a high level language... You literally build a computer. Talk about hands on learning! The subtitle "Nand to Tetris" is no joke. That's literally the breadth of what this book gives you.

I bought this book on a whim, but I did not expect it to contain all that it does. Having read several chapters and having completed the first couple of projects I can say that this book contains an outstanding learning experience. In fact, I would highly recommend this book to anyone who wants to learn the basics of computing. I teach mathematics at the college level, but computer science and the history of computing is a hobby. I also develop math software and do Windows programming and my background includes working on a chip for one of Hewlett-Packard's programmable calculators. I often have students ask how they can learn more about computers because after they take the basic language and programming courses my school offers they know they need more. In fact, few of them can write real-world software because they don't have sufficient experience with a Graphical User Interface like Windows and even fewer of them have a clue as to what an Instruction Pointer is or how the hardware in a CPU works or how subroutine return addresses can be built on a LIFO stack. Telling these students to either study symbolic logic or assembly language or to start reading Knuth's books is not very helpful because these activities are way too hard to do on your own. Having them read about Babbage and Turing can be motivating, but does not bring them close to either the real hardware or the real software. This book is outstanding in its approach and its implementation. Once you get hooked on this you can go very far. This book builds a solid foundation and provides the deeper understanding that students really need. I compliment the authors and all those who worked on this project to make it a reality. It is simply outstandingly effective. There is nothing like it that I have ever seen.

I have nothing but the most positive things to say about The Elements of Computing Systems. If you ever wanted to know how a computer worked -- I mean REALLY know -- read Charles Petzold's book CODE. If you also wanted to BUILD a computer, read The Elements of Computing Systems. This book takes you from a single basic logic gate to a working computer, then proceeds to design software and even a simple operating system that runs on it. (Caveat: there are 2 things you do not create yourself: the system clock and the base module for flip-flops. There's a good reason why for each. Again, to understand these parts better, I highly recommend Petzold's CODE.) All chapters are independent and can be done in any order, but the order they have it in is best. I think the authors intend for TECS to be a textbook for a class but I'm reading it on my own and it's perfect for self study. Before you read, make sure you consult the book's website's errata because there are a few typos. I also have nothing but the highest praises for the accompanying software. The authors make freely available a small open source software suite to help develop the computer you're making. Full tutorials are online. The test suites are fully scriptable. The scripts for actually testing your work are included and there's also an appendix in the book explaining the scripting language used. The software is all written in Java and will run on Windows, Linux, or Mac. Everything is kept as simple as possible without sacrificing any understanding. A perfect learning tool.

I'm sure this is a great book based on the other reviews here. However, there is a subtle but important typo on page 8 in the "Canonical Representation" of the boolean function. The "NOT" symbol is not visible. As a result, the formula makes no sense. A beginner reading this section will not understand how the canonical representation of the boolean function was derived.

Let me first say this; most people view computers as glitter. Much like the engine of a car, most people do not understand the discreet components that make up a modern computer, or how they work together to do what we want them to. Even if someone knows how to program a high level language or knows a lot about computers, they will often have no concept of what is going on at a lower level, or how the processor does what it does with memory access and calculations. Few books do justice in explaining the large set of abstractions that make up our computers. That being said, this is a very well written book, the author gives great explanations no matter what your background knowledge. I picked up this book with several years of programming experience and basic knowledge of logic gates and arithmetic logic units. Each chapter in this book helps understand the abstraction between the layers it deals with, giving you a working knowledge from transistors to high level languages and the implementations and interfaces of everything in between. If you want to get into computer engineering or if you just want a profound understanding of how computers work, you have to read this book.

I've been using this book to review "how it works" with my two (now adult) children, both of whom are interested in Computer Science as a career path. The book is well written and the on-line video tutorials available on YouTube add extra value. I've been through similar material in my formal education and career, but have been enjoying re-discovering the basic elements of computing using this book with my kid's.

I took a course which was using this as a text book when I was an undergrad (HUJI), and the hands-on approach for learning everything from logic with digital circuits to elementary operating systems was appealing and tremendously helpful for gaining this important knowledge. It remained my favorite textbook ever since, and I still use it sometimes as a reference to demonstrate the basic concepts to students and peers. The effort in preparing the exercises and test applications is evident, and I highly recommend this book to any CS graduate seeking insight into the low-level workings of a modern computer system.

This is the only text I know of that walks up the entire stack - from logic gates to the OS - and has you actually implement each layer. It is not really a text book in the traditional sense but rather more of a lab book. The authors give just enough information (just a few pages) to complete each of the projects. It is the projects (and the accompanying software from the book's website - which runs flawlessly) that make this book really work. You are not going to get much out of the book if you don't do the projects. These projects are not end of chapter exercises that test if you understood what you've read. Nearly all of the understanding you get will come from doing the projects and the book is written with this intent. That's why it really is a lab book - you'll learn from doing rather than from reading. This book will give you a gut for how computation systems work and are designed. The text doesn't have the breadth or depth that you would get from the traditional textbooks on these subjects (digital design, computer architecture, compilers, and operating systems) but it gives an intuition (because you actually implement each layer) that you can't get from simply reading a book[s].

I've been programming for about three years now, and have picked up a few different languages in that time, including Python and Java. I didn't study Computer Science in college however, so although I knew how to write code to perform certain tasks I didn't truly understand how that code was ultimately being executed on my computer. My curiosity eventually led me to purchasing this book and I am extremely happy with that decision. Going all the way from simple logic gates to writing a compiler and standard library for your own programming language this book explains, in a very approachable way, how the code in the high level languages people write in is translated into machine code and run on hardware. I now feel I understand how all the pieces in this chain work, if only at a high level. I would highly recommend this book to anyone who may not have a thorough computer science background but is familiar and interested in programming languages.

First, realize that I am a cynic. I was prepared for a critical response from my students regarding the TECS class I conducted last semester (Spring 2010). However, the results were _fantastic_. I had multiple opportunities to see the "lightbulb come on" for our students. They finally understood many topics that our other classes, such as "Computer Organization," only briefly describe. I had one 17-year-old high school student, two graduate students from outside the CS department, and about sixteen upper-level CS undergraduates. The high school student really received a postmodern computer science education in one semester. However, although she grasped the concepts, she lacked the proper programming experience necessary to be independently successful when working on the software side of the material. This was remedied by pair programming. My two non-CS graduates _loved_ the class and were very successful. It was "just the class they were looking for." As for my CS undergraduates, it has been a smashing success. They all emphatically felt that the class should be a required part of our curriculum and the class is now an official elective and will be taught again in the fall of 2011. If you only read one effective book in the field of computer science, this might be the one.

Like many reviewers here, I picked up this book as part of the teachyourselfcs.com reading curriculum. I was truly blown away by the first book in that curriculum, so I approached this textbook with a high set of expectations. I came away a little underwhelmed. There's a lot of artifice to this book—contrived examples and languages, abstract problem sets, etc.—that set out with an agenda to help you create a 'full' computer. The book succeeds at this agenda, but I think it readers would be better served with a lot more of the content found in the 'Perspective' section of each chapter. This is really a cursory look at computer architecture and I feel like I still need to read another book or two before things will really dawn on me. For certain topics, like logic gates, I'm not sure reading is even the best format. That kind of content really lends itself to YouTube videos and online animations. I hope I find some of those out there!

I have used this book in my computer organization class (Istanbul Bilgi University, Computer Science dept.) and I must admit that it brought a very fresh perspective to second year computer science students. For the first time they were able to see the process of designing a computer from the ground up. The book is very suitable for self-study or classroom use: it has an excellent website, all the required HDL simulator, assembler, CPU and VM emulator and compiler are freely available and easy to run on any platform (they are all coded in Java). Of course there are simplifications such as the lack of interrupts and multhithreading but this book prepares the students very well for 3rd and 4th year courses. Every chapter has very well and clearly defined goals and projects that are %100 self-contained. That means even if you skip a chapter you can work out the next project without any loss in implementation. If you or your students want to have a grasp what it means to build a computer starting from logic gates, hardware definition languages, up to the ALU, RAM, CPU, assembler, virtual machine and compilation of an object oriented high level language, then this book is the best choice. It is one of the most hands-on book I've ever seen in this subject matter and at that intermediate level.

Wonderful book I have been using for self-study. For someone like me with a math and programming background but close to zero knowledge on how computers are built from the transistor level up, it fills the gaps very nicely. Yes, it can be difficult at times as the authors do not spoon feed every problem and much is left as "an exercise for the reader", but nothing that some thinking time won't fix. Plus lots of comments and posts can be found on the web when you really do get stuck. The book is well written, and the goals, contrary to some other reviewer's opinions, are actually very well laid out over the chapters. I highly recommend this book to anyone who wants to learn the basics of how computers are built from the ground up all the way to creating a compiler and an OS.

The best way of learning is learning by doing , and it is about this book. I have purchased it in order to accompany me through completely free computer science course from nand to tetris www.nand2tetris.org , the same course now is available on coursera. If you want to understand how computer works, what is the logic and steps that computer do, you will find all this answers by first designing cheaps from simple logical gate nand , then building ALU and finally hack computer , but that is the half of the journey , when you will leave hardware word into software development word , you will write your own programming language, compiler ,OS and in the end design games as culmination of the journey. Just incredible book!

I didn't really understand this book at first. I think before you go and read this book or purchase it. Go to their web site and read through it first. I also found that Code: The hidden language of computer hardware and software was a much more engaging book. The first part of the book has a lot of history. However, I found after reading some of the history it gives you amazing insight to the how modern technology works. So I found the first 9 chapters enlightening and easy to understand.

As a software engineer with over 30 years experience, I have to say this course is great fun. I am amazed at how much coverage is given to such a wide variety of topics. Going from logic gate construction to building a rich programming language and run-time environment is not an easy task. It succeeds in just 12 chapters. I am impressed with the amount of work that must have gone into its creation. It also does a great job introducing concepts like Boolean logic, 2s complement arithmetic, clocking, machine and assembler code, pointer arithmetic, language tokenization and parsing, stack processing, and virtual machines. I wish I'd had something like this when I was starting out. I strongly recommend it to anyone who is.

Do you feel like you know a lot about computer engineering, but you have gaps in your knowledge? If so, this book is perfect for you. Complete the exercises and you will find the experience to be entertaining and productive.

This book was perfect for me because it required only a basic understanding of programming for the later chapters and taught the rest. So far, I have read the entire book but the highest-level project that I have completed so far was the ALU. It was very satisfying to see the ALU test complete without errors. I have also learned a great deal about how computers work in the process. This book demystifies the black box that is the modern computer and gave me a greater appreciation for what goes on behind the curtain. I plan to continue and complete all the projects in the book. For the sections involving logic gates, it helped me greatly to use a logic circuit simulator in the design process (I used logic.ly) so keep this in mind.

The Elements of Computing Systems offers a good introduction into the basic principles of computers and software. The lab work, which can be downloaded from their site, actually lets you build the various logic gates and computer components using a Hardware Simulation Language. However, building the component pieces is not easy and there is little direction given in the text on how to create these components. The download does come with a prebuilt set of components that can be used and tested so building the components from scratch is not absolutely necessary. Overall, I found this book to be very interesting and quyite helpful in learning the basics of computing systems.

If you want to understand how a computer works from the bottom up, this is the book for you. From the basic NAND logic gate, all the way up to an operating system this book (and the accompanying website) give you the tools you need to build each layer. Sometimes I found it difficult to understand some of the concepts without a background in computer science, but with perseverance you can build a whole computer system and really understand how your computer works.

I really enjoyed this book. Though it is well written and thorough, saying that doesn't quite do it justice. The book is more than just a nuts & bolts introduction to the titular "elements of computing systems." It ends up being a deep and subtle overview of the informational and design philosophies behind computing. It shows you the fundamentally simple patterns & processes that are the foundation of all our contemporary hardware & software. And it does this without wading into hardcore mathematical computing theory (which is not to deny the importance of that material, but it's not that helpful in an introductory book). So it manages the great trick of being both sophisticated and approachable. Whether you do the exercises or not (I didn't), it's a great book for anyone curious about the underpinnings of computing.

The books makes building a computer from chips so easy I was actually disappointed in the best possible way.

Used this book for COMP_255: Computer Organization and Archetecture at Wittenberg University in Springfield, OH, and it was worth every penny. This more concisely and simply explained sometimes confusing concepts pertaining to Computer Science, and the NAND2Tetris software that you can download for free online is excellent at explaining and introducing the concept of logic gates and general computer logic. Many important computer science concepts are covered in this text, and I feel it did a way better job at explaining the material than my dominant course text did. I would recommend this to people not only who need it for a course, but people interested in computer science in general! A+!

I was looking for a programming book that integrated my background in assembler and C, with more logic circuits and electronics. Well, I found it! This book starts with the smallest components,such as multiplexers and adders and slowly builds up a an instruction set on this new computer. Its all virtualized so you can't burn any components, and it really helps on building a foundation for assembler coding. Its so detailed , it helps you build your first language - HDL. With a foundation like this , you could take on most any startup research project and write embedded C for drivers.

Kindle version doesn't come with software, of course, but this is a great course. Makes me want to build my own. Compared to a similar book "but how do it know" this goes farther into the software. Compiler and OS are basic, but enough to get through basic concepts.

I think I will have to give up my day job to engage in this project. I got through the first chapter. It took a lot of effort to figure out stuff like 'put the information into the simulator' without telling you how. The authors have written for PC so getting things to happen on an iMac all takes time. I want to do it and I probably will. The time or possibly my wife is going to kill me.

The book is amazing for learning computer architectures! Walks you forward in as good as a way as I could have asked for or imagined was practical. Perhaps the best part is the free software that comes online (nand2tetris). Though I wouldn't recommend it, you could absolutely skip class with a textbook like this.

Superb book! One of the best in the category of introduction to computer systems. A must for a software engineer's personal library.

This book is a companion to the course at nand2tetris.org You can actually read the first seven or so chapters there, to see if it's something that would help you, but the course and book, along with the projects, is invaluable for anyone looking to better understand computers. The projects aren't too hard, but they definitely make you stretch to do them, and the idea of building an entire computing system from parts with guidance is awesome. Some other books may go deeper into logic and the physical components, but this is one of the best I've seen for a beginner.

I only worked my way up to chapter 5 where you build a CPU from parts created in previous chapters as that is all I was interested in. I felt like the projects were great for easing you into concepts to build on. I don't need to write a 2000 word review on this, it's a cheap enough book if you are interested in the subject matter.

I bought this book for my "Computer Organization" class. It has a web site with projects and power point slides, and downloadable circuit and machine language simulator. Not suitable for self-study, because the projects are difficult and need instructor's guidance.

It is an introductory and very comprehensive book in the area of computer systems. It is easy to understand. The way it splits a computer system into different layers of abstraction and the way it explains those layers, makes those complex systems easy to understand.

This book is well written, and easy to understand. Noam Nisan presents the complexities of a computer in such a way that 'how they work becomes clear'. This book is great for people of any background. I am a Computer Science graduate, and related to how a lot of people coming out of universities have a niche understanding - strong understanding of various comp sci 'modules', but a sort of missing the forest appreciation for the trees. This book has changed that, and I strongly recommend it to you!

This book is an absolute must read for anyone interested in computer science

This is an awesome book that I'm thoroughly enjoying so far. Gives a great view of how hardware + software fit together without going into too much technical detail. It really is the 10,000 foot view that integrates what is often left as separate parts. This book is a great starting point and a compliment to other books, for example LaMothe's "Black Art Of Video Game Console Design".

The text is written well, simple and not boring. The idea of building a computer from nand gates to a running an application on an OS is an epic challenge. It isn't enough to just read the principles, but you need to use them. That's where the beauty of the whole package is.

This is an incredible book! Check out the complete course (in two parts) on Coursera. It is challenging, but well worth the effort. If you're curious about how a computer really works, this is the book to read. Enjoy!!

Every bit as good as it sounds. As someone with a degree in the subject matter this book is a great introduction to the material.

The text is good, but the explanations and the companion tools that come with the course could be better. For example, resizing tools often doesn't do anything useful, and some text, like errors, are too long for the allowed display and cannot be read.

This is the book I was screaming at the moon for when I was 12. Better 49 years late than never.

Thank you.

I came away from this book with a deep understanding of basic boolean logic. If you give me enough transistors, I'm completely sure I could build a computer out of them.

Great book, clear and concise - there's also helpful sections at the end of the chapters to help you get started with the project :-) 10 for 10 would recommend...who knew computer systems/organization could be so fun!

An excellent "soup to nuts" survey of computing system components. The projects are both challenging and interesting. Unless you already have a computer science/engineering degree, you *will* get lost and frustrated at times, but there is plenty of support in the user forums to keep you moving in the right direction.

One of my favorite computer science books out there. You have to put in a little work as you follow along, implementing the computer system outlined step-by-step, but the result is absolutely worth it.

Great book, associated with an amazing online course. Both strongly recommended.

Bought as gift

I liked the order on how the book takes you step by step from nand to tetris. it makes you realize that understanding and learning hdl is really important

I was going to give this book 3 stars but felt that would be disingenuous to those wanting to know about this book. This is purportedly a 'teaching' book. As a former college teacher, I fully understand it's the role of the instructor to build a lattice and let the student flesh it out. Such is NOT the case with this book. The reader is pummeled with extraneous information and left to wonder exactly what the goals are. As stated by another reviewer, a judicious selection of books on hardware, programming, etc. would be a better use of one's funds than the purchase of this book.

Ended up using this as the primary text last fall for a course on Machine Organization and Computer Achitecture. It's an excellent book, and the accompanying software suite (free on the associated website) worked very well.

I was lucky having gone to school at a time when it was still relatively easy to understand a computer from scratch, something being lost today and which this book can bring back to the current generation of students and enthusiasts. Very highly recommended.

If you love computers and computer science then you will love the way this book is put together and the information that it presents. A must have for anybody just starting up but a great read for someone who already has some degree of knowledge regarding computers and programming.

This is a fantastic piece of work. In my opinion, it reflects how the education should be. The content is great, very well explained. The challenges are great as well. The idea behind education thru self discovery in a given/propicious enviroment really works.

Reading this makes it clear that AI will never be confused with Artificial Consciousness! It even casts doubt of the validity of human consciousness. Excellent book, essential for any educated person in these times.

Great book for shrinking the conceptual black box of a CPU down to a conceptual black box of NAND chips.

I find this book to be highly informative and challenging, and it is not for just a casual inspection. The book is intended to be a multi-semester text book and so requires more individual effort than may be expected.

Hours of endless joy :-) If you've been in the field for a few years, some of this stuff might not be anything new, but that doesn't make it any less fun to work through.

One of the best books for computer science

As a system architect with no classical Computer Science training, this book filled the chasm of knowledge my brain needed to connect electrical circuitry to the seemingly esoteric world of data manipulation.

very good

This book, and the course on which it's based,covered double the information, in about half of the time, as my senior-level Operating Systems college class. Of course, I took the class twenty years ago, but that just goes to show how much better organized, and knowledgeable the industry has become in that time.

：）

Very good book with solid, professional approach.

This book does a highly effective job of breaking down Computer Science concepts into easily digestible segments. I'd highly recommend this book to anyone interested in computing systems and programming.

Awesome book, describes how the rubber meets the road so to speak (or silicon meets code?). Great to see what really goes on under the hood, how code maps to hardware.

Still looking nice and new to me!

This book is a great resource.

Very clar book.

The book takes you in an amazing journey to a world that very few people can see now days, the inner world of computers.

This course is fantastic.

A little out of date, but still a good starting place for the electronically curious. not all the links worked, but i found the software via google.

Still studying the book but so far it is great.

Learn how to build a simple computer from his bones to the top. Sometimes frustrating, but very satisfying when you succeed come to the finished product.

This book tries to do too much, many details are left out and the reader is left with only a cursory understanding of the material. Its better to buy separate, dedicated books on computer architecture, assembly language, compilers, and operating systems, in my view. Digital design and Computer Architecture by Harris is probably a better choice.

Great book! Working with my son. He starts college in August on his CS degree.

Hands-on understanding of the principle of computers. Text book well structured and accessible to anyone keen on learning this topic.

good insight into the working of a computer

User with Coursera.org course

A joy to read.

Excellent. A step-by-step explanation for building a computer, suitable both for non technical people and skilled ones. From NAD gate to operating system.

Worth the money, so full of info.

Excellent Book!

Great textbook!

At my age really heavy going, but will get there. DJM

Book was excellent in helping me with the Nand2Tetrsis course

This book is such I take it to every party.

Great kick starter for getting into coding.

Great quality. Like brand new

I'm happy with my purchase.

great book

This work is a perfect aproach about moderns computers. The best way to understand the real way of working of these machines.

I highly recommend this book if you are interested in learning about computer science. The book is organized around the idea of building a computer from the fundamental logic gates up--starting with the hardware (combinational logic gates, arithmetic logic units, sequential logic gates, the CPU and memory) and then through the software hierarchy (starting with the machine language, and working up through the assembler, a virtual machine, a compiler for a high-level language, and an operating system). As a "by-product," one learns, by very relevant examples, many fundamental concepts of computer science. You can just read the book, but the best idea is to follow the authors' advice and do the projects where you implement every necessary piece of the computer system yourself. The projects are all very well organized. All the software necessary to emulate any part of the computer is available for free download from the authors' web-site. It all works beautifully. If you want to skip any of the projects, you can, because the software is organized in such a way that it will use built-in modules instead of the ones you built if necessary. The authors seem to have extensively tested the whole approach through the courses they have taught using this material. I also noticed that Harvard's Computer Science 101 course is being taught based on this book. I have been using the book for self-study with absolutely no problems--in fact I have never had such a great experience with a self-study course. All you need is a Windows or Linux (edit: Mac OS X works fine too) computer and access to the internet, and you can give yourself a wonderful education in computer science. In terms of prerequisites, you only really need to have some experience with programming (e.g. with C, or ideally with Java or Python). I think that the book should work well for students or hobbyists who don't have any more experience than that, but it is also great for much more experienced students, as a kind of integrative summary of the field. I also think the book is perfect for graduate students or researchers from other fields who want to learn how digital hardware and software systems are actually engineered. Finally, I just want to compliment the authors on the extraordinary care that they have taken with the whole project. The computer design that you build up is wonderfully elegant--at every stage the design is just as simple as it can be while being sufficient. Every piece of emulation software works as advertised. Even the extra powerpoint or .pdf tutorials are nicely done. This is really quality work, and using it is just a real pleasure. Finally, the source code for all the software provided by the authors is available, so if you wanted to extend the provided emulators, you could do that. In summary, I give this book my unqualified highest recommendation.

I have a love/hate relationship with "The Elements of Computing Systems." The book itself is great. It is written very clearly and provides a lot of great information on how computers work. However, the book is centered around using its companion software in addition to reading the book itself. The problem with that is that the companion software has numerous flaws. For the first few chapters everything works out well. However, by the time I got to Chapter 5, which is where the hardware is supposed to culminate in a fully-functioning computer that provides the basis for the software outlined in Chapters 6-12, the software began to break down. I got incredibly frustrated once because the hardware simulator kept giving me an error that I could not find the source of. The next day I ran the exact same code through it and received no errors. While the GUI that the simulator provides for some chips is a good idea, it is glitchy at best. The displays never allow scrolling, and sometimes there are clear glitches (such as lines through the images). I've also encountered numerous errors with a specific chip the book outlines whose input is intended to have a bus width of 15 bits. However, all of the software assumes that the input is 14 bits wide. This requires making numerous changes in some of the software's built-in features, not all of which correct the issues. The last straw came for me when I was testing the keyboard functionality of the simulated computer. Pressing a keyboard icon is necessary to enable using the keyboard. However, there simply was no keyboard icon. I've seen screenshots of other users who have used the same software and have a keyboard icon where mine simply wasn't. These are just a few examples of the many problems I've encountered with the software. All in all, the book has some good information and is an amazing read for undergraduate computer scientists or those who are truly interested in what goes on inside of the black boxes that have become so commonplace. However, I would only recommend getting it if you're prepared to do a lot of troubleshooting and have a few headaches along the way.

brought all systems into clear view

Incredible bottom-up look at computer science. Finally understood the relationship between hardware and software after reading this book.

As far as I know, this is the only books that gives you a hands on demonstration of how a computer works from its basic logic circuits, to modeling a central processing unit, random access memory, and eventually a complete computer. After creating a simple, but complete computer, you will learn how machine language works, learn to use a modern virtual machine language to generate machine code, and learn to use high level object oriented language that can generate virtual machine language. After creating a computer and its programming languages, you can actually write programs and see how they work on your new simulated computer. When I first started reading this book, I through that it would be an amazing high school course. The first part of the book is simple and powerful. However, some projects in the second part of the book require a basic knowledge of at least one programming language to perform, and many high school students will not have this. As a computer science student, I thought this was the best book I have ever used. It shows you the big picture in hands of fashion. Many courses will try to teach you about hardware, or programming, or logic, but very few will have you design a computer from scratch (which is made much easier than it sounds) and then have you run software on that computer. This is an amazing book and it should be required reading for computer science students.

The course contained in this book is easily one of the most fun and engaging learning experiences I have ever had. Although I am a professional computer programmer, I never learned the basics of how computers worked in school. I read through this book and did all the exercises to fill that gap. The authors did an excellent job of distilling their presentation down to the most crucial elements. Many books on computer architecture can easily overwhelm someone who is not properly prepared, but the material in this book is fairly self-contained. It bears repeating that this book is absolutely ideal for self-study. The members of the online forum are very helpful, and are in themselves another good reason to read this book.

I highly recommend this project-based book to anyone with a passion for programming and the curiosity to dig below its high-level incarnations. This book will show you how to build a computing system from the ground up. In the process, you'll learn about combinatorial & sequential logic, ALU & memory chips, CPU & von Neumann architecture, machine & assembly language, assemblers, virtual machines, parsing and code generation. The hardware part is built using a freely provided Hardware Simulator and the software part can be tackled in any programming language(s) you choose. You can get started right now by going to the book's website, [...], which has some sample chapters and all the tools (like the Hardware Simulator) you'll need to complete these wonderful projects. Each project comes with extensive test cases, giving you immediate feedback on your progress.

Mozart had his Requiem. Michelangelo had the Sistine Chapel. Michael Jordan has game 5 of the 1997 finals. And Nisan and Schocken have The Elements of Computing Systems. Forgive me if I'm being too enthusiastic. I began this book just before Thanksgiving, building a not gate from nand gates, and by mid-January I had finished making the operating system for a real computer that can play Tetris. There were no frustrating gaps in the exposition or unclear explanations that impeded my progress. Everything works, everything is crystal clear, everything is perfect. This book is great for college freshman, as it has been used at Harvard. It's great for working engineers like myself who want to understand computers and computer science better. Something somewhat less obvious is that it would also be great for enthusiastic high school or even middle school students who already know how to program. I would like to see an open source community develop around this book, creating extra chapters and projects and extending the software to support them. For example, I would love an extra chapter that (following a suggestion in chapter 13) shows how to connect this computer to the internet.

if you really want to go through all projects, especially the first ones, buy this book first ####Code: The Hidden Language of Computer Hardware and Software###. i find the two to be a great combination. after reading the code book, the first projects on hardware will be to easy. even the rest actually.

I've been programming for many years, but this book is the first one that explained the initial principles... how you get from logic gates to machine code to compilers. All the stuff below programming. I can't recommend it enough for understanding the principles that underlie computers.

I got this book and when i read the first chapter, I was excited and optomistic to develop the computer. but when i went to the second chapter, the author didnot care and did not expalin much about lots of things involved. looks like i am reading diffrent book when i got to the second chapter. the author left and the book lost its point. when u get to the second chapter, u will relize that u cannt make a computer based on this book. the author want to get money out of it by just taking care of the first few pags. Plus I didot get the hardware simulator that he said its supplied with the book.

You don’t actually build a computer with this book. It’s like telling someone you are going to teach them how to farm and then only providing a walkthrough of a computer farming game.

I've order last 2016 and forgot to provide review. The book came in great condition.

This is a great book. It is well written and laid out, it works in a progressive manner of increasing difficulty, and it broaches a complex problem (building a computer from scratch) and actually accomplishes the goal along the way, filling you with a sense of achievement unlike most other textbooks. BUT it is not complete. This book requires additional sources to "complete" successfully. The answers to each chapter are not provided, yet are essential in understanding your progress before moving on. On its own, the book can be quite frustrating to the reader, and it quickly dawns that their must be another component to it. There is. It is a MOOC (massively open online course) offered for free through Coursera ([...]) over a 6-week lesson plan. The book is really designed to supplement the course. The course is provided by the two authors (PhDs in Computer Science out of the University of Jerusalem) and even offers a university certified certificate upon completion. Take this course, and everything will click. Using this book on its own, however, is difficult; and downloading the reference code and apps can be bewildering. (Disclaimer: I ended up taking the course, and loved it, so I wanted to make sure others knew about the linkage).

While the price of this book may be prohibitive to some, the authors have posted the first half, along with related coursework, for free online. It's a fantastic journey through the design and implementation of a simple yet functional computer. While the authors provide the skeletal architecture, you must be very resourceful to work through each chapter and project; you get to act as designer and engineer as you build the most rudimentary of circuits, then glue them together with abstract logic to produce high and higher levels of functionality into a variety of chips. Once you build the hardware (virtually) you continue to build the tools to program and use the computer, such as an assembler a compiler and an operating system.

Was not what expected or what was described 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

Great book, 12 projects to follow!!! I am using it with the coursera course. Build a computer from scratch.

Excellent! Very clear explanations for somebody like me totally new to the subject. I used this book to follow the corresponding "NAND to tetris" online course. Would recommend to anybody interested in understanding how computers work, from bottom (simplest logical gate) up to high level programming.

One of the best books I have ever read. I wish I had found it earlier. The authors describe complex concepts in interesting and simple ways. A true no-nonsense book.

Great quality for price, shipped fast!

Apenas lo recibí, y es el complemento ideal para realizar el curso NAND to Tetris para entender cómo funcionan las computadoras.

A useful book for geek !!

Studying

An excellent companion to an excellent course!

Produit désiré et rapidité

This is a companion book to a university course on first principles in computing. It's an excellent approach to a common topic, and I did love the approach. The book is well written, but some of the examples suffer from the "... and then a miracle happens..." treatment (you know what I mean if you've ever seen the cartoon I'm referencing). There are places where information is glossed over and you have to either have prior knowledge or peek at the answer to "get it". The companion website is good, but not great. I do also wish a more conventional programming language had been chosen as the high level language for the final machine, but that's quibbling I guess.

I believe you are interesting about how computer works or wanna know hardware stuffs. I'm a software engineer and wanted to know how computer/hardware works. As you might know there are difficult issues in computer world. * Compiler * OS and so on.(Well database is also difficult. Hmm... I think everything is difficult actually) Author developed all executable software with Java which means you need to know java :) and described all things from the root. Author described how gate works and how to make other gates from the gate that god gave. (It was fun to me) and described how to make memory and so on. With that software hardware(because it ran on software), author developed his own language and made a compiler too. (I bought this book because of this chapter) At the end author developed OS with the language that he made. Sounds pretty cool right? :) To be honest, it was not enough for me because I wanted to know more about hardware stuffs. (Don't worry! 'Code' book described hardware stuffs better than this book.) If you like to spend some time to know those things(but don't expect too much), this book will be perfect for you and I think there is not much books that talk about those issues. Last, I recommend you 'Code: The Hidden Language of Computer Hardware and Software, Charles Petzold' book too. If you are interesting about hardware making.

Ce livre contient tout simplement les connaissances que je rêvais d'acquérir depuis des années! Il permet ni plus ni moins que de comprendre comment fonctionne un ordinateur en partant des puces électroniques qui le matérialise jusqu'à un quelconque langage de haut niveau que la plupart des développeurs utilisent. Chaque chapitre (ou groupe de chapitres) envisage un niveau d'abstraction sur lequel va s'appuyer la couche logicielle suivante. Au fil de ces différentes couches, on reconstitue le fil complet du fonctionnement d'un ordinateur. Mais le lecteur est aussi acteur. En effet, les auteurs du livre mettent à disposition des outils logiciels afin d'expérimenter la chose en reconstruisant de manière pratique le fonctionnement de l'ordinateur. Il est ainsi possible de "programmer" rien de moins qu'un processeur via un émulateur fourni (ce qui évite de devoir sortir le poste à souder...^^). Ensuite on établit un langage machine permettant de communiquer avec lui. Puis, parce que ce n'est quand même pas très commode pour un humain de "parler" binaire, on crée un langage Assembleur qui assure la conversion vers ce langage machine. Et ainsi de suite jusqu'à un langage de haut niveau orienté objet (on apprend comment est physiquement stocké un "objet" en mémoire). Tout cela en passant par un operating system. Au final, de manière très pédagogique, les auteurs ont substitué les parois noires qui entourent un boitier d'ordinateur par des verres totalement transparents, mettant en lumière le fonctionnement de l'appareil qui vous permet de lire ce commentaire. Ce livre date certes de plusieurs années, mais tous les principes exposés ont encore cours à l'heure actuelle. Les fondements conceptuels de l'informatique n'évoluent pas aussi vite que cela. Bien que cela ne soit pas nécessaire pour la première moitié du livre, il est toutefois recommandé de disposer d'un petit niveau en programmation pour la seconde si le lecteur désire expérimenter les exercices proposés. Profitant d'une place d'honneur dans ma bibliothèque, j'estime que le contenu de ce livre devrait être enseigné dans tous les cursus dédicacés à la science informatique.

Ich träume schon länger davon einen eigenen Chip, samt Assembler, High-Level Language und OS zu entwerfen. Wobei der Chip natürlich in keiner foundry erzeugt wird, sondern auf einer FPGA läuft. Das ist heute auch im industriellen Einsatz durchaus üblich. Die Autoren haben genau das gemacht. Der Chip läuft zwar auf einem Hardware-Simulator am PC. Eine Implemetierung in einer FPGA ist aber eine relativ triviale Sache. Soweit ich auf der Homepage nand2tetris.org gesehen habe, wurde diese Idee von einer chinesischen Uni auch implementiert. Das Buch beginnt mit dem Design elemenarter Hardware aus NAND-Gates. Diese werden anschließend zu Addern und anderer Logik zusammen gesetzt. Darauf wird eine einfache aber elegante 16-Bit CPU gebaut. Programmiert wird die CPU mit dem Assembler-Hack. Auf Hack setzt eine Virtuelle Maschine auf. Im nächsten Schritt wird die einfache objektorientierte Sprache Jack definiert und für diese in 2 Schritten ein Compiler gebaut. Der Compiler übersetzt Jack in die VM. Zum Abschluss gibt es noch ein schlankes OS bzw. eine Runtime. Das alles passt in ein 300 Seiten dickes Buch. Man hat auch nicht das Gefühl, dass das Ganze besonders schwierig ist. Tatsächlich haben die Autoren das System fein aufeinander abgestimmt und sich in der Kunst des Weglassens geübt. Man kann sich das System sowohl als executable als auch den Java-Kode von der Projekthomepage herunterladen. Es war ein Vergnügen dieses Buch zu lesen. Ich habe auch eine Reihe von Anregungen für mein eigenes System SL18 ("Sweet Little Eighteen") bekommen. SL18 soll auf einer XiLinx-Spartan mit 18-Bit Memory laufen und daher auch einen 18-Bit Befehlssatz - aber 16 Bit Registerbreite - haben.

Ich habe das Buch über den TED-Talk von einem der Autoren entdeckt. [...] Die erste Hälfte des Buchs und begleitendes Material ist auf der Webseite zum Buch zu finden: nand2tetris.org KURZ: Bisher habe ich zwar nur bis Kapitel 3 gelesen, doch wurden mir in diesen wenigen Seiten so unglaublich viele Fragen beantwortet, die mich beim Lesen anderer Bücher im Bereich der Informatik immer aufgehalten haben. Der Text des Buchs agiert in einem klar abgesteckten Bereich. Als untere Grenze nimmt man das Nand-Gate, aus dem sich wiederum alle anderen Gatter zusammensetzen lassen, bis hoch zur ALU. Die elektrische, bzw. physikalische Zusammensetzung der Gatter spielt keine Rolle. Die Trennung erfolgt wunderbar, es entsteht nicht das Gefühl, einen Themenbereich einfach beiseite gelassen zu haben. Ein Musterbeispiel für Modularisierung. Als Voraussetzungen zu dem Buch, wird eine Hochsprache, am besten Java, von den Autoren genannt. Sollte einen nicht abschrecken, falls man Interesse hat aber kein Java, C, C++, Python, etc. kann. Man braucht es schlicht erstmal nicht. Da man das Buch früher oder später um jeden Preis lesen sollte, ist es auch egal, wenn man es jetzt kauft und erstmal nicht alles versteht, es bei Seite legt und später wieder einsteigt. Folgende andere Bücher fand ich sehr hilfreich, mehr vom großen Ganzen zu verstehen: "Programming from the ground up" [...] "How Computers Work" von Tom White und Timothy Downs Generell so viel lesen wie nur möglich. Auf den Unterseiten von StackExchange.com findet man auch viele tolle Antworten zu vielen tollen Fragen. LANG: doch nicht... :) (gelöscht)

È probabilmente il più utile libro che abbia trovato sull'argomento. Rispetto ai tipici testi universitari, ha un taglio piuttosto pratico, dato che nel corso del libro viene presentata la realizzazione di un computer da realizzare in ogni sua parte (dagli aspetti hardware e quelli software: sistema operativo, compilatore, assembler...), il tutto grazie a software multipiattaforma scaricabile dal sito del libro (simulatori hardware, programmi di test, etc...). Ogni capitolo si concentra su un aspetto specifico, seguendo una progressione naturale. Soffermandosi adeguatamente su ogni capito ed eseguendo gli esercizi proposti si arriva al capito successivo avendo realmente compreso i concetti. Viene proposta la realizzazione di una macchina basata su un set di istruzioni ah hoc, con un assembler, un compilatore e un sstema operativo ad hoc. Anche come linguaggio di descrizione dell'hardware viene proposto un linguaggio pensato appositamente per il libro, facile da imparare. Una volta concluso il libro non è però affatto un problema integrare quanto appreso e sviluppare il tutto magari su FPGA usando un linguaggio come VHDL o Verilog, costruendo una versione "fisica" del sistema proposto (e cercando in rete si trovano infatti implementazioni di questo tipo). Assolutamente consigliato per chi voglia imparare l'architettura degli elaboratori dalle basi fino allo sviluppo del software, senza fermarsi alla teoria ma mettendo in pratica, da subito, quanto appreso.

This is book is like a couple of Tanembaum books bundled together, but shorter, easier and more fun. You start with (software simulations of) basic logical circuits and use them to build a CPU. Then you build an assembly language, a VM and a high level language similar to Java. All this in like 300 pages. Impressive!

Building a computer from the ground up....sounds like science fiction! Ultimately it enabled me to see machines, not as these "black boxes" that do "magic"...I felt like I was taken through a journey that gave enough theoretical background to get you going and then left you to the implementation whilst they hold your hand. It was much, much harder than I expected, especially the later chapters, which in fairness I had to cheat a little but it was the first half of the book that was the magic for me. It is a brilliant read and I would recommend it to anyone with a technical background.

have only got through the first two chapters so far but am having a whale of a time, the book doesn't really tell you what to do, it just lists components that need to be created ( i.e. what their properties need to be) and you fill in the blanks, however it seems that it lists them in approximately the order you would need to construct them anyway. I heartily recommend as a little project, as each chapter is self contained so it's perfect to dive in and out of, if you're still not sure you can even read the first 6 chapters on the course's website nand2tetris.org

Entdeckt hab ich das Buch vor einigen Jahren als ich noch nicht so viel von Chipdesign wusste. Einzelne kleine Digitalschaltungen waren mir bereits vertraut. Allerdings wie diese zusammen agieren müssen um damit rechnen zu können war mir schleierhaft. Bis ich diese Buch durch geackert habe :) Die ersten Kapitel sind für blutige Anfänger (Logikgatter und co.) Das beiliegende Software(Download auf Seite der Autoren) ist sehr zu empfehlen (vor allem der Assembler) Meier Erfahrung nach lernt man jedoch am Meisten wenn man nicht nur die beiliegende Software verwendet sonder auch einen graphischen Logiksimulator (z.B. Logisim) verwendet.

Delivered on time, good packaging with the book intact. Well-done

Questo libro è parte di un corso online su coursera, ma dal contenuto libero. Affiancato alle spiegazioni dei due autori, chiarissimi nell'esposizione, permette di fare quanto promesso, costruire un computer funzionante (in emulazione) partendo da una porta logica NAND fino ad un programma reale funzionante attraverso l'implementazione di RAM, registri, ALU ecc ecc con un linguaggio HDL (simile per certi versi ad assembly e VHDL) a mano. Chiarisce molto bene quindi la struttura di una macchina di von Neumann.

The book is absolutely fantastic, written in down-to-earth style, for humans. It would be nice if the implementation code is in the book, but then it would probably double in size, so I understand why the author provided only the essential code.

I am a hobbyist programmer and this book answered a lot of my questions about why code works the way it does. The explanation is lucid, the software suite is updated and easy to use. It's a truly rewarding experience.

It is a book about fundamentals. If you really want to understand everything about how computing works. This is the way to doing iit

The tools & emulators mentioned in the book is not provided with the book

Amazing book. I have passed mid way and I would say that this book has given me a unique perspective. Without being too prescriptive it lets reader come up with solution, needing the deep thinking that is required with the subject like this. Amazon is amazing as usual with the order delivery and quality of service.

Great if you like a challenge, opens your eyes to the foundations of computing. It is a bit tricky when you get stuck though, but you have to persist or just come back to it later with fresh vision.

Excellent! From the very basics to a full(ish) computer. One of the best ways to learn and understand the fundamentals

Takes you from first principles to a complete working virtual computer. Best used in conjunction with the online course from Coursera. Highly recommended.

Having just done the excellent free Coursera Nand 2 Tetris course, part one of which uses the first few chapters of this book, this was the perfect way to continue learning.

This is an excellent guide along with course available on Coursera.