dexianta/fa19

6.035 Computer Language Engineering FA19

Any and all information about 6.035 Fall 2019!

There are two websites for 6.035 fa19:

1. this page
2. Piazza

WE WILL MAKE ALL ANNOUNCEMENTS VIA PIAZZA, SO MAKE SURE THAT YOU ENROLL

If neither site has the information you need, you should email the TA's directly

Table of Contents

1. 6.035 Computer Language Engineering
   1. Schedule
   2. General Administrivia
      1. Course Staff
      2. MIT Catalog Description
      3. Recommended Texts
      4. Communication
      5. Grading and attendance policy
      6. Late policy
      7. Collaboration
      8. Compiler Building and Running
      9. Third-party Libraries
      10. Class meetings
      11. Contact
      12. Office Hours and Relectures
   3. Reference Materials
      1. Official References
         1. Provided During Exams
      2. Unofficial References

Schedule

Official MIT Calendar

                                            2019
     September                October                 November                December
Su Mo Tu We Th Fr Sa    Su Mo Tu We Th Fr Sa    Su Mo Tu We Th Fr Sa    Su Mo Tu We Th Fr Sa
 1  2  3  4  5  6  7           1  2  3  4  5                    1  2     1  2  3  4  5  6  7
 8  9 10 11 12 13 14     6  7  8  9 10 11 12     3  4  5  6  7  8  9     8  9 10 11 12 13 14
15 16 17 18 19 20 21    13 14 15 16 17 18 19    10 11 12 13 14 15 16    15 16 17 18 19 20 21
22 23 24 25 26 27 28    20 21 22 23 24 25 26    17 18 19 20 21 22 23    22 23 24 25 26 27 28
29 30                   27 28 29 30 31          24 25 26 27 28 29 30    29 30 31

Note: L: parsing~55 means that the topic was parsing and we covered up to slide 55

	Monday	Tuesday	Wednesday	Thursday	Friday
09/02 - 09/06			FIRST DAY L: overview piazza project info survey	L: regex	L: regex
09/09 - 09/13	P1 INFO SESS L: grammar~55 course tools decaf spec P1 RELEASE	L: grammar~62	L: parsing~46	L: parsing~72	L: parsing~64
09/16 - 09/20	L: parsing~94	L: parsing~$	P1 DUE	P2 INFO SESS P2 RELEASE L: high-IR~16	Career Fair
09/23 - 09/27	SUBMIT TEAM L: high-IR~52	L: high-IR~76 L: semantic~29	L: semantic~46
09/30 - 10/04	L: high-IR~$ L: semantic~$	L: codegen~22	L: codegen~59	L: codegen:~70	P2 DUE P3 RELEASE
10/07 - 10/11	L: codegen~124	L	L		QUIZ 1 quiz solutions
10/14 - 10/18	Columbus Day	Columbus Day	L: opt~59	L: dataflow~16
10/21 - 10/25	L: dataflow~$				Family Weekend
10/28 - 11/01			P3 DUE
11/04 - 11/08	L: dataflow~22	L: dataflow~$	L: loops~18	L: loops~$	L: reg~74
11/11 - 11/15		P4 DUE L: lattice~27	L: lattice~49	L: lattice~$	L: lattice~$
11/18 - 11/22	L: lattice~$	L: parallel~47	DROP DATE L: parallel~$
11/25 - 11/29				Thanksgiving	Thanksgiving
12/02 - 12/06		QUIZ 2		CHECKPOINT
12/09 - 12/13		P5 DUE	LAST DAY DERBY

General Administrivia

Course Staff

• Professor
  • Martin Rinard [email protected]
• TA's
  • Jackie Bredenberg [email protected]
  • Jack Choi [email protected]

MIT Catalog Description

• Prereq -- 6.004, 6.031
• Level -- U
• Units -- 4-4-4

Analyzes issues associated with the implementation of higher-level programming languages. Fundamental concepts, functions, and structures of compilers. The interaction of theory and practice. Using tools in building software. Includes a multi-person project on compiler design and implementation.

Recommended Texts

6.035 has no officially required textbook. All of the material you need is taught in class, with the exception of the documentation for your implementation language and associated libraries. However, the following books may be helpful in implementing various components of your compiler, and are available from MIT libraries.

Modern Compiler Implementation in Java (Tiger Book)
Andrew W. Appel and Jens Palsberg
Cambridge University Press, 2002

Many other resources such as technical papers, interesting and useful blog posts, and reference guides are available on the references page.

Communication

We will distribute assignments and make all announcements via Piazza and GitHub (this) page. Important announcements will also be made via email.

Since lecture dates are not all finalized at the start of the semester, please pay attention to the schedule.

Grading and attendance policy

Your grade in 6.035 is based upon four components: your compiler, two quizzes, and the mini-quizzes at the beginning of every lecture. You must therefore attend all lectures in order to take the mini-quizzes and receive a full grade.

For more information on the way the compiler project is graded, see the projects overview handout from the first recitation.

Late policy

We expect you to attend all quizzes and submit the project on time. For extensions under extenuating circumstances (e.g., you are sick for a week, family emergencies), we require a letter from one of the student deans at S^3.

Collaboration

Although you may discuss the projects with anybody, you must develop the code yourself. For the scanner/parser project, you must develop your code alone. On all subsequent projects, you should work with your team members, but you may not develop or share any code with other teams.

You may collaborate on the mini-quizzes, but you may not collaborate with anybody on the full quizzes; doing so will result in a failing grade.

Do not post your lab or homework solutions on publicly accessible web sites or file spaces; this enables cheating for students in future years.

Compiler Building and Running

We will use the software provided by the Athena infrastructure to evaluate each group project. The project skeletons contain the scripts that will automatically build and run your projects.

The submitted project should be self-contained. With the exception of the languages and libraries provided by the Athena infrastructure, all code and libraries (when applicable; see the next section) should be contained within the submitted archive.

Make sure to build and run your compiler on the Athena infrastructure before submitting it for evaluation. If we are not able to automatically build or run your compiler using the scripts provided with the project skeletons, it will incur a 25% penalty on the number of points for this project.

Third-party Libraries

In 6.035, you build a compiler almost entirely from scratch. There are a few allowed exceptions: you may use one of the approved parser generators, described in the first project & athena handouts. You may use various language APIs for working with collections and data types. However, there are some restrictions on that. For example, users of Haskell may not use Haskell's Data.Graph or Compiler packages.

Any libraries beyond the Java API or basic Scala libraries must be approved by the TA. We will not allow more advanced libraries, such as the PackratParsers package. In general, if you are unsure of whether or not you are allowed to use a piece of software, ask the TA.

Class meetings

Lectures:

• 11am-12pm MTWRF in 32-144.

To find out whether there is lecture on a given day, check calendar above.

Contact

For all general questions and/or concerns, please post on Piazza.

If the matter is private, please email the TA's directly.

Office Hours and Relectures

Office Hours:

• Tuesday's 4pm-6pm in 34-304
• additional ones available via request

Relecture:

• Monday's 7pm-9pm in 34-304
• Thursday's 4pm-5pm in 34-304
• additional ones available via request

Note that relectures are only held if students email the TA's in advance to request one.

We will have additional office hours before each quiz and each phase of the project.

Reference Materials

This section contains a number of useful and/or interesting references selected by the staff. You are not expected to know most of the material on this page for quizzes or for implementing your compiler; however, you may find it interesting and helpful.

Official References

1. Decaf language spec TODO link
2. The complete Intel x64 manual
3. Intel x64 Optimization Reference Manual
4. x64 wiki
5. x64 cheat sheet -- lists and tables detailing registers and assembly commands
6. x86-64 architecture guide -- a walkthrough with an example, and common commands
7. Intel x64 manual
8. Intel developer manual -- detailed description of some assembly instructions

Provided During Exams

1. x64 cheat sheet -- lists and tables detailing registers and assembly commands

Unofficial References

Interesting blog posts, papers, etc

1. Overviews
   1. LLVM compiler architecture
   2. GCC compiler architecture
2. Blogs
   1. Russ Cox's Blog -- Russ is one of the developers of Google Go, a pretty interesting language.
   2. Ian Wienand's Blog -- Whoever he is, he writes about compiler and language internals, the magic black box that is the linker, and more
   3. Matt Might's Blog -- Matt is a professor at the University of Utah and has written some very interesting articles (e.g. "Yacc is dead")
3. Papers
   1. Register Allocation & Spilling via Graph Coloring -- G.J. Chaitin / 1982. Great (short) paper on simple register allocation.
   2. Linear Scan Register Allocation
   3. Iterated Register Coalescing -- Lal George / 1996. Presents improvements/alternative to Chaitin's design. If Chaitin-style (+/-Briggs) register allocation isn't enough for you, this paper is a good read - actually, it's a good read anyway, to understand the tradeoffs
   4. Superword Level Parallelism combined with loop unrolling, a simple way to implement a vectorizing compiler
4. Miscellaneous
   1. Scala Patterns for Compiler Design
   2. 6.823 Advanced Computer Architecture lecture notes