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

A book for the laypersons and those self-taught individuals who have a strong curiousity on how the hardware and software of a computer work, but have never really ventured into those deeper waters. If you fit that description, then you'll be rewarded in this adventure of "Nand to Tetris" as you go through this book. For those in college that are getting into Computer Science, this book will serve you well for your upcoming classes. Note, like another review mentioned, you will need internet access and computer to download the accompanying material and also access the forums (you will need the forums if the material is new for you). Also, on Coursera, there are lectures that are helpful, I especially enjoyed the "Perspectives." As a layman, I bought the first edition quite some time ago and was only able to get to Chapter 4. It was a bit overwhelming and I didn't fully understand the material, so I wasn't able to build the computer. This edition and the accompanying lectures on Coursera have filled the gaps for me. They've updated the text and the lectures to make it more accessible to those who are not in the hardware or software industry. It is pretty concise and yet explanatory without being overly wordy. They try to use words and explanations to those unfamiliar with the terminology. That is one of the reasons that I really like this book, as I have read similar books, but they use unfamiliar terminology which make it difficult to follow for me. Think about it. You are setting out to virtually build, learn and understand a computer starting with a Boolean NAND gate to the Tetris game. This book more than any that I've seen can pull this off. It is written for those who do not yet understand this computing eco-system. They use a simpler and yet elegant, real world computing hardware and software architecture. You will spend a lot of time! I cannot stress this enough. For those who are new to hardware and software and are of average intelligence like me, you will spend a lot of time! But if you also wanted to understand the entire computing system, it will be very rewarding to you. It is helpful if you've had exposure to Boolean logic or binary numbers and counting, otherwise you will need to spend some time and work to get familiar with it. You will need to understand it because you will be using a simplified HDL code to build the different logic gates. You will build the components and eventually the ALU which makes up the heart of the CPU. Building the ALU is challenging, expect to spend some time there. Another challenging but rewarding aspect was in completing the build of the computer hardware because you will also learn Assembly language. This was a another great section, because you get to see registers in action. You will have to understand Assembly language and the usage of registers and the HDL code, but they've simplified as much as possible so it is attainable, but it could require a lot of time if these topics are new, it is worth the effort! The authors have made this very accessible in their updated 2nd edition and lectures I've found. What is incredible is the simplicity of the machine language, it is basically a bunch of simple operations and jumps, who new?! Yet from this simplicity rises all the amazing things that we do day in and day out on our computers and iPhones. The software is equally amazing. You will learn about compilers and translation, and also the idea and structure of the software stack. If you've ever gotten deeper into software, you will hear about this, but now you'll know more specifically about it! I would strongly recommend having some software programming exposure, preferably object-orientated, even just a little will be helpful. You may be able to get by without it, but it will be very helpful. If you go through the book, the Coursera lectures, the projects in the book and utilize the forum, and you have a strong interest in understanding the entire computer eco-system, then you will be rewarded and find yourself with a lot of 'aha' incredible moments! Furthermore, it is a great springboard into more complex and rich books that were previously inaccessible to you. It is quite a remarkable journey!

This is a marvelous book for anyone starting a study of computers. Or just starting a job in computers. Or even well down the path if you feel you don't have a full grasp of the underpinnings of your profession. Yeah, I'm looking at you, Software Developer, who only knows software. I've worked with many a folk with excellent software engineering skills who never even thought about what's under the hood. This book is for you too! And what an ambitious book it is! Starting with Boolean logic it builds a hardware platform that mirrors what you'll see in real life. You could probably cast that design in silicon and add a few peripherals and have a real live computer. Then it moves onto an introduction to programming and what goes into building assemblers and compilers. Kudos to the author for building a virtual machine to run that stuff on! Then it moves into building a basic operating system, with just the kinds of things you'd expect in a real, albeit simple, OS. When I say "it builds" I should say "you build". The whole point of the book (and the course available both free online and in many universities) is to have you get your hands dirty. *You* will create the logic circuits. You will test them. You will write the assembler and compiler. You will write the OS. Man, I would have loved this course way back when I was in school. Also kudos to the authors for skipping over all the bugs and problems. They assume, for example, no syntax errors in your code. Realistic? No way! But seeing that they provide you with error free tests that's a plus and not a negative. Why mess up clear and concise descriptions with the Real World, eh? There's plenty of that down the road! There are of course some nits to pick. Some axes to grind. But, to paraphrase Dr. Frank-N-Furter from the Rocky Horror Picture Show, they didn't build this book for me. I've been noodling around with real computers since 1970 or so. I've studied this stuff for both fun and practicality. For me this was a great nostalgic trip down memory lane. It brought to mind all the classes I took, all the books I read, all the computers I've built, all the operating systems I've hacked, all the programming languages and techniques I've acquired over the years. And even so I found it a great read. (caveat: I did not do any of the coursework. For me it was not necessary and I have plenty of other projects to work on) So, yeah, get the book. Find the course. Do all the work. Unless you're an old hand like me (and I don't know many old hands quite like me) this book will enrich your journey thru all things computing.

This is a brilliant book. This clears a lot of the mysteries of computing systems in a very approachable way. In many ways this is a pedagogical gem and there aren't that many of them out there, believe me. What it purports to do and it does very well: - It traverses the entire stack (HW --> SW) of a minimal and yet completely functioning modern computing system and clarifies the role of each and every component of such a system. These are the same components that you'll see in the kind of industrial-strength computers that we use on a daily basis. The difference is, of course, in the level of complexity of these components. For instance, in this book you will write a minimal operating system, however, this operating system is not going to be even remotely comparable to let's say an operating system like Linux. Be that as it may, the principles that you'll learn while creating this simple operating system are the same as those upon which Linux or for that matter any operating system has been built. - There is a nice balance between theory and practice. You will not find any fluff in this book. The language is very terse, sentences are well-chosen and yet everything has been explained very clearly. The amount of theory is nicely proportional to how difficult the projects are. You will not see too much theory and then some toy projects or conversely, not enough explanation followed by impossible tasks. You are given sufficient theoretical background to carry out sufficiently ambitious projects. What this book does not claim to do and, well, it doesn't: - You will NOT create an actual physical computer by reading this book. I should clarify that, this does not mean that you can't, it simply means that this is not the principal intention of the authors. After finishing this book, you have all the knowledge you need to implement your minimal computer in actual hardware. There is no guide in the book to teach you that, but after finishing this book such a task should be relatively trivial. If that's your intention, then I'll recommend supplementing this book with another book that teaches you how to do digital design using FPGAs and one of the two major HDLs (Hardware Description Language); VHDL or Verilog. Here are some options: https://www.amazon.com/Digital-Design-Using-Digilent-Boards/dp/0982497091/ https://www.amazon.com/Digital-Electronics-Practical-Approach-VHDL/dp/0132543036 And this is a very decent FPGA board you can purchase for your project: https://www.amazon.com/Digilent-Basys-Artix-7-Trainer-Board/dp/B00NUE1WOG/ And if all you care about is actually building a very simple physical computer using breadboards instead of FPGAs then you can read this classic: https://www.amazon.com/Digital-Computer-Electronics-Jerald-Malvino/dp/0074622358/ - You will NOT be able to understand all the internals of a complex piece of hardware, like an Intel CPU, simply by reading this or any book, regardless of how complete and complex the book is. One thing you have to bear in mind that there is a lot of optimization that goes into for example an Intel or AMD CPU. The major source of complexity and monetary value of such CPUs is mostly these optimization technologies. The basic principles are the virtually the same, what makes an Intel CPU unquestionably superior to the CPU that you'll create in this book is the mind-boggling amount of optimization technologies that goes into an Intel CPU. You will not see any mention of deep pipelines, branch prediction, superscalar processors, out-of-order processors, register renaming, multi-threading, instruction-level parallelism or anything advanced here, so you should not expect to understand them after reading this book. Things to look forward to: There are certain decisions that have been made by the authors that as the reader I believe you should be aware of beforehand, since all of us come to this book with different expectations and you might be discouraged if you become aware of these decisions half-way through the book. The book is heavily influenced by Java and its specific implementation. What does that even mean you might say? Well Java is an (almost) purely object-oriented language that famously has a two-tier compilation process. Let's explain these two things: - Java is an (almost) purely object-oriented language: If you have done any programming with any of the so-called object oriented programming languages then you should know that object-oriented programming (OOP) is a major programming paradigm based on the concepts of "objects" and "classes", these "objects" can contain data and code: data in the form of fields, and code, in the form of procedures/functions/sub-routines. Certain languages have support for OOP, but also for other programming paradigms as well (like functional programming) and there are also those languages that are said to be "purely" OOP and that means you can't escape OOP even if you'd try. And Java is such a language. The language created and used in the second part of the book is called "Jack" which is in fact based on Java. - Java has a a two-tier compilation process: All programming languages need to be translated to machine code otherwise computers can't understand them. This process of translation is called compilation or interpretation depending on the type of programming language (compiled vs. interpreted). Among compiled programming languages we also have those languages that are directly translated/compiled to the machine code (like the C programming language) and those (like Java) that are indirectly translated to the machine language, by first being translated to an intermediary language that is supposed be understood by a so-called virtual machine (not the actual physical machine) and then that intermediary code (called bytecode) becomes translated to the actual machine language of the system. Why bother doing it that way? Many good reasons, believe me. The good thing about this is that the implementation of the virtual machine in this book is the so-called "Stack Machine" implementation, so by reading this book you will get to understand the infamous "Stack" and that will come in handy later on when you want to learn other programming languages. The last thing to know about this book is that the concept of an "operating system" occasionally bleeds into other similar concepts like the concept of a "standard library", so in a way the operating system in this book is a very minimal operating system, a very very minimal one. You should never forget that this is 200+ page book and also it's a book that is supposed to teach about the fundamentals (AKA basics) of computing systems, so you should not expect to walk out of this with your own gaming machine or something. The computer you'll built in this course is basically a proof of concept that the principles taught in the book do indeed culminate in a working computing system, as has been promised. Prerequisites: Technically there are no prerequisites for this book, however, quite a few of the projects described in the book "recommend" (read require) the student to know some higher-order programing language with support for object-oriented programming like Java, Python and so on. Although, you will still be able to complete these projects by writing some sort of pseudo-code on a piece of paper or some other alternative ways, in reality you will not get the same level of satisfaction and I would argue the same level of understanding from those projects unless you know how to implement them in an actual programming language, so I would say that for at least a few of the chapters a working programming knowledge is a prerequisite.

Steep learning curve right out of the gate (pun intended) trying to figure out the HDL code but if you know to experiment with the simple gates first like NOT, OR, AND you'll start to catch on.

I’m a beginner in this type of field this book actually taught me about computers and computer building good read, easy wording

Many of us have taken courses in operating systems, digital logic, computer architecture, and compilers. This book offers a condensed, hands-on exploration of all those subjects. It guides you through the process of building a computer from the ground up—starting with designing basic gates, using those gates to create an ALU and memory system, and combining the two to develop a simple processor capable of executing machine instructions. From there, you'll design a high-level programming language that compiles down to machine code understood by your CPU. Finally, the book takes you through the design of a mini operating system. By the end, all the concepts you encountered in those college courses will coalesce into a cohesive, bottom-up understanding of how computers work. While this book is academic in nature and won't teach you how to build an optimized x86-64 processor, it provides a deep and practical understanding of the core principles behind computer systems. The aim is not to dive into highly advanced topics, but to build a simple, yet powerful, system to demonstrate the inner workings of a computer. One key point: this book may frustrate some readers. It takes an exploratory approach, offering a high-level overview of each topic but leaving significant room for independent research. The end-of-chapter projects are where the real learning happens, but to complete them, you’ll need to go beyond the book’s instructions and dig deeper. If you're looking for a book that provides every detail and lets you passively absorb the material, this isn't it. However, if you enjoy solving problems and exploring new concepts, the projects will be the highlight of the experience. By the end of this journey, you'll be in a much stronger position to design your own MIPS processor or dive deeper into computer architecture.

Well written. Thought provoking. Sent me off in all sorts of different directions - producing fpga version of the hack computer - making a c compiler for it

The book is good, and the downloadable tools (Hardware Simulator etc.) and the Coursera videos make it even better. I've used both the first edition and the second edition of the book to introduce eager students to the basics of digital logic applied to computational systems both at the college, high school, and even middle school levels (note: middle school students need a fair amount of support as they work on the projects). The students aren't asked to do a unique design (that would be asking too much of all but the most dedicated), but are supplied with a set of projects that allow them to solve smaller design problems while they build to meet the supplied overall design. The authors have provided a wonderful teaching tool to the global community.

Together with the online course it is a wonderful experience. It really taught me what it promised: from the most elemental building block, a NAND gate, I was able to build a working, fully functioning, albeit heavily simplified computer (at least virtually). Furthermore, I managed to create a high-level compiler, and did some wonderful projects. Understanding every single detail of how computer programs run on chips and do their magic, to the last bit and the last wire, is truly a breathtaking journey. If you are interested even a little, I highly recommend this book, together with the online lecture.

Excellent boom to learn how a computer works under the hood, and also a very fun journey

If you tried the Nand2Terris course, you know how good it is. Although the courses are free, it's still well worth getting the book.

El mejor libro sobre cómo funcionan los ordenadores que he leído. Ameno, sencillo de entender, didáctico, te guía desde una puerta NAND hasta un ordenador de propósito general. Se debería enseñar así en todas las titulaciones de informática, pero por desgracia no suele ser común, así que si te has quedado con las ganas de saber realmente cómo funcionan los ordenadores, te recomiendo que lo leas (o te apuntes a alguno de los cursos online gratuitos de los autores)

This book is better than IT graduation!