This page contains the log of the topics of

for Ing1 students of class EPITA 2014 (i.e., from November 2011 to May 2012). The topic was started with the Formal Languages Lecture (THL).


Lecture 1: 2011-11-21 (Grp. B & A), 2 hours: Introduction to the Project (%roland%)

  1. 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/~akim/ccmp/).
      1. Assignments (http://www.lrde.epita.fr/~akim/ccmp/assignments.html).
      2. Appel's books.
      3. Tiger Compiler Reference Manual (http://www.lrde.epita.fr/~akim/ccmp/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. Tiger Compiler pipeline (front end only)
    8. 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.
    9. Other compilation strategies.
    10. 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).
    11. Misc: students should overcome Make, Makefiles and seperate compilation, etc.

Lecture 2: 2011-12-05 (Grp. B & A), 2 hours: Architecture of tc (tasks), Scanner and Parser hints, Abstract Syntax (%roland%)

  1. 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.
    1. 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.
  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.
  1. Abstract Syntax. See the lecture notes,

ast.pdf, ast-handout.pdf and ast-handout-4.pdf (sections 1.1 and 1.2).

Lecture 3: 2011-12-12 (Grp. A & B), 2 hours: Abstract Syntax (%roland%)

Lecture 4: 2012-01-30 (Grp. A & B), 2 hours: Development Tools: Autoconf and Automake (%roland%)

  1. 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.
      2. 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.
      3. Adding tests.
        1. TESTS in Makefile.am and make check.
        2. Compiling test-only (not installed) programs: check_PROGRAMS.
      4. Distributing.
        1. make dist.
        2. make distcheck.
        3. Don't forget to adjust the arguments of AC_INIT in configure.ac.
      5. 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).
    6. 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.

Lecture 5: 2012-02-02 (Grp. A & B), 2 hours: C++ 2011, Development Tools, Abstract Syntax (%roland%)

  1. New features from C++ 2011 used in the Tiger Project.
    1. nullptr.
    2. Range-based for loops.
    3. consecutive right angle brackets (>>).
    4. auto typed variables.
    5. Defaulted and deleted functions.
  2. Abstract Syntax, up to the end. See the lecture notes,

ast.pdf, ast-handout.pdf and ast-handout-4.pdf.

  1. Development Tools, sections 2 (rapidly) and 3. See the lecture notes:

dev-tools.pdf, dev-tools-handout.pdf and dev-tools-handout-4.pdf.

Lecture 6: 2012-02-03 (Grp. A & B), 2 hours: Names, Identifiers and Bindings (%roland%)


Lecture 1: 2012-02-21, 2 hours: Type-checking (%roland%)

  1. Types. See the lecture notes (sections 1 and 2):

type-checking.pdf, type-checking-handout.pdf and type-checking-handout-4.pdf.

  1. 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().

Lecture 2: 2012-02-28, 2 hours: Type-checking, Intermediate languages (%roland%)

  1. 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."

    1. Using symbols (where ⊢ ("tee" or "turnstile") is the symbol meaning "yields" or "proves"):

Failed to parse (syntax error): {\displaystyle <semantics> <mfrac> <mrow> <mo stretchy="false">&#915;</mo> <mi>&#8866;</mi> <mo stretchy="false">&#945;</mo> <mi mathvariant="normal">:</mi> <mtext>Int</mtext> <mi/> <mo stretchy="false">&#915;</mo> <mi>&#8866;</mi> <mi mathvariant="italic">&#946;</mi> <mi mathvariant="normal">:</mi> <mtext>Int</mtext> </mrow> <mrow> <mo stretchy="false">&#915;</mo> <mi>&#8866;</mi> <mrow> <mo stretchy="false">&#945;</mo> <mo stretchy="false">+</mo> <mi mathvariant="italic">&#946;</mi> </mrow> <mi mathvariant="normal">:</mi> <mtext>Int</mtext> </mrow> </mfrac> </semantics> }

    1. Examples of type rules: addition of 2 integers, if-then-else, if-then, addition of 3 integers, comparison of two variables, etc.
    2. Type inference
      1. (a_ ? _b : _c_) > 0
      2. (a_ ? _b : f_ (_b)) > 0
      3. (a_ ? _b : f_ (_c)) > 0
  1. Intermediate languages. See the lecture notes (up to section 1.2 (included)):

intermediate.pdf, intermediate-handout.pdf and intermediate-handout-4.pdf.

Lecture 3: 2012-03-06, 2 hours: Intermediate languages (%roland%)

Lecture 4: 2012-03-20, 1 hour: Canonization (%roland%)

Lecture 5: 2012-04-26, 1 hour: Microprocessors, Instruction Selection (%roland%)

Lecture 6: 2012-05-15, 2 hours: Instruction Selection, Liveness Analysis, Register Allocation (%roland%)

Lecture 7: 2012-05-31, 2 hours: Register Allocation, Dynamic Dispatch Implementation (%roland%)

  • Register Allocation: Coalescing, Precolored Nodes, Caller- and Callee-Saved Registers, Implementation, Alternatives to Graph Coloring. See the lecture notes (up to the end): regalloc.pdf, regalloc-handout.pdf and regalloc-handout-4.pdf.
  • Alternatives to Graph Coloring: an example of register allocation on trees.
  • Dynamic Dispatch Implementation in Object-Oriented Languages.
    • The C++ approach (virtual function tables).
    • The SmartEiffel approach (ids and switches/tests).


Lecture 1: 2012-04-30, 3 hours: History of Computing, History of Programming Languages (%roland%)

Lecture 2: 2012-05-14, 3 hours: History of Programming Languages, Object Oriented History (%roland%)

Lecture 3: 2012-05-21, 3 hours: Subprograms, Some Traits of Functional Programming Languages (%roland%)

  • Subprograms. See the lecture notes, subprograms.pdf, subprograms-handout.pdf and subprograms-handout-4.pdf.
    • In-depth explanation of the example of the numerical differentiation in Haskell.
  • Some Traits of Functional Programming Languages.
    • Currying, partially applied functions, closures.
    • Pure vs impure languages.
    • Lazy vs strict evaluation, equational reasoning, infinite lists.
      • loop.hs (lazy evaluation, terminates)
      • loop.ml (strict evaluation, does not terminate)
      • loop-lazy.ml (local/partial lazy evaluation, terminates)


1main =
2  let y = 0
3		loop z = if z > 0 then z else loop z
4		f x	 = if y > 8 then x else -y
5  in
6	 f (loop y)


1let y = 0 in
2let rec loop z = if z > 0 then z else loop z in
3let	  f x	 = if y > 8 then x else -y in
4f (loop y)


1let y = 0 in
2let rec loop z = if z > 0 then z else loop z in
3let	  f x	 = if y > 8 then (Lazy.force x) else -y in
4f (lazy (loop y))

Lecture 4: 2012-05-28, 3 hours: Generic Programming, the Standard Template Library (STL) and Template Metaprogramming, Concepts, Mixing OOP and GP (%roland%)

  1. Generic Programming, the Standard Template Library (STL), and Template Metaprogramming. See the lecture notes,

generic.pdf, generic-handout.pdf and generic-handout-4.pdf.

  1. More on GP, concepts and links between GP and OOP.
    • OOP vs OOP
      • OOP: two levels: Interfaces and classes (compile time), instances (run time).
      • GP: three levels: Concepts (documentation/design time), models/types (compile time) and instances (run time).
      • Single algorithm "instantiation"/compilation (OOP) vs several (GP).
        • 1-time compiling/loose coupling between compiled algorithms and data structures (OOP) vs many-time compiling/strong coupling between compiled algorithms and data structures (GP).
        • No or little compile-time optimization (OOP, cost of virtual) vs opportunities for compile-time optimizations (GP).
      • Constraint through interface inheritance (OOP) vs lack of explicit constraint (classic GP) or implicit/explicit concept checking (C++ concept proposal)
    • Some elements of the "Concepts" proposal for C++
      • Intent: make concepts part of the language.
      • Writing concepts with concept.
      • Enforcing concept constraints on templates (require).
      • Mapping models to concepts with concept_map.
      • Adapting models to concepts with concept_map.
      • Setting up implicit links based on structural conformance between models and concepts using auto concept.
    • Mixing OOP and GP
      • The Curiously Recurring Template Pattern (CRTP).
        • Mixing two kinds of relations between a base class (top) and a derived class (bottom), in opposite ways:
          • Inheritance (top-down).
          • Parameter passing (bottom-up).
        • Generalizing the Curiously Recurring Template Pattern to whole hierarchies (static hierarchies).
      • Using abstractions (Abstraction<T>) to constrain algorithms.
        • Static knowledge of the exact type of the argument
        • Static conversion to exact type (instead of dynamic_cast in traditional OOP)
        • Implementing static dispatch based on abstractions.
        • Implementing static multiple dispatch based on sets of abstractions (static multimethods).

-- %roland% - 01 Jun 2012