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 5.12: Perspective
Loading...
Из курса от партнера Hebrew University of Jerusalem
Build a Modern Computer from First Principles: Nand to Tetris Part II (project-centered course)
203 оценки
Hebrew University of Jerusalem
203 оценки
Из урока
Compiler II: Code Generation
Познакомьтесь с преподавателями
Shimon SchockenProfessor
Computer Science
Welcome to the perspective unit on cogeneration
in which we're going to answer some frequently asked questions as usual.
So Let's see.
You mentioned several times in the course that Jack is a relatively simple language.
What would it take to generate code for a more realistically complex language.
Indeed, very simple.
To begin with, it doesn't really have a type system.
All the data values are 16-bit, and
the data value of any type can be signed to a variable of any other type.
This allows compilers To almost completely
sidestep all the headache that is associated with handling typing issues.
For example, when compiling and evaluating expressions,
jet compilers don't have to bother about determining.
The type of the expression according to the types of
the constituent's elements of these expressions.
Likewise, array entries are also untyped in Jack.
In contrast, most programming languages feature rich and versatile Typing systems.
So different amounts of memory must be allocated for
different types of variables, 16 bits, 32 bits, 64 bits and so on.
The conversion from one type into another requires
specific casting and language operations.
The compilation of expressions like x plus y
depends strongly on the types of x and y and so on and so forth.
All these requirements make compilation much more challenging
Another significant simplification is that Jack does not support inheritance.
This implies that all method calls can be handled by the compiler
statically during compile time.
In languages that do have inheritance like Java Compilers must read
method calls during runtime because they have to determine to which class
the method belongs according to the object on which the method was called to operate.
You know this method is somewhere.
Along the inheritance hierarchy, and
this determines which methods we have to invoke.
This is sometimes called late binding.
And also, and this is completely unrelated to what we discussed before,
Jack has now public fields The only way to access a field from
outside the class is through accessor methods that the programmer must write.
If you look at all these things, the lack of a typing system,
the lack of inheritance, the lack of public fields,
all these simplifications make co generation Far
simpler in Jack compared to compilers of industrial strength languages.
With that, let's move on to the next question.
Well this question is actually related to the first one, how difficult will it be to
close the gaps between Jack In languages like Java or Python.
[COUGH] Well,
some extensions like handling inheritance as I just discussed,
well these extensions require significant code generation efforts.
You know supporting inheritance,
polymorphism, late binding, that's a lot of compilation work.
And yet other simplifications of the Jack language can be easily relaxed.
Well I shouldn't say easily, but they can be relaxed with relatively little effort.
And that's because they are quite straight forward.
For example, we can easily add the control structures like for and switch.
That's not such a big deal in terms of extending our compiler.
And adding more data types aside of the three types we have now,
requires more effort but Once again the extension is relatively straightforward.
Another limitation of Jack is that you can not assign character constants to
variables of type char, C-H-A-R.
In order to bypass this limitation,
the Jack programmer must use all sorts of string functions which is kind of tedious.
Well once again that's an example of a feature that can be easily fixed
in the Jack language.
Using some, we have to both extend the grammar as well as the compiler.
And indeed I would like to observe that Each of
the language extensions that we discuss in general, well, each of these activities,
extending the language, requires two very separate activities.
First af all, the language designer has to sensibly extend the language grammar.
In syntax, and this is something that must be done with great care.
And then, once the specifications have been extended,
the compiler writer must extend the parser and
the code generator in order to accommodate these changes in the language So
altogether, these are big time changes that must be done with great care,
as the language evolves from one version to the other,
as programming languages normally do.
Now, Once again,
there are many things that can be implemented and improved in Jack.
Most of these extensions,
that's the good news is that most of these extensions are independent of each other.
And in that respect, they can be implemented by making relatively local and
simple extensions To the parser and code generator that we're already developed.
So with that, let's move on to the next question.
[COUGH] Which is,
What is the meaning of compiler optimization?
Well, it's not terribly important that the compiler itself
will be efficient at optimizing.
What's important is that.
The compiler will generate low level code, which is efficient and optimized.
And I hope you understand this distinction.
For example, consider high level statement like X++ in, say, Java.
And a Java compiler may translate this statement into Push x,
push one add and pop x, x plus plus.
And then the VN translator will kick in and translate
each one of these four VN commands into several machine level instructions.
We'll end up with something like 50 lines of code.
And so the result would be a considerable chunk of code.
At the same time, an optimized compiler may notice that what we have
here is simply a variable incrementing the operation.
And with that in mind, the compiler or the optimized compiler Will translate
X plus plus into two machine instructions only et
x followed by m equals m plus 1.
That's at least what we could have done in the Jack hack platform.
Of course this is just one example of many optimization
tricks that are expected From a full service compiler.
In general the ability to generate compact code that uses as few cycles and
as little hardware resources as possible well this ability is very attractive,
very attractive feature Of code generation and compilers in general.
Well, none of this optimization was done
in the VM translator that we developed in this module.
So to wrap up my answer to this question, I would like to comment that
Even though the code generator that we developed is un-optimized it's still
represents a sophisticated and substantial piece of engineering.
Once you complete developing this co generator,
you should feel very proud of your accomplishment.
You've just finished developing a compiler,
a compiler for an object based Java-like language.
So Mazel tov And with that,
that's the end of our module.
Module five.
And in the next module we're going to develop and operating system.
And this operating system will be developed using Jack language.
Ознакомьтесь с нашим каталогом
Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.
Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.
© Coursera Inc., 2019 Все права защищены.
