Courses/CcmpTylaLogIng2016 (Ing1 students)

This page contains the log of the topics of

• the Compiler Construction Course 1 (CMP1),
• the Compiler Construction Course 2 (CMP2), and
• the Typology of Programming Languages Course (TYLA)

for Ing1 students of class EPITA 2016 (i.e., from December 2013 to June 2014). The topic was started with the Formal Languages Lecture (THL).

CMP1

Lecture 1: 2013-12-09 (Grp. B & A), 2 hours: Introduction to the Tiger Project

1. Introduction to The Tiger Project. See the lecture notes: tiger-project-intro.pdf, tiger-project-intro-handout.pdf and tiger-project-intro-handout-4.pdf.
   1. Ressources (http://www.lrde.epita.fr/~tiger/).
      1. Assignments (http://www.lrde.epita.fr/~tiger/assignments.html).
      2. Appel's books.
      3. Tiger Compiler Reference Manual (http://www.lrde.epita.fr/~tiger/tiger.html).
      4. epita.cours.compile.
   2. Goals (C++, OO, DP, Management, Several Iterations, Testing, Documenting, Maintaining, Fixing, Understanding Computers, English).
   3. Non goals (Compiler Construction).
   4. Rules of the Game.
      1. No copy between groups.
      2. Tests are part of the project (test cases and frameworks should not be exchanged).
      3. Fixing mistakes earlier is better.
      4. Work between groups is encouraged as long as they don't cheat.
   5. Tests.
      1. Tests matter.
      2. Rules.
         1. A bug => a test.
         2. A suspicious behavior => one or several tests to isolate it.
         3. Don't throw away tests!
         4. Don't exchange tests! (bis repetita).
   6. C Compilation model (cpp, cc1, as, ld).
   7. Width of a compiler (granularity of compiled entities).
   8. Tiger Compiler pipeline (front end only)
   9. Compilers handling multiple input (sources languages) and multiple outputs (target assembly languages/processors).
      1. The case of GCC.
      2. Factoring the compiler components: intermediate representation(s).
      3. Front-end and back-ends.

Lecture 2: 2013-12-16 (Grp. B & A), 2 hours: Introduction to the Tiger Project (cont.), Architecture of tc (tasks), Autotools

1. Introduction (cont.)
   1. Other compilation strategies.
   2. The Tiger Compiler pipe (annotated with tools and steps).
      1. Front-end: TC-0 - TC-3 (mandatory part), TC-4 - TC-5 (optional part).
      2. Back-end: TC-6 - TC-9 (optional part).
   3. Misc: students should overcome Make, Makefiles and separate compilation, etc.
2. Architecture of the Tiger Compiler (tc).
   1. Modules: parse, ast, bind, etc.
      1. Pure libraries providing actual services.
      2. Tasks (non-pure services) using a declarative system: Development Tools, section 1 (tc Tasks). See the lecture notes: dev-tools.pdf, dev-tools-handout.pdf and dev-tools-handout-4.pdf.
         1. Command-line options.
         2. Declaration of dependencies.
         3. Actual computations delegated to pure libraries.
   2. Driver (tc.cc).
      1. Instantiates a tasks manager, used to record all existing tasks at start-up and later compute the steps to performe according to the dependencies of the invoked tasks.
      2. Workflow computed by the task manager from the options passed to the driver, triggering corresponding tasks and their dependencies ( la Make).
      3. Error management: catches exceptions (including misc::error) and displays error messages.
3. Autoconf and Automake
   1. History: Unix, Unices, configuration systems (imake, configure), portability issues (broken tools, broken/missing functions, libraries, etc.).
   2. Generating configure with Autoconf
      1. The choice of (a subset of) the Bourne Shell for portability reasons.
      2. Generating to encapsulate tests, simplify, shorten and reuse shell script bits.
      3. Using the M4 macro language.
      4. Autotools Diagram: Autoconf.
   3. Generating Makefile (s) with Automake and configure.
      1. Generating to simplify and shorten portable Makefile bits.
      2. Substituting variables (@VAR@) in Makefile.in using configure (BTW: variables listed in configure --help).
      3. Completing the Autotools diagram: Automake.
      4. Developer side vs User side.
   4. A word on aclocal.
   5. Hands-on example.
      1. A simple program.
         1. Writing hello-world.cc.
         2. Adding Makefile.am.
         3. Running autoscan.
         4. Adjusting config.scan to create config.ac (initializing Automake, avoiding autoheader).
         5. Running alocal, automake -a -c (and installing helpers) and autoconf.
         6. Running ./configure.
         7. Running make.
         8. Running ./hello-world.

Lectures 3 : 2014-02-17 (Grp. A & B), 2 hours: Autotools (cont.), Development Tools

1. Autoconf and Automake (cont.)
   1. Hands-on example (cont.)
      1. Adding a (static) library.
         1. Writing the client (hello.cc) and the library (greet.hh and greet.cc).
         2. Adjusting Makefile.am (lib_LIBRARIES vs noinst_LIBRARIES), and configure.ac (AC_PROG_RANLIB).
         3. Updating by running make (and not the Autotools).
         4. Compiling the client (hello) by adjusting Makefile.am (in particular, link to libgreet.a using hello_LDADD).
         5. Running make again.
         6. Running ./hello.
      2. Adding tests.
         1. TESTS in Makefile.am and make check.
         2. Compiling test-only (not installed) programs: check_PROGRAMS.
      3. Distributing.
         1. make dist.
         2. make distcheck.
         3. Don't forget to adjust the arguments of AC_INIT in configure.ac.
      4. Installing.
         1. make install.
         2. configure --prefix, $prefix, $bindir, $libdir, etc. and bin_, lib_ prefixes of primaries (PROGRAMS, LIBRARIES, etc.).
         3. make uninstall (careful, very limited).
   2. Misc.
      1. Generating tests with configure (e.g. so that they can find $srcdir).
      2. Changing variables (e.g. CXXFLAGS) at the configuration step (=./configure CXXFLAGS...=; global) or at the build step (=make CXXFLAGS...=; local).
      3. autoheader and config.h: getting rid of limitations of using -D options to pass options to the compiler.
      4. Pros and cons of using multiple Makefile s in a multi-directory project.
      5. srcdir vs builddir, running configure from a directory other than the source dir.
2. Development Tools. See the lecture notes: dev-tools.pdf, dev-tools-handout.pdf and dev-tools-handout-4.pdf.

Lecture 4: 2014-02-21 (Grp. A & B), 2 hours: Scanner and Parser Hints

1. Additional details and hints about the scanner and the parser: The Scanner and the Parser. See the lecture notes: scanner.pdf, scanner-handout.pdf and scanner-handout-4.pdf.
   1. Symbols (light-weight, shared and non-mutable strings used to represent identifiers).
   2. Extra information (in addition to tokens/terminals) passed between the scanner and the parser.
      1. Semantic values.
      2. Locations.
   3. Various improvements on the scanner and the parser.
      1. Error recovery by deletion (using the error symbol).
      2. Pure (reentrant) parser and scanner.

Lecture 5: 2014-02-24 (Grp. A & B), 2 hours: Abstract Syntax

• Abstract Syntax, up to basic Visitors (sec. 2.3, p. 51). See the lecture notes, ast.pdf, ast-handout.pdf and ast-handout-4.pdf.

Lecture 6: 2014-02-25 (Grp. B & A), 2 hours: Abstract Syntax [in lieu of TYLA]

• Abstract Syntax, up to the end. See the lecture notes, ast.pdf, ast-handout.pdf and ast-handout-4.pdf.

Lecture 7: 2013-03-04 (Grp. B & A), 2 hours: Names, Identifiers and Bindings

• Names, Identifiers and Bindings, up to Scoped Symbol Table Implementations. See the lecture notes (section 1 and 2, unfinished), names.pdf, names-handout.pdf and names-handout-4.pdf.
• TC's Binder explained.
  • Traversal and use of the symbol tables.
  • Chunks (ast::TypeDecs, ast::FunctionDecs) and how they are processed by bind::Binder.

CMP2

Lecture 1: 2014-03-14 (Grp. A & B), 2 hours: Names, Identifiers and Bindings, Type-checking

1. Names, Identifiers and Bindings: Complications. See the lecture notes (section 3), names.pdf, names-handout.pdf and names-handout-4.pdf.
2. Types. See the lecture notes (sections 1 and intro to section 2): type-checking.pdf, type-checking-handout.pdf and type-checking-handout-4.pdf.

Lecture 2: 2014-03-18 (Grp. B & A), 2 hours: Type-checking

1. Types. See the lecture notes (up to the end): type-checking.pdf, type-checking-handout.pdf and type-checking-handout-4.pdf.
2. Some details on the implementation of types and type-checking within the Tiger Compiler.
   1. Hierarchy of types (src/type/)
      1. src/type/README.
      2. Implementing atomic types: singletons.
      3. Resolving aliased types: Named and actual().
3. Sequent Calculus
   1. In English: "If alpha is of type Int in the context Gamma and beta is of type Int in the context Gamma, then alpha + beta is of type Int in the context Gamma."
   2. Using symbols (where ⊢ ("tee" or "turnstile") is the symbol meaning "yields" or "proves"): ${\frac {\Gamma \vdash \alpha :Int\quad \Gamma \vdash \alpha :Int}{\Gamma \vdash \alpha +\beta :Int}}$
   3. Examples of type rules: addition of 2 integers, if-then-else, if-then, addition of 3 integers, comparison of two variables, etc.
   4. Type inference
      1. (a ? b : c) > 0
      2. (a ? b : f(b)) > 0
      3. (a ? b : f(c)) > 0

Lecture 3: 2014-04-28 (Grp. B) & 2014-04-29 (Grp. A), 2 hours: Intermediate languages

1. Intermediate languages. See the lecture notes (up to section 4.1 (included), except details about intermediate representations (sec. 1.1), details dynamic allocation (sec 2.1), non-local variables & static link (sec. 2.2)): intermediate.pdf, intermediate-handout.pdf and intermediate-handout-4.pdf.

Lecture 4: 2014-05-26 (Grp. B) & 2014-05-27 (Grp. A), 2 hours: Intermediate languages (cont.), Canonization

1. Intermediate languages: details about intermediate representations (sec. 1.1), details dynamic allocation (sec 2.1), non-local variables & static link (sec. 2.2). See the lecture notes: intermediate-handout.pdf and intermediate-handout-4.pdf.
2. Canonization. See the lecture notes (section 4.2): intermediate.pdf, intermediate-handout.pdf and intermediate-handout-4.pdf.

Lecture 5: 2014-06-06 (Grp. B & A), 2 hours: Microprocessors, Instruction Selection, Introduction to Liveness Analysis

1. Microprocessors, Instruction Selection. See the lecture notes: instr-selection.pdf, instr-selection-handout.pdf and instr-selection-handout-4.pdf.
2. Examples of MonoBURG input files from the Tiger Compiler (Tree to MIPS).
3. Liveness Analysis. See the lecture notes: liveness.pdf, liveness-handout.pdf and liveness-handout-4.pdf.

Lecture 6: 2014-06-09 (Grp. B) & 2014-06-10 (Grp. A), 2 hours: Liveness Analysis, Register Allocation

1. Liveness Analysis. See the lecture notes: liveness.pdf, liveness-handout.pdf and liveness-handout-4.pdf.
2. Register Allocation: Coloring by Simplification, Spilling, Coalescing, Precolored Nodes, Caller- and Callee-Saved Registers, Implementation, Alternatives to Graph Coloring. See the lecture notes: regalloc.pdf, regalloc-handout.pdf and regalloc-handout-4.pdf.

TYLA

Lecture 1: 2014-02-27 (Grp. A & B), 2 hours: History of Computing

• History of Computing: A Short Computer History Chronology (section 1). See the lecture notes, history.pdf, history-handout.pdf and history-handout-4.pdf.

Lecture 2: 2014-03-07 (Grp. B & A), 2 hours: History of Computing and Programming Languages

1. History of Computing: Some Early Machines (section 2). See the lecture notes, history.pdf, history-handout.pdf and history-handout-4.pdf.
2. History of Programming Languages: The Very First Ones: FORTRAN, Algol, COBOL (Section 1). See the lecture notes, early-languages.pdf, early-languages-handout.pdf and early-languages-handout-4.pdf.

Lecture 3: 2014-03-11 (Grp. B & A), 2 hours: History of Programming Languages, Object-Oriented History

1. History of Programming Languages: The Second Wave: APL, PL/I, BASIC, Pascal & Heirs (Section 2) and The Finale (Section 3). See the lecture notes, early-languages.pdf, early-languages-handout.pdf and early-languages-handout-4.pdf.
2. Object-Oriented History: Simula. See the lecture notes, object.pdf, object-handout.pdf and object-handout-4.pdf.

Lecture 4: 2014-03-19 (Grp. B & A), 2 hours: Object-Oriented History: Smalltalk

1. Object-Oriented History: Smalltalk. See the lecture notes, object.pdf, object-handout.pdf and object-handout-4.pdf.

Lecture 5: 2014-03-25 (Grp. B & A), 2 hours: Some Traits of Functional Programming Languages, Generic Programming

1. Object-Oriented History: Smalltalk, C++. See the lecture notes, object.pdf, object-handout.pdf and object-handout-4.pdf.
2. Generic Programming, except Template Metaprogramming (section 4.2). See the lecture notes, generic.pdf, generic-handout.pdf and generic-handout-4.pdf.
3. Subprograms (sections 1 and 2). See the lecture notes, subprograms.pdf, subprograms-handout.pdf and subprograms-handout-4.pdf.