AFP 2011: Annotated learning outcomes

• 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

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
• A01: EDSL for Turtle graphics
• A02: EDSL for CGI scripts

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

• L01: recap of Haskell
• L02: compositionality and abstraction
• L08: Discussing modelling and implementation

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

• L11': Working through the AFP 2010 exam in groups
• A0*: Working in pairs -> discussion
• A01: Part II, task 5: Thoughts and reflections
• A03: Explain design choices and limitations