Can this course be completed in one semester?

Yes. The speaker argues it can be taught in one semester if the material is well structured, with modular units and comprehensive tooling. The key is a focused curriculum and well-documented projects. Timestamp: 198.

What tools are used to build the computer?

Students work with a small HDL dialect, a hardware simulator, and a Java backend that can implement chips. They also write an assembler and a VM emulator as part of the software stack. Timestamp: 482.

What is the machine language for the computer?

The machine language uses two instructions: A-instruction to load a 15-bit constant into the A register, and C-instruction to perform ALU computations with optional jumps and destinations. Timestamp: 1424.

What is the Harvard architecture mentioned in the course?

The Harvard architecture separates instruction memory from data memory, simplifying CPU design and implementation. The talk discusses this as the memory model used in the project. Timestamp: 1669.

What is the VM in this course?

The VM is a stack-based intermediate language like a Java bytecode level; students translate VM code to Hack machine code as part of the compiler project, illustrating layered compilation. Timestamp: 2100.

What is the Jack language?

Jack is the high-level language used in the course. Students implement a compiler for Jack and can run programs by translating Jack into VM and then into the Hack platform. Timestamp: 2556.

How is Space Invaders used in the course?

Space Invaders serves as a student-built example to demonstrate graphics, input, and game logic running on the VM/Hack stack, illustrating the end-to-end pipeline from hardware to software. Timestamp: 2604.

Can this be taught to high school students?

The presenter argues the course can be used as a capstone or even introductory CS 101, suggesting it could be taught to older high school students with sufficient preparation. Timestamp: 3246.

What happens in the compiler construction part?

Compiler construction is taught in two projects: syntax analysis that tokenizes Jack into XML, and code generation that traverses the XML to produce VM/Hack code. Timestamp: 2912.

From Nand to Tetris in 12 steps

Google Talks

Education3 min read62 min video

Aug 22, 2012|61,604 views|811|26

googlevideo

Save to Pod

Key Moments

TL;DR

Build a computer from NAND gates to an OS in one semester.

Key Insights

Multidisciplinary integration: Real-world problems cross disciplinary boundaries, so course design should reflect systems thinking rather than isolated topics.

Theme-driven pedagogy: Center the curriculum around building a complete computer system, from hardware to software, to teach core abstractions and interfaces.

Modular, API-driven projects: Complex systems are decomposed into well-defined instructional units with clear APIs, enabling flexible sequencing and partial credit when needed.

Hands-on learning over lectures: Projects drive learning; lectures serve to contextualize and enrich understanding, including historical perspectives.

Hardware-software co-design: Begin with gates and chips, progress to CPU, memory, machine language, VM, compiler, and OS, showing how abstractions layer atop one another.

Accessibility and tooling: Use open-source tools and simulators that allow students and instructors to swap order of modules, test progressively, and focus on learning outcomes.

COURSE PHILOSOPHY: INTEGRATED DISCIPLINE FOR APPLIED CS

The talk argues that modern computing problems are inherently multidisciplinary, making siloed courses insufficient. The instructors Shimon Shakan and his colleague Nissan (N Nissan) advocate a theme-driven approach: teach using a grand objective—constructing a general-purpose computer from the ground up. This method helps students appreciate interfaces and contracts that underlie applied computer science, ensuring they grasp both the forest and the trees. The narrative also emphasizes historical context to illuminate why ideas evolved into practical engineering.

COURSE ARCHITECTURE: HARDWARE-SOFTWARE STACK AND APIS

The course is structured around two grand pieces—hardware and software—and their interface via machine language. It progresses through a set of weekly, modular instructional units (lectures, projects, chapters) where each unit is self-contained and defined by APIs. Students can start at different points (e.g., VM first or hardware first) because each layer exposes clear, well-documented boundaries. The course aims to finish in one semester by staying focused on essential abstractions needed to build a functioning computer.

HARDWARE MILESTONES: GATES TO RAM AND THE HARVARD ARCHITECTURE

Students begin with fundamental logic gates (NAND as a starting point) and incrementally assemble a 16-bit ALU, then a CPU, followed by a RAM-based memory system. The architecture adopted is Harvard-style, separating instruction and data memory, and includes screen and keyboard mappings for I/O. The visual demonstrations—such as a Pong-like game, Space Invaders, and Hangman—make the hardware decisions tangible. The course emphasizes modularity and the ability to swap hardware components as needed.

SOFTWARE MILESTONES: ASSEMBLER, VM, COMPILER, JACK, AND OS

On the software side, students implement an assembler for the defined machine language, a high-level VM akin to a two-tier compiler, and a Jack language with a corresponding compiler. The VM abstracts hardware from software, enabling code to run on a simulated machine and then be translated to native machine code. An operating system, also written in Jack, exposes system calls and abstractions that make higher-level programs feasible, culminating in runnable applications such as games.

PEDAGOGY AND TOOLS: SIMULATORS, OPEN SOURCE, AND PROJECT DESIGN

A core strength of the course is the suite of tools: a simple HDL dialect, a test description language, and a hardware simulator (implemented in Java) with both HDL and Java-based implementations of chips. The simulator can fallback to Java implementations if HDL is absent, enabling flexible project development. All software is open source and platform-agnostic (Windows and Unix). This tooling philosophy enables pedagogical resilience and makes it possible to complete complex projects in a single semester.

OUTCOMES AND REAL-WORLD INSIGHTS: GAMES, DEMOS, AND LONG-TERM VALUE

The culminating demonstrations—ranging from Tetris-like programs to Space Invaders—showcase a computer built from hardware up to the OS level, with code paths spanning millions of bits. The course emphasizes that every line of code corresponds to a concrete hardware mechanism, reinforcing the historical thread from Boolean logic to practical computing. The instructor shares a personal anecdote about the excitement of seeing a simple program become a playable game, underscoring the emotional and educational payoff of building a system from scratch.

Mentioned in This Episode

●Products

●Software & Apps

●Tools

●Organizations

●Concepts

●People Referenced

From Nand to Tetris in 12 steps — Quick Do's & Don'ts

Practical takeaways from this episode

Do This

Follow a modular, stepwise design: build from NAND up to a CPU in small, testable chunks.

Use the provided HDL test scripts and the hardware simulator to verify every chip.

Rely on the API contracts: define clear inputs/outputs for each hardware block.

Leverage optional backends (e.g., Java implementations) to keep momentum if a lower level stalls.

Avoid This

Don't try to implement the entire machine at once; respect unit boundaries.

Don't skip documentation or unit tests; they prevent confusion and errors.

Common Questions

The course teaches applied computer science by guiding students to build a simple 16‑bit computer from ground up, integrating hardware and software concepts. It uses a hands-on, project-driven approach to connect core CS topics through a unifying hardware-software theme. Timestamp: 51.