Explore

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

Approx. 90 hours to complete

Save Course

Go to Course

Course Summary

Learn how to design and build a modern computer system from the ground up with this course. You will start with building basic logic gates and work your way up to creating a fully functional computer.

Key Learning Points

Design and build a computer system from scratch
Learn how to create programming languages and compilers
Gain a deep understanding of computer architecture and hardware design

Learning Outcomes

Design and build a fully functioning computer system
Create programming languages and compilers
Gain a deep understanding of computer architecture and hardware design

Prerequisites or good to have knowledge before taking this course

Basic knowledge of programming languages
Familiarity with digital logic

Course Difficulty Level

Intermediate

Course Format

Online
Self-paced

Similar Courses

From NAND to Tetris: Building a Modern Computer From First Principles
Computer Architecture

Related Education Paths

Notable People in This Field

Andrew Tanenbaum
David Patterson

Related Books

Description

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. In particular, you will implement a virtual machine and a compiler for a simple, Java-like programming language, and you will develop a basic operating system that closes gaps between the high-level language and the underlying hardware platform. In the process, you will gain a deep, hands-on understanding of numerous topics in applied computer science, e.g. stack processing, parsing, code generation, and classical algorithms and data structures for memory management, vector graphics, input-output handling, and various other topics that lie at the very core of every modern computer system.

This is a self-contained course: all the knowledge necessary to succeed in the course and build the various systems will be given as part of the learning experience. The only prerequisite is knowledge of programming at the level acquired in introduction to computer science courses. All the software tools and materials that are necessary to complete the course will be supplied freely after you enrol in the course. This course is accompanied by the textbook "The Elements of Computing Systems" (Nisan and Schocken, MIT Press). While not required for taking the course, the book provides a convenient coverage of all the course topics. The book is available in either hardcopy or ebook form, and MIT Press is offering a 30% discount off the cover price by using the discount code MNTT30 at https://mitpress.mit.edu/books/elements-computing-systems. The course consists of six modules, each comprising a series of video lectures, and a project. You will need about 2-3 hours to watch each module's lectures, and about 15 hours to complete each one of the six projects. The course can be completed in six weeks, but you are welcome to take it at your own pace. You can watch a TED talk about this course by Googling "nand2tetris TED talk". *About Project-Centered Courses: Project-centered courses are designed to help you complete a personally meaningful real-world project, with your instructor and a community of learners with similar goals providing guidance and suggestions along the way. By actively applying new concepts as you learn, you’ll master the course content more efficiently; you’ll also get a head start on using the skills you gain to make positive changes in your life and career. When you complete the course, you’ll have a finished project that you’ll be proud to use and share.

Outline

Getting Started
Course Overview
Project 0 Overview
Week 1 Overview (start here)

Machine Language
Unit 0.0: Machine Language Primer
Unit 0.1: Machine Language Overview
Unit 0.2: Machine Language Elements
Unit 0.3: The Hack Computer and Machine Language
Unit 0.4: Hack Language Specification
Unit 0.5: Handling Input and Output
Unit 0.6: Low-Level Programming, Part I
Unit 0.7: Low-Level Programming, Part II
Unit 0.8: Low-Level Programming, Part III
Unit 0.9: Project 4 Overview
Module Overview (start here)

Virtual Machine I: Stack Arithmetic
Unit 1.0: The Road Ahead
Unit 1.1: Program Compilation Preview
Unit 1.2: VM Abstraction: the Stack
Unit 1.3: VM Abstraction: Memory Segments
Unit 1.4: VM Implementation: the Stack
Unit 1.5: VM Implementation: Memory Segments
Unit 1.6: The VM Emulator
Unit 1.7: VM Implementation on the Hack Platform
Unit 1.8: VM Translator: Proposed Implementation
Unit 1.9: Project 7: Building the VM Translator, Part I
Unit 1.10: Perspective
Module Overview (start here)

Virtual Machine II: Program Control
Unit 2.1: Program Control
Unit 2.2: Branching
Unit 2.3: Functions: Abstraction
Unit 2.4: Function Call and Return: Implementation Preview
Unit 2.5: Function Call and Return: Run-time Simulation
Unit 2.6: Function Call and Return Implementation
Unit 2.7: VM Implementation on the Hack Platform
Unit 2.8: VM Translator: Proposed Implementation
Unit 2.9: Project 8: Building the VM Translator, Part II
Unit 2.10: Perspective
Module overview (start here)

High-Level Language
Unit 3.1: The Jack Language in a nutshell
Unit 3.2: Object-Based Programming
Unit 3.3: List Processing
Unit 3.4: Jack Language Specification: Syntax
Unit 3.5: Jack Language Specification: Data Types
Unit 3.6: Jack Language Specification: Classes
Unit 3.7: Jack Language Specification: Methods
Unit 3.8: Developing Apps using the Jack language and OS
Unit 3.9: A Sample Jack App: Square Dance
Unit 3.10: Graphics Optimization
Unit 3.11: Perspective
Module Overview (start here)

Compiler I: Syntax Analysis
Unit 4.1: Syntax Analysis
Unit 4.2: Lexical Analysis
Unit 4.3: Grammars
Unit 4.4: Parse Trees
Unit 4.5: Parser Logic
Unit 4.6: The Jack Grammar
Unit 4.7: The Jack Analyzer
Unit 4.8: The Jack Analyzer: Proposed Implementation
Unit 4.9: Project 10: Building a Syntax Analyzer
Unit 4.10: Perspective
Module Overview (start here)

Compiler II: Code Generation
Unit 5.1: Code Generation
Unit 5.2: Handling Variables
Unit 5.3: Handling Expressions
Unit 5.4: Handling Flow of Control
Unit 5.5: Handling Objects: Low-Level Aspects
Unit 5.6: Handling Objects: Construction
Unit 5.7: Handling Objects: Manipulation
Unit 5.8: Handling Arrays
Unit 5.9: Standard Mapping Over the Virtual Machine
Unit 5.10: Completing the Compiler: Proposed Implementation
Unit 5.11: Project 11
Unit 5.12: Perspective
Module Overview (start here)

Operating System
Unit 6.1: Operating System
Unit 6.2: Efficiency Matters
Unit 6.3: Mathematical Operations
Unit 6.4: Memory Access
Unit 6.5: Heap Management
Unit 6.6: Graphics
Unit 6.7: Line Drawing
Unit 6.8: Handling Textual Output
Unit 6.9: Input
Unit 6.10: String Processing
Unit 6.11: Array Processing
Unit 6.12: The Sys Class
Unit 6.13: Project 12: Building the OS
Unit 6.14: Perspective
Module Overview (start here)

Postscript: More Fun to Go
Unit 7.1: More Fun To Go
Unit 7.2: More Fun To Go
Unit 7.3: More Fun To Go
Unit 7.4: More Fun To Go

Summary of User Reviews

Nand2Tetris Part 2 is a highly rated course on Coursera that teaches students how to build a modern computer system from the ground up. Users praise the course for its challenging and rewarding curriculum, which covers topics such as computer architecture and operating systems. One key aspect that many users thought was good is the hands-on approach to learning, which allows students to apply what they've learned in real-world scenarios.