B629 - Parallel Functional Languages and DSLs
 
Private Course Website :
The course website itself can be found on OnCourse at this location.
 
Short Course Description:
 
This is a seminar course focused on reading papers from the primary
literature.  The subject area is parallelism (1) in functional
programming languages and (2) in domain-specific languages (DSLs) that
leverage functional abstractions.  We will review data-parallel DSLs
that focus on stream processing on parallel container datatypes.
We will also survey the state of parallelism in general-purpose
functional language implementations including Clojure, F#, Scala,
Haskell, and Manticore.  Each student will present at least one paper
during the semester.  In addition to reading papers, we will explore
programming languages and idioms through in-class group programming
sessions.  In lieu of a traditional course project, students will
attempt to add parallelism to an existing project they are working on
-- using a functional style -- and will report on the experience.
 
 
Extended Course Description:
 
If you read about programming languages in tech news or listen to
podcasts on software engineering, you have probably heard the idea
that functional programming is "good for parallelism".  That is,
structuring programs as compositions of pure mathematical functions
increases opportunities for parallelism as well as the safety of
parallel programs.  Indeed, any two expressions in a pure functional
program can be evaluated independently without changing the programs
output.
 
While this idea has been discussed for decades, we have only recently
seen a widespread effort to realize this vision.  It is now possible
to write parallel programs that run on multicores using a variety of
widely available general-purpose functional languages (GPFLs).
Library support is not ideal, but has come a long way, with libraries
such as Scala's parallel collections framework offering pre-packaged
parallelism strategies for many common datatypes.  Shared-memory
parallelism in GPFLs still faces challenges, however, most accutely in
that they require scalable runtime systems and garbage collectors that
can keep up with the high allocation rates of functional programs.  In
this course we will read about the latest attempts to meet these
challenges.
 
We will also study more restricted, domain specific languages built on
functional abstractions (FDSLs).  In fact, libraries for building
pipelines of functional, aggregate operators are becoming the norm in
even in non-functional languages (e.g. FlumeJava, RiverTrail,
CopperHead).  Many of these libraries even enforce a pure-functional
abstraction by making collection types immutable.
 
In this course, students will practice critical reading of research
papers, including their empirical evaluations.  We will evaluate
language designs, and learn about the compilation and runtime
techniques that distinguish the major approaches to functional
parallelism.