Build a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course)
- Offered byCoursera
Build a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course) at Coursera Overview
Duration | 90 hours |
Start from | Start Now |
Total fee | Free |
Mode of learning | Online |
Official Website | Explore Free Course  |
Credential | Certificate |
Build a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course) at Coursera Highlights
- Earn a shareable certificate upon completion.
- Flexible deadlines according to your schedule.
Build a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course) at Coursera Course details
- 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.
Build a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course) at Coursera Curriculum
Getting Started
Course Overview
Project 0 Overview
Week 1 Overview (start here)
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)
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
Build a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course) at Coursera Admission Process
Important Dates
Other courses offered by Coursera
Student Forum
Anything you would want to ask experts?
Data ScienceDeep LearningComputer VisionBuild a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course)