CS2013-final-report

15-150: Functional Programming, Carnegie Mellon University
Pittsburgh, PA, USA
Daniel R. Licata and Robert Harper
{drl,rwh}@cs.cmu.edu
http://www.cs.cmu.edu/~15150/previous-semesters/2012-spring/
Knowledge Areas that contain topics and learning outcomes covered in the course
Knowledge Area
Total Hours of Coverage
Programming Languages (PL) 18
Parallel and Distributed Computing (PD) 9
Algorithms and Complexity (AL) 8
Software Development Fundamentals (SDF) 7
Discrete Structures (DS) 5
Software Engineering (SE) 1
Where does the course fit in your curriculum
Functional Programming is a required course, and is typically taken in a student’s first, second, or third semester.
Carnegie Mellon’s required introductory CS courses consist of this course on functional programming, a course on
imperative programming, a course on discrete math, a course on parallel data structures and algorithms, and a course
on computer systems. The only prerequisite for Functional Programming is a basic math course, though students
usually have some prior programming experience. Functional Programming is a prerequisite for the parallel data
structures and algorithms course. The course typically has an enrollment of 200-250 students per semester.
Approximately 1/3 to 1/2 of the students are CS majors, though most of the remaining students are intending to
minor or switch to a CS major.
What is covered in the course
The four key skills that students learn are
• to write parallel functional programs
• to analyze programs’ sequential and parallel time complexity
• to write mathematical specifications and verify that programs meet them
• to structure programs using modules and abstract types
One central principle of the course design is that the skills of writing, analyzing, and verifying parallel programs are
integrated throughout the semester, rather than separated into units. In the first three weeks of the course, students
learn to write basic sequential functional programs on numbers and lists, to analyze their time complexity, and to
prove mathematical correctness specifications using induction. Parallelism is introduced in the fourth week:
Students learn to write data-parallel functional programs. They learn to analyze not just the usual sequential
complexity of programs, but their parallel complexity, and how this influences algorithm and data structure design.
An early example is sorting: One might think that mergesort would have logarithmic parallel complexity, because as
a sorting problem is repeatedly divided in half, the length of the longest dependency is logarithmic. However, with
lists as the data structure, mergesort has a linear parallel complexity, because just the operation of splitting a list into
two halves takes linear time, independently of how many processors are available. This motivates studying
mergesort on trees, which has a sublinear parallel complexity. Because the parallelism is deterministic, students can
reason about the behavior of their programs as if they were sequential, but run them in parallel. These
programming, analysis, and verification skills continue to be interwoven throughout the remainder of the course, as
students learn more advanced techniques.
- 384 -