Build a Modern Computer from First Principles
Nand to Tetris Part II (project-centered course)

share ›
‹ links

Below are the top discussions from Reddit that mention this online Coursera course from Hebrew University of Jerusalem.

In this project-centered course you will build a modern software hierarchy, designed to enable the translation and execution of object-based, high-level languages on a bare-bone computer hardware platform.

Computer Architecture Compiler Construction Compiler Operating System

Reddsera may receive an affiliate commission if you enroll in a paid course after using these buttons to visit Coursera. Thank you for using these buttons to support Reddsera.

Taught by
Shimon Schocken
and 9 more instructors

Offered by
Hebrew University of Jerusalem

Reddit Posts and Comments

2 posts • 30 mentions • top 21 shown below

r/hackernews • post
21 points • qznc_bot
Build a Modern Computer from First Principles: Nand to Tetris Part II
r/CFBOffTopic • comment
5 points • VeryFancyCat

Do I want to take this class or a more relevant one?

This looks interesting:

r/NandToTetris • post
3 points • peterb12
Part 2 of Nand2Tetris on Coursera starts January 15th, 2017
r/learnprogramming • comment
6 points • firesofmay

Highly highly recommended handson material for exactly what you are asking:

You start with a simple nand gate and build everything upto a game. Everything below the stack is made by you (using simulators, no actual hardwares but you have that aha moment!!)

Mooc on coursera by the same author Part 1 -

Part 2 -

r/AskReddit • comment
3 points • Warshon

I'd suggest nand2tetris. They have a course on coursera that I took and I highly recommend it. It teaches how a simple logic gate can be used to create upwardly increasing circuitry, up to a computer. The first course is the hardware side, while the second course is supposedly on the software side.

r/learnprogramming • comment
1 points • abbadon420

To get a better grasp on stack and heap, i'd suggest nand2tetris part 2

r/programming • comment
2 points • SilasX

Another session of this course started last week on Coursera [2]. I really, really love it. You get to see all the layers of abstraction between logic gates [1] and an operating system:

  • Given a NAND gate, build an AND gate, XOR gate, multiplexor, etc. using a hardware description language.
  • Given all those gates, build an ALU -- something that takes two 16-bit inputs A and D, and (given the settings on six other bits), computes one of several functions (A+D, A or D, not-A, not-D, etc).
  • Given that ALU and a "flip flop" (which "recycles" output to input), build a CPU that can read to and write from persisted memory.
  • Given that CPU, implement a way to have it iterate through a list of inputs (instructions).
  • Given the ability to program that CPU as above, write programs for it directly as machine code (sequential inputs to the CPU).
  • Start thinking in terms of abstract stack operations on a virtual machine, and write a compiler that converts such VM commands into a machine code program like in the previous step.
  • Start thinking in terms of a high level language and write a compiler that converts such programs into stack operations on the VM as above.

If you've ever wanted to know how a computer works, this is your (hands-on) answer!

(As someone who made a mid-career change to software, this is making me really wish I had majored in CS; I'm hoping I can still move to a career involving the kind of stuff in this course.)

[1] Technically, logic gates plus flip-flops, the part that allows the element of time into the circuit iterations, and therefore persisted memory.

[2] Also part 2.

r/AskProgramming • comment
1 points • [deleted]

Therein lies the beauty and magic of this thing called programming! We create virtual universes that can change and bend to our heart's desire, limited only by our imagination. In these little words, we are nothing short of Gods. If you really think about it, it is nothing short of magic. This is the reason why I have always loved computers and programming in particular. This is also why I despise people who cannot see this magic and dismiss programming as nothing more than a clerical job. Too bad for them!

To try and answer your question is a more direct way, a simplistic answer would be to take your example of how the computer know what color is, for instance. In this case, your color (say, blue) description in CSS on a webpage is processed by your browser (ultimately) into a series of electrical signals that your OS can understand, and it passes on those signals (or a different bunch of signals) onto your monitor's driver hardware, which then interprets those electronic signals to light up different parts of your screen to varying intensities (and duration) to simulate the colour that your eyes perceived to be blue.

The key thing to remember here is that ultimately everything is about a bunch of electrical signals varying in duration. How those signals are interpreted depends on the hardware itself, whether it be your CPU or your screen hardware. A saner way of understanding it would be to start at this level and work up the user's level.

Now if you ask how the hardware understands those signals, well then you'll have to know a bit about how logic gates work and a bit about how computer logic works. Ultimately, it's all hardware, and logic gates all the way, but the problem is that hardware by itself is restricted in terms of what it can do. Hence the need for software to work with hardware to provide an infinite amount of functionality on top of a basic hardware configuration. Imagine the olden days when telephone operators had to manually switch callers from source to destination as opposed to today where it's all done in software. It's a nice symbiotic relation.

To really "get it" with your mind and your gut, you need to start from the very basic (which, depending on your background can vary in terms of difficulty and/or effort). A course like this - aims to give precisely that understanding - starting off from designing your own hardware (using emulators, of course), and then working all the way up to writing your own compiler after which the possibilities of what you can do with it are endless.

The basic thing to appreciate is the almost infinite levels of abstraction present from the user to the hardware today, and yet the whole damn thing just works, and not only works, but works almost flawlessly and with unbelievable speed. For me, this is the real wonder and brilliance of our industry as a whole.

EDIT: The linked course is the first part, creating the virtual hardware from scratch. For the software part, here is the link -

r/AskProgramming • comment
1 points • LonghairedHippyFreek

I haven't taken this course so I don't know if it would be over the head of your daughter but it is for peoole with zero experience. If it is too much maybe it would be a great father/daughter project:

Build a Modern Computer from First Principles: From Nand to Tetris (Project-Centered Course) Part I

Build a Modern Computer from First Principles: From Nand to Tetris (Project-Centered Course) Part II

Good luck!

r/programming • comment
1 points • chanamasala4life

I gained a lot of insight into the inner workings of a computer with this:

It will run you through constructing a computer from pure and simple NAND gates up to programming Tetris to run on it using a hardware simulator. There's also a part 2:

Might want to give that a spin...

r/OMSCS • comment
1 points • my_password_is______

these two might be interesting

I haven't taken them, but I plan too

week 6 of the first course has them doing assembly language

r/learnprogramming • comment
2 points • ludonarrator

There are a few resources I would suggest, pick whichever ones suit your level / taste:

  • Tanenbaum's Structured Computer Organization: you'll probably breeze through this book in a few days, since you're already fluent with low level paradigms, but it does take you from hardware all the way up to software, and in great detail. It's a textbook, so you can skip all the academic stuff like exercises.

  • Silberschatz, Galvin, and Gagne's Operating System Concepts (the dinosaur book): this goes into the nuts and bolts of OS: from processes and their scheduling to virtual memory and paging to filesystems and networks.

  • [Crash Course Computer Science] ( (YouTube playlist): a concise yet startlingly comprehensive summary of everything, in friendly video form, a total of perhaps 6-8 hours of watch time.

  • Teach Yourself CS: a collection of resources, most of which are quite dense, but some are light.

  • NAND to Tetris is popular and well known, although I haven't personally taken the course.

r/OMSCS • post
2 points • vivekng
New OMSCS student

I recently got admitted for Spring 2020 and planning to take GIOS as my first course.

Although I have significant programming experience and work as a data engineer , I do not have any system programming experience and am worried that the direct leapt to a OS course will spell trouble.

The only closest thing to systems that I did was the nand2tetris course, (1 and 2) which i completed late last year.

Please advise on the prep to keep me adequately prepared for the GIOS course.

I am looking to enroll in as a Non degree SCPD student but the course costs a whopping 6.5 k .

I am looking at much cheaper options but a course of high quality which will set me up in the right direction.


r/AskComputerScience • comment
1 points • khedoros

> How can I get this done?

In my CS program, there was a progression of topics, that in retrospect all built on each other, something like this: Predicate logic->boolean logic->combinatorial logic->sequential logic->computer organization->computer architecture->assembly programming->compiler design+implementation (might be set up as tokenizing and parsing in the first course, optimization and code generation in the second)->OS design.

Essentially, it's Nand2Tetris, but in a different format. Coursera has 2 courses covering that material: part 1, part 2.

r/learnprogramming • comment
1 points • jairuncaloth

Along these lines, the nand2tetris course has you implement an entire CPU in a simplified hardware description language created for the course. You start by implementing basic logic gates and use those to build more complicated chips like muxes, demuxes, ALU, ect. Then it goes on to building an OS and application layer on top. It's all pretty simplified relative to today's modern computers. I've completed the first half, which is the hardware implementation and learning to write assembly code for it. It's been super insightful and approachable for me.

It's also available on Coursera in two parts for free if you 'audit' the course. I like this format, because you get video lectures from the guys who made the course for each chapter. You get all the content, just no auto grading. and

r/linuxquestions • comment
2 points • mdaffin

If you want to go from the group up I recommend trying the nand 2 tetris course a nice introduction to developing a system from NAND gates to building a basic CPU to building a simple assembler then compiler and finally an operating system. They have two courses on coresra part 1 and part 2 which you can audit for free.

If you want to go from the top down you might find learning to write kernel modules a good way to start.

The redox book is also a fascinating read about an ongoing effort to build a modern operating system in the rust language.

r/learnpython • comment
1 points • dougouverson

I'm relatively new to programming myself. I have a hard time dealing with the number of "black boxes" in CS and programming. I come from a construction background where it's much easier to "unravel the mystery" of how things are put together.

I decided if I was going to spend any time writing programs/scripts I was going to need to start from the beginning and learn the basics of CS.

I recently finished Part I of Build a Modern Computer from First Principles: From Nand to Tetris (Project-Centered Course) which tackles the hardware stack.

This course was great in that you started with a simple Nand logic gate and build layer-upon-layer the hardware platform of a "typical" computer platform. This really helped me understand what's going on under-the-hood of most modern computer systems.

I'm taking a break to learn some Python programming, and then I'm planning on continuing with Part II Build a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course) which continues with the software stack.

On a personal note, I have had to learn to enjoy the process; to slow down; to slow waaaay down; to accept failure as an important part of achieving any level of success; did I say slow down :)

To God be the glory!

r/learnprogramming • comment
1 points • ewig94

I'm not sure if any Coursera "certificate" is worth it, but these courses are definitely worth checking out:

Algorithms specialization by Stanford

Nand2tetris 1 and Nand2tetris 2

Machine Learning by Andrew Ng

r/beneater • comment
1 points • randohms

Thank you for sharing.

Here are the links for Part I and Part II:

And here's another course which is also beginning and that looks interesting:

r/sysadmin • comment
1 points • Alhomeronslow

To get a strong foundations in computing I recommend the following website, free software on the site, projects offered, along with the book found at Coursera has two courses that offer lessons with videos.

r/learnprogramming • comment
1 points • Alaharon123


Keep in mind that for week 3 of part two (or whatever the equivalent is in the book), you need to already know how to program in a high level language so either take Helsinki's MOOC first or between part 1 and part 2. Taking it first would be recommended, but if you want to get straight to the low level stuff, you can wait until after Part 1.

If you want to go more in-depth than Nand2Tetris, then take Computation Structures.


  1. Nand2Tetris Part 1
  2. Object-Oriented programming with Java Part 1 and Part 2
  3. Nand2Tetris Part 2
  4. Prerequisite to Computation Structures if you haven't already taken a two course sequence in physics
  5. Computation Structures Part 1, Part 2, and Part 3