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.
Unit 6.13: Project 12: Building the OS
Loading...
Из курса от партнера Hebrew University of Jerusalem
Build a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course)
218 оценок
Hebrew University of Jerusalem
218 оценок
Из урока
Operating System
Познакомьтесь с преподавателями
Shimon SchockenProfessor
Computer Science
So here we are in project 12, the last and final project in Nand to Tetris,
in which we are going to build our operating system from the ground up.
Here is the operating system in all its glory,
consisting of eight different classes.
Each designed to service some other functionality like memory management,
screen management, keyboard management and so on.
And I wish to remind you that at least in this form of description,
the operating system is nothing more than an obstruction.
It is basically a set of APIs that describe what
the operating system can do for you, or for other application programmers.
For example, let us sample one class from this set of eight classes, Screen.
And take a look at this class description.
Basically, what we'll see is a set of subroutine signatures
each describing how to use it for its effect, and
this documentation is aimed at application developers.
So an application developer can write some code, in any class that he or
she desires, and this code can use the services of the screen or it's class.
It can draw lines, and rectangles, and circles, and whatnot.
Now, if this were an introduction to computer science course or
many other courses in computer science,
then we would've been contained with this level of description.
The API of the operating system, because we view the OS from a user's perspective.
But in nand2tetris, we don't take anything for granted.
And so, we are going to actually build and
realize this operating system from scratch.
And in particular, in nand2tetris, we're going to find
three different implementations of the same OS abstraction.
First of all, the supplied VM emulator, which is a fancy Java
program that we wrote, several years ago, well this VM emulator also has
a built in Java based implementation of the Jack operating system.
So when you execute the program in the VM emulator, if you find the call to let's
say memory.aloc with VM emulator, knows how to service it using Java.
Also, we provide a completely different implementation of the Jack OS.
In this folder here, which is now on your computer,
because it's part of the nand2tetris software suite,
that you have downloaded at the beginning of the course.
Basically it's a set of eight VM files, which are the compiled
version of the operating system that we wrote also using the Jack language.
And in project 12, you're going to do exactly the same thing.
You're going to write these eight OS classes in Jack yourself.
And after you compile them, you will get your own set of eight VM files.
Which presumably will deliver the same functionality as our VM OS classes.
They will not necessarily be the same code that hopefully, they will have the same
behavior, because they implement the same or they seek to implement the same API.
Now before we go on, I'd like to say a few words about reverse engineering,
which is an important technique in the software developer's tool box.
So let's assume, that we want to implement some existing operating system.
And let us assume further that the operating system,
naturally consists of several executable modules.
These modules are stand-alone classes,
for example, in some language like Java or C++.
They are executable so you don't have the source code.
And they also interact with each other intensively.
As often happens in complex program like an operating system.
How would you go about writing this software from scratch?
After all, you don't have the source code you have only, the executables.
For each module in the OS you can focus on this module only,
develop the source code of this module separately.
And use the remaining n-1 executable modules to support it.
So if your module will call
a method in some other executable model for it's effect.
The executable module will be there to service the call.
So that's a very nice and elegant development strategy and
if you just follow it step by step, then after end stages you will end up
developing the whole operating system yourself.
By the way, this is exactly how systems like,
Gnu Unix and Linux were developed.
The developers of these systems started from an existing executable well-known
operating system, Unix and they went on to develop their own versions using reverse
engineering, using precisely the same technique that we're using here.
So going back to nand2tetris, let us assume that we want to
develop the Screen class, which is one of the eight OS classes,
and test it using some supplied test code.
Which we call Main.jack.
How should we go about doing it?
Well, the development strategy is going to be surprisingly simple.
What we suggest that you do, is that you take the screen Jack file that you want to
develop and the supply the Main.jack, and put them in some directory on your PC.
Then you can go on and compile the directory using the Jack compiler.
Now, what you will get is a set of VM classes or two VM classes,
screen.vm and main.vm that you can now go on to execute.
How will you execute it?
Well, we will simply execute the directory in the VM emulator.
Now, think about it.
The VM emulator has a built-in implementation of the operating system.
But, if it finds a user implementation of any VM function including,
let's say draw rectangle or draw line.
Function that you have written in Jack and compiled and transformed into
VM functions, then the VM emulator is going to use your implementation.
Instead of the built-in implementation.
So what you get is exactly the ideal setting for reverse engineering.
Now the VM emulator will first of all execute your code,
including your own implementations of the OS subroutines.
And all the other OS subroutines which maybe called in the process will be
serviced, using the built in OS version.
So that's how we're going to do it for every class in the OS.
So let's go on and continue with this example of the Screen class, because it
would serve as an example of how to do all the other classes in the operating system.
Well, this file is going to be supply to you by us.
It is part of the nand2tetris software package,
it's part of project 12, and the I call this file, Stub File.
And I use this term and you know its not a term that I invented,
it's a well-known term in a software engineering.
Basically, it's a skeleton of a class that contains
the signatures of all the subroutines of interest in this class.
And notice that these subroutines include also the non-public subroutines,
that application programmers don't get to see.
In other words, this file was delivered to you by the system architect who said,
go on and implement every sub routine that you see here.
Including for example,
init which is a sub routine that the application program has don't get to seek.
Now how should you go about implementing this class,
well we discussed it in several units in this module.
Say you just go back, you re-read if necessary the relevant
units in a module six, if you want you can consult the chapter 12 in the book.
And then just go on and
implement every one of these methods using the Jack language.
So that's how you'll develop the Screen class.
What about testing it?
Well, we're going to supply a test file.
And the name of this test file is going to be main.jack.
And as you see, the test file calls all sorts of methods.
In the Screen class.
And if you will run this directory on the VM emulator.
Then, here is what you get to see.
Some simple picture,
which is designed to demonstrate that your Screen class is well behaving.
So we are going to provide the stub file and the test file.
And it's your job to implement the stub file and bring it through a level,
that it can service the test file to your and our satisfaction.
Now that's what we have to do with every one of the eight classes in
the operating system.
So five of these classes are going to be designed in exactly the same technique,
using a supplied stub file in the supplied Main.jack.
And the remaining three classes will be tested slightly
differently using both jack tst and compare files.
And all the details are in the project page in the nand2tetris website, so
I don't want to belabor on it because you can just go on and read it yourself.
Now, any one of these classes can be developed in any order that you fancy,
because you can always use the remaining seven classes to support it by default,
if you use our VM emulator.
And once you are done with these eight classes,
we request that you do a final test.
And the final test will be to test
the operating system that you developed in the context of a Pong application.
And if you read the steps here, they will tell you exactly how to do it.
So this will be the final test and once it passes this test,
we can say that your operating system is, well, it's not fully tested, obviously.
But it's sufficiently tested to ascertain,
that you have completed project 12 to our satisfaction.
So that's it, and
in the next unit we'll go on to talk about some perspective on operating systems.
Ознакомьтесь с нашим каталогом
Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.
Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.
© Coursera Inc., 2019 Все права защищены.
