AFP 2011: Annotated learning outcomes

Relating course parts to learning outcomes

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

DSL: design embedded domain specific languages

DSL.Concepts: (abstract) syntax, semantics, ...

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

DSL.Implement: implement EDSLs in Haskell (as combinator libraries)

  • 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

Types: read, understand and extend Haskell programs which use advanced type system features

Types.Class: type classes, newtypes, deriving, ...

  • 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

Types.GADT: (generalised) algebraic datatypes & type families

  • L07: GADTs
  • L07: Type families
  • L09: use of GADTs
  • L09: use of type families
  • L11: Inductive families of datatypes (similar to GADT's)

Types.HOT: functors, monads and monad transformers

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

Spec: use specification based development techniques

Spec.Test: formulate and test properties about the program

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

Spec.Prove: reason about correctness of functional programs

  • 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: Proving correctness of a simple theorem prover

Spec.Trans: transform programs on the basis of reasoning

  • 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

Expl: explain and discuss the above topics