Revision as of 14:46, 13 May 2013

This is a collection of material of interest to those teaching or
taking courses that use Haskell. There is also a more general site,
http://www.cs.kun.nl/fple/, devoted to all functional languages. The proceedings of the latest
International Workshop on Functional and Declarative Programming in Education (FDPE) are now available.
Some of the lecture notes and
other course material found in these web pages are excellent
supplements to the available text books.
If you would like to use lecture
notes, assignments, or other material found in these course web pages
please contact the author for permission.

Most of the entries are years old. When you add your own new
material to this page, please also say when the course was run for the last time.

The results of a survey of university courses using Haskell in the academic year 2005-2006 can be found here. Also, some news were added during the 2006-2007 academic year.

These materials arose from a course offered for three consecutive
semesters as
an alternative to our usual first course in programming. Most of the
students
who took the course graduated in the past two years, and many of them
cited it
in the exit interview with the department chair as the most influential
course
in the entire academic career.

All materials for two offerings of the course are available through
the web
page. This includes individual projects, team projects, project
solutions,
exams, supplied software (connected with certain projects), tips for
students
taking the course, FAQs addressing questions that students asked during
the
semester, and a short textbook which served as the primary text in the
course.

The first 10 to 11 weeks of the course use Haskell. Students are
required to
write nine programs in Haskell, three of which are team projects that
combine
software developed in individual projects. Different members of a team
are
assigned different individual projects, and the team efforts combine
their
solutions into a working piece of software.

In the early part of the course, students use operators like map,
foldr, zip,
and iterate to express computations. Explicit recursion is introduced
after some
experience with these common patterns of computation. Examples and
problems
address non-numeric applications, for the most part. Both interactive
and file
I/O are covered, but general purpose monads are not.

The last 5 to 6 weeks of the course use C, and most of the projects
in that
part of the course duplicate the function of earlier pieces of software
that the
students have written in Haskell.

Instructor:Jonathan Hill
Oxford University Computing LaboratoryCourse: Functional Programming for the Integrated Graduate Development Programme in Software Engineering at Oxford University.Student background: Discrete mathematics (the course is a part time MSc for people from industry; most are from IBM or Nortel).Materials: Gofer (an old version, with a stripped down prelude---no parameter classes!); Own course materialWeb page:http://www.comlab.ox.ac.uk/igdp/text/course06.html
Note: Web pages not accessible. May be ... moved ?

(Introductory programming course for CS and math/science majors, typically Freshman and Sophomores. Class size ~60)
Our undergraduate computing environment is now largely
PCs running Windows NT. We use NTEmacs as the programming
environment with a slightly modified version of Emacs hugs
mode with hugs running as a subprocess. The combined
hugs/NTEmacs/Active Haskell distribution (available through
course home page) is installed on 400+ public Win NT machines
on campus and some unknown number of student-owned Win 95/98
machines.
This arrangement is new this semester, but so far has been
working well. Keystroke-oriented interactive applications
may be problematic with hugs running in NTEmacs shell mode.
I'm planning assignments using Fran and Active Haskell and
will try teaching the "brief introduction to imperative
programming" at the end of the class using monads. I would
be interested in talking with anyone who has experience or
suggestions along these lines.
I took a cue from Paul Hudak and others and have occasional
appearances of MS Agents during lectures to wake students up!
This is my first time teaching this course, and I would
enjoy talking to others teaching at a similar level. A
cursory search on the web didn't reveal many courses
in this category.

Our first semester course
uses Haskell as a vehicle to fundamental aspects of computation:
algorithmics, specification and verification, efficiency analysis,
programming methods. This works wonderfully. We do not require previous
or additional programming experience. Haskell is quickly learned,
to the necessary degreee; we make no attempt to cover the full language.
This is NOT a Haskell course! Haskell allows us to speak about concepts
of computer science WITHOUT a lot of language learning. And Haskell
even helps to keep out detrimental habits from previous programming
experience, as well as motivational problems resulting from the widely
differing previous experiences of our incoming students.

The first 75% of the course is basic programming concepts using Haskell. The remainder covers the same concepts in Java. This is reinforced - hopefully - by the third assignment (in Java) being the same as the first assignment (in Haskell). The aim is to provide a managed transition to the course which follows in second semester. Another point of possible interest is the use of a simple graphics library, ANUPlot, built on top of the OpenGL binding. See http://code.google.com/p/anuplot/

Lecture notes comprise over 350 animated slides (all both PowerPoint and
PDF
formats). About two-thirds of the material centers around mathematical logic.
After the introduction of predicates, all of the examples in the logic
portion
of the course involve reasoning about properties of software, most of which is
expressed in Haskell (a few are conventional looping functions).

Software examples include sum, sequence concatenation, logical operations on
sequences, the Russian peasant algorithm, insertion and lookup in AVL
trees, and
other computations. Most of the properties verified relate to aspects of
program
correctness, but resource utilization properties are also verified in
some
cases. Several semesters worth of exams (finals and exams given during
the term)
are provided. The slides have matured through several offerings of the course.

The remaining third of the course discusses other standard topics
in discrete
mathematics, such as sets, functions, relations, trees, and counting.
The web
page provides access to a preview of the material. Exams and solutions are
protected by a login procedure (to increase the comfort level of
instructors
wishing to use them in courses). The web page provides a link through
which
instructors may gain access to the full website.

Instructor:Jose Emilio Labra Gayo,
Dept. of Computer Science (EUITIO) University of OviedoCourse: Logic and Functional ProgrammingStudent background: The course is oriented towards third year undergraduate students in computer science. Usually, the students have been
introduced to imperative languages like Pascal and Object
Oriented Languages like C++Materials: Hugs; R. Bird "Introd. to FP using Haskell" (2nd Ed), J. E. Labra Gayo. "Introduction to the Haskell Language" (in spanish).Web page:http://lsi.uniovi.es/~labra/plf.html (in spanish).

The notes and labs I have on-line are in pretty rough form: many slide
points are just one-line topical stubs I used as reminders in lecture.
Many of the on-line materials are not linked into the (out of date)
home page.
I hope to have the course approved for next Fall as a regular offering
(i.e., not as a "special topic") and should have more extensive
on-line materials up by then.
Teaching "bi-lingually" in Haskell and Scheme seemed like a good idea
at the time, but next time around I will use Haskell as the main vehicle,
perhaps taking some time near the end of the course to highlight some
other languages (Scheme, ML, Clean).
Some of my students used Conal Elliot's Fran and Paul Hudak's Haskore
and liked them a lot; I was nice to have some significantly-sized
applications that seemed more practical and fun to show off at the end
of the course (I should have demonstrated these things at the beginning
of the course to help with motivation). Next time around I would like to
have a "beginner's prelude" or similar available to avoid problems with
classes in type inference, Int vs. Integer, etc. These problems were a
constant annoyance during lectures.

Instructor:Chris Lengauer
University of PassauCourse: Functional ProgrammingStudent background: two years of CS studyMaterials: hugs; Richard Bird's new text (PHI)Web page: not reachable from outside Passau

Instructor:Conrad Cunningham
University of MississippiCourse: Functional ProgrammingStudent background: official -- senior or graduate standing; actual -- introductory programming, data structures, and discrete mathMaterials: Hugs on Unix and MS Windows systems;
Mostly use the instructor's own set of lecture notes. Also Simon Thompson's HASKELL: THE CRAFT OF FUNCTIONAL PROGRAMMING. Previously used the Bird and Wadler textbookWeb page:http://www.cs.olemiss.edu/~hcc/csci555/Comments:

Although I am not a researcher in FP, I enjoy teaching the FP course.
Most of the students take to the course after a few weeks. Hugs works
reasonably well, but, of course, more pedagogically oriented error messages
and other support tools would be helpful.

The course starts with 4 full time days of learning Haskell. During the semester
the students (in groups of 2 students) have to implement a compiler and an
abstract machine for a simple imperative language. They are given parts of the
system and a manual on how to do the remaining parts (they have no prior
knowledge on compiler construction).
The most difficult construct for students to understand is the monad. I
introduce IO without mentioning monads. Later I explain how to build a simple
exception handling system based on the type `Maybe a' / `Error a'. Only
subsequently I give the general definition of monads and present the list monad
and a simple state monad. However, I fear that just to understand the bind
operator `>>=' requires people to be quite comfortable with higher-order
functions.

This is the declarative programming option for 4th year
undergrads, who have Java as a first programming language, and some
knowledge of C and C++. The current final year have had some exposure
to Haskell in first year, though this is no longer the case for our
current intake.

Instructor:Leif Kusoffsky,
Royal Institute of Technology, StockholmCourse: Functional Programming 2D1370Student background: The course is oriented towards third year
undergraduate students in computer science. The students
have been introduced to imperative languages like
C and Object Oriented Languages like Java
Materials: Hugs; Hudak : The Haskell School of Expression

Instructor:David Duke
University of Leeds, School of ComputingCourse: Functional ProgrammingStudent background: Second and third year undergraduate
Materials: ghc; Graham Hutton "Programming in Haskell"
Web page: www.comp.leeds.ac.uk/se23/Comments:

This is an optional course that students currently can take in
second or third year (from 2008/9 it will be third-years only).
Students will have previously used Python and Java.
Although the emphasis is on learning to solve problems within
the functional paradigm, and how to develop solutions within
Haskell, I also like to show students what is "under the
bonnet" and conclude the module with an introduction to
implementation issues, using material derived from
"Implementing Functional Languages" by Simon Peyton Jones and
David Lester.

Haskell is used as an implementation languages in student's laboratories.
The ideea was to provide a language powerfull enough to be able to express
how to build a parser starting from a grammmar. The students are able
to build small (monadic) interpreters for "while-languages" using a
recommanded monad and a recommanded back-end. The labs are focusing on the
grammar of the languages, on the modular (monadic) parsing as a tool for
verifying and processing inputs which are not validable by finite state
automata but by context free grammmars. Adaptability of the language,
especially obtained manipulating and improving syntax is also a target.
Support (concerning Haskell): "O introducere in Haskell prin exemple" by
Dan Popa, published in january 31,2007 by
Edusoft(in romanian) Contact the author if needed .
Other recommanded books: "Gentle Introd to Haskell 98" and YAHT
Recomanded papers: All about monadic parsing.
Special message for Graham Hutton, Erik Meijer and P. Wadler and all
other authors with similar interests from the Haskell
community:

Thank you very much for your papers concerning Monadic parsing and
interpreters !

Course: Programming Paradigms

4 Comparative programming languages

These courses teach general programming language principles, with
Haskell as an example of a functional language.

Instructor: Ruediger Marcus Flaig, University of Heidelberg (Germany)
Course: An introduction to programming in bioinformatics Student background: different, but generally lowMaterials: Hugs-98 and lots of other stuff
Web page:http://www.sanctacaris.net/rc.htmlComments:

This course is designed to introduce life science students,
that is to say, going-to-be biologists, physicians, biotechnologists
and maybe others, to solving real-life problems (such as DNA sequence
handling and analysis). Emphasis will be on paradigms (imperative /
OO, functional, declarative). Although -- in order not to frighten
people -- the official announcement mentions only Python, Haskell will
be presented as THE purely functional language, and all solutions may
be presented in either Python, Haskell or Java. I am very curious
about the feedback I'll get, and maybe next term we shall focus more
on Haskell. What I'd really need, though, is some life science related
package for Haskell, such as BIOPYTHON and BIORUBY.

I'm using Haskell in a programming-languages course, but it's distributed
somewhat piecemeal through the course. Probably adds up to something like
3-4 weeks (out of 15).

Instructor:Mark Utting
University of Waikato (New Zealand)
Course: Programming LanguagesStudent background: Two years of C++ and 1 year of HaskellMaterials: Textbook "Programming Languages", Louden.
Web page:http://www.cs.waikato.ac.nz/~marku/313Comments:

The course covers at least two languages in each of the
main paradigms (object-oriented, functional and logic programming),
plus history, semantics and implementation issues.
The Haskell section is about 2 weeks long and usually focusses on
programming with higher-order functions and how that enables the
language to be extended in application-specific ways
(parser combinators, html-generation combinators etc.)

5 Advanced functional programming using Haskell

These courses deal with the advanced issues such as semantics, type
systems, or compilers. Includes a other advanced courses taught using
Haskell.

Instructor:Graham Hutton
School of Computer Science, University of NottinghamCourse: Advanced Functional ProgrammingStudent background: At least one year of CS, including a course in HaskellMaterials: Hugs; GHC; Graham Hutton, Programming in Haskell; own course materialWeb page:http://www.cs.nott.ac.uk/~gmh/afp.html

The goal is to teach students how to solve substantial problems in a
functional language --- `functional programming in anger', one might say. The
emphasis is on design and use of suitable combinator libraries to simplify
applications. Material covered includes monad design, use of CPS style,
libraries for parsing, pretty-printing, and GUIs (presently fudgets).
The course is taught in a `problem based' manner: lectures are few, while
students solve three substantial programming problems during the term, with
plenty of backup via group meetings. I adopted this teaching form three years
ago, and it has led students to develop far better practical skills than most
obtained from my earlier `lectures and exercises' courses, and I believe to
use Haskell much more after the course's end.
This course is optional in the third or fourth year, and is taken by a
small-to-medium sized group of students.

Instructor:Lyndon While
The University of Western AustraliaCourse: Functional ProgrammingStudent background: OOP, plus most of them have used Haskell previouslyMaterials: hugs 98; none of the recent books really fitWeb page:http://undergraduate.cs.uwa.edu.au/courses/230.301Instructor:Fethi Rabhi,
University of Hull (UK)Course: AI Problem Solving Techniques (using Haskell and Prolog)Student background: Haskell and Prolog programmingMaterials: HUGS; Thompson'96, own notes (soon to be published as a book).Web page: noneComments:

It is very hard to justify learning Haskell unless it can be
demonstrated in very practical situations (hence the provision
of the above course).

Instructor:Jerzy Karczmarczuk
University of Caen, Caen (France) No links in the fr-Haskell page. Why not ?
Course: CompilationStudent background: General CS knowledge; students (should...) know Scheme and imperative languages, also some theory of languages and automata.Materials:
Hugs, GHC, now also GHCi, and their documentation. Handouts: (still a little incomplete)
Impossible to find the foolowing matterials.Files can not be found.

This is a compulsory semestrial course in fourth year. Weekly: 1.5h
course, 2.5H practice.
One, but comprehensive assignment, taking 2 months or more.
askell is our main coding tool. A little time is devoted by necessity
to the language
itself, but also from the perspective: "how would you compile such a
language".
"Standard stuff", such as parsing combinators, etc.is covered, but we
don't begin with that.
We start with the construction of small interpreters: from recursive
Lisp-style to postfix,
(Forth/PostScript style) constructing this last by partial evaluation
(intuitively).
We introduce control structures as lazy functions, operation
sequencing through continuations,
monads not only for parsing, but also for exceptions and
non-determinism.
We discuss (simply) the type inference. The code generator assembles a
linear code by lazy
concatenation of chunks which makes it trivial to deal with loops and
cross-referencing
fragments. Algorithms of garbage collection are presented (not
implemented, though...) in
a purely functional style.
Students' opinion: "Frightening at first. Learning curve steep, but
much less time spent on debugging, coding proficiency comes fast. Good for
understanding what the compilation is about, but difficult to make a
complete running program with all the I/O, etc.

This is a course in the low level programming of microprocessor systems.
The course will focus on the development of an emulator (virtual
machine, or VM) for a small computer system based on a modern RISC
microprocessor (the ARM CPU) using a high level programming language
(Haskell), and assembly language programming of the VM. Development of
the VM will occur in stages, starting with the simple direct-execution
(stream-based) model, gradually moving to a more realistic memory-mapped
model, including exception handlers, concurrent processes, and
asynchronous external devices.

Instructor: Gabriele Keller
The University of New South WalesCourse: Concepts of Programming LanguagesStudent background: Most of them have used Haskell in first yearMaterials: GHC, TaPL and `Programming Languages: Theory and Practice', papersWeb page:http://www.cse.unsw.edu.au/~cs3161Last run: 2006Comments:

Expose students to a theory of programming languages based on type
theory and operational semantics as a mathematically sound framework
which allows us to investigate the properties of a large number of
programming language features, including:

on semantics of different programming languages and programming paradigms: imperative, object oriented, and declarative.

Assignments are in GHC/Haskell, and in the past have included implementing a
mini-Haskell type checker, type inference and interpreter.

Instructor: Manuel Chakravarty
The University of New South WalesCourse: Advanced Functional ProgrammingStudent background: Most of them have used Haskell in first yearMaterials: GHC, papers (see the website)Web page:http://www.cse.unsw.edu.au/~cs4132Last run:2004Comments:

To provide students with an understanding of the theory and practice of
the design, use, and implementation of functional programming languages,
such as Haskell
This includes selected topics from the following areas: