
Frank Pfenning
Courses

15210 Parallel and Sequential Data Structures and Algorithms

15210 aims to teach methods for designing, analyzing, and
programming sequential and parallel algorithms and data
structures. The emphasis is on teaching fundamental concepts
applicable across a wide variety of problem domains, and
transferable across a reasonably broad set of programming languages
and computer architectures. This course also includes a significant
programming component in which students will program concrete
examples from domains such as engineering, scientific computing,
graphics, data mining, and information retrieval (web search).
Unlike a traditional introduction to algorithms and data structures,
this course puts an emphasis on parallel thinking, i.e., thinking
about how algorithms can do multiple things at once instead of one at a
time. The course follows up on material learned in 15122 and 15150 but
goes into significantly more depth on algorithmic issues.

15414/614 Bug Catching: Automated Program Verification

Highprofile bugs continue to plague the software industry,
leading to major problems in the reliability, safety, and security
of systems. This course teaches students how to write bugfree
code through the process of software verification, which aims to
prove the correctness of a program with respect to a mathematical
specification. Along the way, students will learn how to: specify
correct program behavior; prove the correctness of their code; use
formal semantics to reason about the soundness of proof rules;
write practical and efficient verified code; use decision
procedures and model checkers to reduce verification
effort. Students will learn the principles and algorithms behind
automated verification tools, and understand their practical
limitations while gaining experience writing verified,
machinechecked code that solves real problems.

15122 Principles of Imperative Computation

For students with a basic understanding of programming (variables,
expressions, loops, arrays, functions). Teaches imperative
programming and methods for ensuring the correctness of programs.
Students will learn the process and concepts needed to go from
highlevel descriptions of algorithms to correct imperative
implementations, with specific application to basic data structures
and algorithms. Much of the course will be conducted in a subset of C
amenable to verification, with a transition to full C near the end.
This course prepares students for 15213 and 15210.

15150 Functional Programming

The purpose of this course is to introduce the theory and practice
of functional programming (FP). The characteristic feature of FP
is the emphasis on computation as evaluation. The traditional
distinction between program and data characteristic of imperative
programming (IP) is replaced by an emphasis on classifying
expressions by types that specify their applicative
behavior. Types include familiar (fixed and arbitrary precision)
numeric types, tuples and records (structs), classified values
(objects), inductive types such as trees, functions with specified
inputs and outputs, and commands such as input and
output. Welltyped expressions are evaluated to produce values, in
a manner that is guaranteed to be typesafe. Because functional
programs do not cause sideeffects we can take advantage of simple
mathematical principles in reasoning about applicative behavior
and analyzing the runtime properties of programs.

15213 Introduction to Computer Systems

This course provides a programmer's view of how computer systems
execute programs, store information, and communicate. It enables
students to become more effective programmers, especially in dealing
with issues of performance, portability and robustness. It also serves
as a foundation for courses on compilers, networks, operating systems,
and computer architecture, where a deeper understanding of systemslevel
issues is required. Topics covered include: machinelevel code and its
generation by optimizing compilers, performance evaluation and
optimization, computer arithmetic, memory organization and management,
networking technology and protocols, and supporting concurrent
computation.

15312 Foundations of Programming Languages

This course discusses in depth many of the concepts underlying the
design, definition, implementation and use of modern programming
languages. Formal approaches to defining the syntax and semantics are
used to describe the fundamental concepts underlying programming
languages. A variety of programming paradigms are covered such as
imperative, functional, logic, and concurrent programming. In addition
to the formal studies, experience with programming in the languages is
used to illustrate how different design goals can lead to radically
different languages and models of computation.
Prerequisites: 15212 Principles of Programming.

15317 Constructive Logic

A juniorlevel introduction to constructive logic and its applications
in computer science. The course will cover the philosophical origins,
the mathematical properties, and numerous applications of constructive
logic. The topics include intuitionistic logic, functional
programming, type theory, logic programming, intuitionistic linear logic, and
constructive modal logic. Previously crosslisted as 80317/617 in
the Department of Philosophy and number 15399 in Computer Science.

15411/611 Compiler Design

This course covers the design and implementation of compiler
and runtime systems for highlevel languages, and examines the
interaction between language design, compiler design, and runtime
organization. Topics covered include lexical and syntactic analysis,
handling of userdefined types and typechecking, context analysis,
code generation and optimization, and memory management and runtime
organization.

15453 Formal Languages, Automata and Computation

A seniorlevel introduction to formal languages, automata, computability,
and complexity.

15462 Computer Graphics

This course provides a basic introduction to Computer Graphics. Some
undergraduate followup courses such as and Computer Animation are
offered on a regular basis.
Prerequisites: 15213 Introduction to Computer
Systems, 21241 Matrix Algebra, 21259 Calculus in Three Dimensions, or
equivalents.

15814 Types and Programming Languages

This graduate course provides an introduction to programming
languages viewed through the lens of their type structure. Core
topics include: Static and dynamic semantics; preservation and
progress; hypothetical judgments and substitution; propositions as
types, natural deduction, sequent calculus; the untyped
lambdacalculus; functions, eager and lazy products, sums,
recursive types; parametric polymorphism, data abstraction,
existential types K machine, S machine, substructural operational
semantics sharedmemory concurrency, session types

15815 Automated Theorem Proving

This course provides a thorough, handson introduction to automated
theorem proving. It consists of a traditional lecture component and a
joint project in which we will construct a theorem prover. The lecture
component introduces the basic concepts and techniques of logic followed
by successive refinement towards more efficient implementations. The
basic theorem proving paradigms we plan to cover are tableaux and the
inverse method, both of which are applicable to classical and
nonclassical logics. In addition we will cover equational
reasoning and cooperating decision procedures.
Prerequisites: For undergraduates an undergraduate
logic course or 15312. No prerequisites for graduate students.

15836 Substructural Logics (previously: 15816)

This graduate course provides an introduction to substructural logics with an
emphasis on its applications in computer science. This includes the
theory of functional, logic, and concurrent programming languages.
It is an evaluation of the course on Linear Logic.
Prerequisite:
General familiarity with functional programming and logic.

15816 Linear Logic

This graduate course provides an introduction to linear logic with an
emphasis on its applications in computer science. This includes the
theory of functional, logic and imperative programming languages. We
will also develop a linear type theory which will serve as a
metalanguage in which the theory of programming languages with state
can be formalized effectively. An implementation of the type theory may
be available for practical experiments later in the semester.
Prerequisite:
General familiarity with functional programming and logic.

15816 Modal Logic

Modal logic is the study of the laws of inference for judgments
such as "it is necessary that", "it is possible that", "K knows that",
"K affirms that", etc. Its roots lie in philosophy and linguistics,
but it has a suprisingly rich variety of applications in computer
science. This course provides a thorough introduction to both
classical and intuitionistic modal logic, with an emphasis on
applications in computer science. This class will study the proof
theory and meta theory of modal logics, and present the foundations
for practical proof procedures.

15819 Logic Programming

Logic programming is a paradigm where computation arises from proof
search in a logic according to a fixed, predictable strategy. It
thereby unifies logical specification and implementation in a way that
is quite different from functional or imperative programming. This
course provides a thorough, modern introduction to logic programming.
It consists of a traditional lecture component and a project component.
The lecture component introduces the basic concepts and techniques of logic
programming followed by successive refinement towards more efficient
implementations or extensions to richer logical concepts. We plan
to cover a variety of logics and operational interpretations. The
project component will be one or several projects related to logic
programming.

15851 Computation and Deduction

This introductory graduate course explores the theory of programming
languages using deductive systems. Throughout the course we use the
Twelf system to specify languages,
implement algorithms, and prove metatheorems. A textbook to be published
by Cambridge University Press is in preparation.

15212 Fundamental Structures of Computer Science II

A sophomorelevel introduction to advanced programming techniques
using Standard ML. This course eventually evolved into 15150.

15810 Advanced Topics Theory: Proofs and Programs

A graduate level introduction to constructive logic, proofs, and programs.
 Spring 1993, cotaught with Wilfried Sieg and Stanley Wainer,
Department of Philosophy
 Spring 1988

21127 Introduction to Modern Mathematics

Undergraduate (freshman level) introduction to discrete mathematics using the Mathematica
symbolic computation system.
 Fall 1995, teaching assistant to Michael Albert, Department of Mathematics.

15810 Advanced Topics Theory: Typed LambdaCalculus

Graduate introduction to typed lambdacalculi and their relation to
programming languages.
 Spring 1990, cotaught with Robert Harper

15810 Advanced Topics Theory: Programming Languages and Type Theory

Graduate introduction to functional programming and type theory.

15810 Advanced Topics Theory: Inferential Programming

Graduate seminar on formal program development and program transformation.
 Fall 1986, cotaught with Eugene Rollins

Theory of Computation

Undergraduate (senior level) course on automata, formal languages, and computation.
 Spring 1982, cotaught with Dale Miller.
[ Home
 Contact
 Research
 Publications
 CV
 Students
]
[ Projects
 Courses
 Conferences
 Organizations
 Journals
]
Frank Pfenning
