- 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, referential transparency
- L02: deep and shallow embedding
- L02: first DSELs: constructors, run functions etc.
- L03: Simple I/O-library
- L09: deep & shallow embedding
- L12: deep embedding
- L13: narrowing
- 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
- A01: EDSL for Turtle graphics
- A02: EDSL for CGI scripts

- L01: recap of Haskell
- L02: compositionality and abstraction
- L07: Discussing modelling and implementation
- A03: explore a Hackage library and report on the results

- L01: type classes
- L05: (multi-parameter) type classes
- L07: design patterns: newtypes, type classes, Show, Read and QuickCheck
- L09: heavy use of type classes and deriving
- L13: Lazy SmallCheck implementation

- L07: GADTs and Type families
- L09: use of GADTs and type families
- L11: Datatypes and families (similar to GADT's)
- L12: Inductive families of datatypes (similar to GADT's)

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

- L03: Monad laws
- L06: Specification
- L06: Testing (QuickCheck - properties & generators)
- L10: Program coverage (the tool hpc)
- L10: Writing QuickCheck generators for a larger program (Compiler example)
- L13: Lazy SmallCheck

- L06: Proving properties of functional programs
- L07: programming with strong invariants
- L11: Curry-Howard-correspondance (program : type) ~= (proof : theorem)
- L11: Agda - a dependently typed language similar to Haskell
- L12: Proving correctness of a simple theorem prover

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

- L*: Several lectures contained interactive sessions
- L06: Explicit focus on group solving of exam questions
- A0*: Working in pairs -> discussion
- A01: Part II, task 5: Thoughts and reflections
- A03: Write about the library you chose.