In this lecture we do a quick recap of Haskell and talk about things like referential transparency, laziness, and type classes. We also look at a first simple example of a domain specific embedded language.
In this lecture we develop a domain specific embedded language for describing shapes. We talk about the distinction between a deep and a shallow embedding, about compositionality and abstraction.
This lecture introduces monads by looking at how to design a simple library for input/output.
In this lecture we look at another application of monads, namely parsing. We also see how to refine the implementation of a library. Starting from a naive translation from syntax to semantics, we derive intermediate representations for an efficient implementation.
We learn how to build complicated monads from simple building blocks.
We look at the different stackings of the monad transformers in the Interpreter4 example (from last lecture). And we start looking at program verification: proving, specifying and testing correctness of programs.
In this lecture we continue the work on QuickCheck, mainly looking at how to generate test data. We also check out how the program coverage tool hpc can be used to see what parts of a program has been tested.
We look at two recent extensions to Haskell: Type families and GADTs.
Digital signal processing (DSP) appears in a wide range of applications, ranging from biomedicine and audio processing to radio base stations. In many of those applications, speed is a major concern, which means that a great deal of signal processing code is written in very low-level machine-oriented languages. Such low-level code is hard to develop and maintain, and it is also difficult to move between different hardware platforms. We are developing a domain-specific language for DSP that aims to allow signal processing code to be developed at a higher level of abstraction. The language, Feldspar, is embedded in Haskell, and it offers a high-level programming interface similar to ordinary list processing in Haskell. In this lecture, I will mostly focus on Feldspar's implementation, which uses an interesting combination of a deep and shallow embedding. I will also show some basic examples.
In this lecture we look at concurrent and parallel programming in Haskell. Topics include: Haskell "sparks", threads and Software Transactional Memory (STM).
In dependently typed languages such as Agda one can both write programs and prove propositions which refer to the programs. I will introduce Agda by implementing a very simple theorem prover, and formally prove that it is sound.
In this lecture we look back at the learning outcomes and how they relate to the different parts of the course and what parts of the RWH book are covered. Some other relevant topics did not fit but I include references and code below.