Coursera compilers
English | Size: 1.22 GB (1,314,931,973 Bytes)
Category: Tutorial
This course will discuss the major ideas used today in the implementation of programming language compilers. You will learn how a program written in a high-level language designed for humans is systematically translated into a program written in low-level assembly more suited to machines!
This course will discuss the major ideas used today in the implementation of programming language compilers. You will learn how a program written in a high-level language designed for humans is systematically translated into a program written in low-level assembly more suited to machines!
This course will discuss the major ideas used today in the implementation of programming language compilers, including lexical analysis, parsing, syntax-directed translation, abstract syntax trees, types and type checking, intermediate languages, dataflow analysis, program optimization, code generation, and runtime systems. As a result, you will learn how a program written in a high-level language designed for humans is systematically translated into a program written in low-level assembly more suited to machines. Along the way we will also touch on how programming languages are designed, programming language semantics, and why there are so many different kinds of programming languages.
The course lectures will be presented in short videos. To help you master the material, there will be in-lecture questions to answer, quizzes, and two exams: a midterm and a final. There will also be homework in the form of exercises that ask you to show a sequence of logical steps needed to derive a specific result, such as the sequence of steps a type checker would perform to type check a piece of code, or the sequence of steps a parser would perform to parse an input string. This checking technology is the result of ongoing research at Stanford into developing innovative tools for education, and we’re excited to be the first course ever to make it available to students.
An optional course project is to write a complete compiler for COOL, the Classroom Object Oriented Language. COOL has the essential features of a realistic programming language, but is small and simple enough that it can be implemented in a few thousand lines of code. Students who choose to do the project can implement it in either C++ or Java.
I hope you enjoy the course!
Why Study Compilers?
Everything that computers do is the result of some program, and all of the millions of programs in the world are written in one of the many thousands of programming languages that have been developed over the last 60 years. Designing and implementing a programming language turns out to be difficult; some of the best minds in computer science have thought about the problems involved and contributed beautiful and deep results. Learning something about compilers will show you the interplay of theory and practice in computer science, especially how powerful general ideas combined with engineering insight can lead to practical solutions to very hard problems. Knowing how a compiler works will also make you a better programmer and increase your ability to learn new programming languages quickly.
->FAQ
-Will I get a statement of accomplishment after completing this class?
-Yes. Students who successfully complete the class will receive a statement of accomplishment signed by the instructor.
-How is the class structured?
-Each week there will be a number of videos to watch, most of which will include an in-video quiz question to answer. Most weeks there will also be homeworks (done on-line) and a quiz. There will be also be a midterm and a final exam. For those doing the course project, there will be 5 programming assignments, which you will do on your own using infrastructure that we provide.
-Are the lectures available in a file format?
-Yes. The slides from the lectures will be available in both annotated and unannotated form.
-Do I need a textbook?
-No, no textbook is required for the class. However, you may find a textbook useful as a reference or to learn more details of some of the ideas discussed in the course. There are a number of good textbooks on compilers; here are three in particular:
Compilers: Principles, Techniques, and Tools (Second Edition)
Alfred Aho, Monica Lam, Ravi Sethi, and Jeffrey Ullman.
Addison-Wesley
Modern Compiler Implementation in Java (Second Edition)
Andrew Appel and Jens Palsberg.
Cambridge University Press
Engineering a Compiler
Keith Cooper and Linda Torczon
Morgan Kaufman
-How do I ask questions?
-There will be an on-line discussion forum in which students can ask questions and receive answers. While the scale of an on-line class means that often the fastest (and best!) answer comes from another student, the course staff will monitor the discussions for accuracy and to address questions where the student community particularly wants to hear from the staff.
-Is the compiler project required?
-No. You can take the class without doing the programming assignments.
-How difficult is the compiler project? What background and tools do I need?
-This question is very hard to answer as the level of difficulty will vary depending on your programming background. As a rough guide, you should already be an experienced programmer and be comfortable writing substantial C++ or Java programs; writing a compiler is not a good way to learn either programming or these particular languages. The project also makes use of software tools, so you should also be comfortable learning to use new tools on your own. It is not a problem if you start the project but don’t finish it; we will just consider you to be enrolled in the non-project option of the class in this case.
->File list:
+—01 – Introduction
| +—01 – 01-01 Introduction (8m20s)
| +—02 – 01-02 Structure of a Compiler (13m53s)
| \—03 – 01-03 The Economy of Programming Languages (19m51s)
+—02 – The Cool Programming Language
| +—01 – 02-01 Cool Overview (19m58s)
| +—02 – 02-02 Cool Example II (15m04s)
| \—03 – 02-03 Cool Example III (18m05s)
+—03 – Lexical Analysis
| +—01 – 03-01 Lexical Analysis (12m06s)
| +—02 – 03-02 Lexical Analysis Examples (13m03s)
| +—03 – 03-03 Regular Languages (12m36s)
| +—04 – 03-04 Formal Languages (13m40s)
| +—05 – 03-05 Lexical Specifications (16m19s)
| \—06 – DeduceIt Demo (8m25s)
+—04 – Finite Automata
| +—01 – 04-01 Lexical Specification (14m30s)
| +—02 – 04-02 Finite Automata (23m28s)
| +—03 – 04-03 Regular Expressions into NFAs (9m41s)
| +—04 – 04-04 NFA to DFA (15m12s)
| \—05 – 04-05 Implementing Finite Automata (11m56s)
+—05 – Parsing
| +—01 – 05-01 Introduction to Parsing (5m31s)
| +—02 – 05-02 Context Free Grammars (14m07s)
| +—03 – 05-03 Derivations (7m37s)
| \—04 – 05-04 Ambiguity (17m35s)
+—06 – Top-Down Parsing
| +—01 – 06-01 Error Handling (13m03s)
| +—02 – 06-02 Abstract Syntax Trees (3m50s)
| +—03 – 06-03 Recursive Descent Parsing (6m35s)
| +—04 – 06-04 Recursive Descent Algorithm (13m28s)
| +—05 – 06-04-1 Recursive Descent Limitations (6m56s)
| \—06 – 06-05 Left Recursion (9m11s)
+—07 – Bottom-Up Parsing I
| +—01 – 07-01 Predictive Parsing (19m37s)
| +—02 – 07-02 First Sets (14m02s)
| +—03 – 07-03 Follow Sets (17m05s)
| +—04 – 07-04 LL1 Parsing Tables (14m41s)
| +—05 – 07-05 Bottom-Up Parsing (7m25s)
| \—06 – 07-06 Shift-Reduce Parsing (7m37s)
+—08 – Bottom-Up Parsing II
| +—01 – 08-01 Handles (6m48s)
| +—02 – 08-02 Recognizing Handles (13m12s)
| +—03 – 08-03 Recognizing Viable Prefixes (14m57s)
| +—04 – 08-04 Valid Items (3m31s)
| +—05 – 08-05 SLR Parsing (14m16s)
| +—06 – 08-06 SLR Parsing Example (6m42s)
| +—07 – 08-07 SLR Improvements (11m49s)
| \—08 – 08-08 SLR Examples (12m47s)
+—09 – Semantic Analysis and Type Checking
| +—01 – 09-01 Introduction to Semantic Analysis (3m42s)
| +—02 – 09-02 Scope (8m09s)
| +—03 – 09-03 Symbol Tables (11m06s)
| +—04 – 09-04 Types (11m22s)
| +—05 – 09-05 Type Checking (8m43s)
| +—06 – 09-06 Type Environments (11m43s)
| +—07 – 09-07 Subtyping (11m35s)
| +—08 – 09-08 Typing Methods (8m12s)
| \—09 – 09-09 Implementing Type Checking (6m57s)
+—10 – Cool Type Checking
| +—01 – 10-01 Static vs. Dynamic Typing (7m14s)
| +—02 – 10-02 Self Type (7m36s)
| +—03 – 10-03 Self Type Operations (12m12s)
| +—04 – 10-04 Self Type Usage (6m29s)
| +—05 – 10-05 Self Type Checking (10m00s)
| \—06 – 10-06 Error Recovery (7m07s)
+—11 – Runtime Organization
| +—01 – 11-01 Runtime Organization (6m44s)
| +—02 – 11-02 Activations (13m50s)
| +—03 – 11-03 Activation Records (13m11s)
| +—04 – 11-04 Globals and Heap (6m56s)
| +—05 – 11-05 Alignment (6m04s)
| \—06 – 11-06 Stack Machines (16m23s)
+—12 – Code Generation
| +—01 – 12-01 Introduction to Code Generation (7m57s)
| +—02 – 12-02 Code Generation I (17m26s)
| +—03 – 12-03 Code Generation II (18m08s)
| +—04 – 12-04 Code Generation Example (13m17s)
| +—05 – 12-05 Temporaries (16m14s)
| \—06 – 12-06 Object Layout (23m56s)
+—13 – Operational Semantics
| +—01 – 13-01 Semantics Overview (7m06s)
| +—02 – 13-02 Operational Semantics (12m20s)
| +—03 – 13-03 Cool Semantics I (21m10s)
| \—04 – 13-04 Cool Semantics II (26m13s)
+—14 – Local Optimization
| +—01 – 14-01 Intermediate Code (9m03s)
| +—02 – 14-02 Optimization Overview (13m37s)
| +—03 – 14-03 Local Optimization (25m35s)
| \—04 – 14-04 Peephole Optimization (4m29s)
+—15 – Global Optimization
| +—01 – 15-01 Dataflow Analysis (8m02s)
| +—02 – 15-02 Constant Propagation (21m11s)
| +—03 – 15-03 Analysis of Loops (7m22s)
| +—04 – 15-04 Orderings (6m34s)
| \—05 – 15-05 Liveness Analysis (13m39s)
+—16 – Register Allocation
| +—01 – 16-01 Register Allocation (9m56s)
| +—02 – 16-02 Graph Coloring (12m07s)
| +—03 – 16-03 Spilling (14m50s)
| \—04 – 16-04 Managing Caches (10m37s)
+—17 – Garbage Collection
| +—01 – 17-01 Automatic Memory Management (14m53s)
| +—02 – 17-02 Mark and Sweep (13m05s)
| +—03 – 17-03 Stop and Copy (19m03s)
| +—04 – 17-04 Conservative Collection (3m31s)
| \—05 – 17-05 Reference Counting (15m23s)
\—18 – Java
+—01 – 18-01 Java (7m21s)
+—02 – 18-02 Java Arrays (8m15s)
+—03 – 18-03 Java Exceptions (14m09s)
+—04 – 18-04 Java Interfaces (8m38s)
+—05 – 18-05 Java Coercions (7m51s)
+—06 – 18-06 Java Threads (18m36s)
\—07 – 18-07 Other Topics (14m28s)
DOWNLOAD:
http://uploaded.net/file/c1ny9mle/Coursera%20compilers.part1.rar
http://uploaded.net/file/odrtpcu8/Coursera%20compilers.part2.rar
http://uploaded.net/file/oystpiuc/Coursera%20compilers.part3.rar
http://rapidgator.net/file/3209cb4068ca039cee9be04ec159e3d2/Coursera_compilers.part1.rar.html
http://rapidgator.net/file/659744e415a09332eb93de38ea7a78e6/Coursera_compilers.part2.rar.html
http://rapidgator.net/file/032c6b90224c8131bfd42e48217a157c/Coursera_compilers.part3.rar.html
If any links die or problem unrar, send request to http://goo.gl/aUHSZc
Leave a Reply