Unit 0.0: Machine Language Primer

Loading...

En provenance du cours de Hebrew University of Jerusalem

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

146 notes

Hebrew University of Jerusalem

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

146 notes

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.

À partir de la leçon

Machine Language

Unit 0.0: Machine Language Primer7:41

Unit 0.1: Machine Language Overview12:08

Unit 0.2: Machine Language Elements17:05

Unit 0.3: The Hack Computer and Machine Language15:57

Unit 0.4: Hack Language Specification10:26

Unit 0.5: Handling Input and Output26:38

Unit 0.6: Low-Level Programming, Part I24:16

Unit 0.7: Low-Level Programming, Part II21:22

Unit 0.8: Low-Level Programming, Part III32:21

Unit 0.9: Project 4 Overview19:08

Rencontrer les enseignants

Shimon Schocken
Professor
Computer Science

Welcome to module zero of Nand to Tetris part two in which we

are going to talk about machine language basics.

Now, a note to graduates of Nand to Tetris Part I.

Even if you feel completely competent with the heck programming and low level

programming you still have to bear with me at least through this preliminary unit and

then you can decide how much more you want to take from this primer.

Because almost all the material that we're going to cover in this module

is something that we covered already in part one.

But once again, bear with me until the end of this unit.

All right, so here is the big picture of a Nand to Tetris Part II.

Here are the various modules that we are going to go through

throughout the course beginning with module zero.

Now module zero, deals with a very exciting interface

in applied computer science and this is the point where hardware meets software.

In particular, we meet the hardware or

we use the hardware platform through its interface which is machine language.

And we need this machine language and we need Module 0 in order

to set the stage and build a foundation for

the next two modules in which we are going to build the computers virtual machine.

And in order to explained this delicate handshake take a look at this slide here.

And you will notice that what we have here is some

VM code written in a language what they called a virtual machine

language of which I don't expect you to understand anything.

This is something that we're going to describe later on.

But notice that we are going to discuss this language as well as

the task of translating programs written in this language into

machine language into assembly.

So in particular, the VM translator is going to be a program that

you guys will write under our guidance in some language like Java or Python.

This program will treat the VM code as input and

it will start marching through this input and generating, assembly called from it.

So for example it will start with push one and generate the assembly

code that you see here then it will go on to pulse push two and

generate from it this code segment and so on and so forth.

So you see that in order to accomplish this task,

you have to be able to generate code in assembly.

You have to be able to write code in assembly language.

And so in modules one and two we are going to do two things.

First of all we'll talk about the virtual machine, architecture,

obstruction and commends, the commends of the VM language.

And then we're going to talk about building this machine

by realizing it using a VM translator.

And in order to do this we have to once again generate code in assembly.

So module zero is about explaining the notion of low-level programming in

assembly language, and writing a program or two in order to gain this fundamental

competence without which you will not be able to write your VM translator.

Now in order to do this, we are going to supply you with nine instruction units,

which culminate in what is known as project four.

And you have to understand that all these units are exact replicas of

exactly the same units that we taught in Nand to Tetris Part I.

And in Nand to Tetris Part I, these units were the substance

of module four that's the project is called project four.

And with that in mind I think that the group of people who are listening to this

video now fall into three possible categories.

First of all there are people who took Nand to Tetris Part I probably recently.

And they are happy campers, they enjoy the course,

they understand the machine language quite well and

are eager to start working on Nand to Tetris Part II.

Well if that is the case, we recommend that you review only

unit eight of the table of contents you have here, and

we highly recommend that you also review your project

four in unit nine the numbering is a bit confusing here.

And you may also consider re-submitting project four if you want,

this is an optional project but just make sure

that you remember how to write programs in the hack assembly language.

So that's this group.

The second group consists of people who took Nand to Tetris Part I in the past but

by now the part of their brains that was committed

to a machine language is now occupied by some other thoughts.

Well, if that is the case, you have to remove the rust and

the best way to do it is to review this subset of units that you see here.

And we highly recommend that you do again project four and submit it,

but once again, this project is optional in Nand to Tetris Part II.

And finally, there is this group of people who did not take a Nand to Tetris Part I

and decides to jump into Nand to Tetris Part II heads on.

Well, there's no need to be gloomy about.

You can certainly do that but if this is your choice.

Then we insist that you learn carefully all the units that you see here and

in particular you must do project four.

If you will not gain the requisite knowledge of low-level programming,

you won't be able to proceed with Nand to Tetris Part II.

So it's up to you to fulfill this prerequisite knowledge.

All right, so with that, that's the end of this preliminary unit.

Please locate yourself in one of these three tracks,

according to your level of low level programming expertise.

Decide what you want to learn from these remaining units, and once you do this,

I will meet you in Module 1 in which we'll begin building our virtual machine.

Explorer notre catalogue

Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.

Coursera propose un accès universel à la meilleure formation au monde, en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.

© 2018 Coursera Inc. Tous droits réservés.

Télécharger dans l'App Store

Disponible sur Google Play