- DSL: design embedded domain specific languages
- DSL.Concepts: (abstract) syntax, semantics, ...
- DSL.Implement: implement EDSLs in Haskell (as combinator libraries)

- Types: read, understand and extend Haskell programs which use advanced type system features
- Types.Class: type classes, newtypes, deriving, ...
- Types.GADT: (generalised) algebraic datatypes & type families
- Types.HOT: functors, monads and monad transformers

- Spec: use specification based development techniques
- Spec.Test: formulate and test properties about the program
- Spec.Prove: reason about correctness of functional programs
- Spec.Trans: transform programs on the basis of reasoning

- Expl: explain and discuss the above topics

Notation: Lnn = Lecture #nn, Amm = Assignment #mm.

- L01: laziness
- L01: referential transparency
- L02: deep and shallow embedding
- L02: first DSELs: constructors, run functions etc.
- L03: Simple I/O-library
- L09: abuse of referential transparency
- L09: deep embedding
- L09: shallow embedding
- A01: recognising concepts from the course

- L04: Parsing (as an application of DSLs and Monads)
- L05: Implementing interpreters
- L06: QuickCheck - two DSL's: for properties & for generators
- L10: Software Transactional Memory (STM).
- L10: Threads and MVars
- A01: EDSL for Turtle graphics
- A02: EDSL for CGI scripts

- L01: recap of Haskell
- L02: compositionality and abstraction
- L08: Discussing modelling and implementation
- L10: evaluation strategies - par, pseq, etc.

- L01: type classes
- L05: (multi-parameter) type classes
- L07: design patterns: newtypes, type classes, Show, Read and QuickCheck

- L07: GADTs
- L07: Type families
- L09: use of a GADT
- L09: use of type functions / associated types
- L11: Inductive families of datatypes (similar to GADT's)

- L03: higher-order types
- L03: Monads
- L05: higher order functions
- L05: Monad repetition
- L05: Transformers: StateT, ReaderT, WriterT, ...
- L09: use of Monad transformers

- L03: Monad laws
- L06: Specification
- L06: Testing (QuickCheck - properties & generators)
- L06: Program coverage (the tool hpc)

- L06: Proving properties of functional programs
- L07: programming with strong invariants
- L11: Curry-Howard-isomorphism (program : type) ~= (proof : theorem)
- L11: Agda - a dependently typed language similar to Haskell
- L11: Explicit and implicit (type) arguments

- L04: Stepwise refinement based on laws
- L04: From a simple deep embedding towards an efficient implementation.
- L05: Extending an interpreter step by step
- A01: Extensions to the Turtle language
- A02: Part II: Task 2: Optimising the Replay monad

- L08: Problem solving
- L08: Working through the AFP 2009 exam in groups
- A0*: Working in pairs -> discussion
- A01: Part II, task 5: Thoughts and reflections
- A03: Explain design choices and limitations