Frank Pfenning


15-210 Parallel and Sequential Data Structures and Algorithms
15-210 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 15-122 and 15-150 but goes into significantly more depth on algorithmic issues.
15-414/614 Bug Catching: Automated Program Verification
High-profile 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 bug-free 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, machine-checked code that solves real problems.

Undergraduate Courses

15-122 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 high-level 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 15-213 and 15-210.
15-150 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. Well-typed expressions are evaluated to produce values, in a manner that is guaranteed to be type-safe. Because functional programs do not cause side-effects we can take advantage of simple mathematical principles in reasoning about applicative behavior and analyzing the runtime properties of programs.
15-213 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 systems-level issues is required. Topics covered include: machine-level 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.
15-312 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: 15-212 Principles of Programming.
15-317 Constructive Logic
A junior-level 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 cross-listed as 80-317/617 in the Department of Philosophy and number 15-399 in Computer Science.
15-411/611 Compiler Design
This course covers the design and implementation of compiler and runtime systems for high-level languages, and examines the interaction between language design, compiler design, and runtime organization. Topics covered include lexical and syntactic analysis, handling of user-defined types and type-checking, context analysis, code generation and optimization, and memory management and runtime organization.
15-453 Formal Languages, Automata and Computation
A senior-level introduction to formal languages, automata, computability, and complexity.
15-462 Computer Graphics
This course provides a basic introduction to Computer Graphics. Some undergraduate follow-up courses such as and Computer Animation are offered on a regular basis.
Prerequisites: 15-213 Introduction to Computer Systems, 21-241 Matrix Algebra, 21-259 Calculus in Three Dimensions, or equivalents.

Graduate Courses

15-814 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 lambda-calculus; functions, eager and lazy products, sums, recursive types; parametric polymorphism, data abstraction, existential types K machine, S machine, substructural operational semantics shared-memory concurrency, session types
15-815 Automated Theorem Proving
This course provides a thorough, hands-on 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 non-classical logics. In addition we will cover equational reasoning and cooperating decision procedures.
Prerequisites: For undergraduates an undergraduate logic course or 15-312. No prerequisites for graduate students.
15-836 Substructural Logics (previously: 15-816)
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.
15-816 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 meta-language 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.
15-816 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.
15-819 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.
15-851 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 meta-theorems. A textbook to be published by Cambridge University Press is in preparation.

Distant Past

15-212 Fundamental Structures of Computer Science II
A sophomore-level introduction to advanced programming techniques using Standard ML. This course eventually evolved into 15-150.
15-810 Advanced Topics Theory: Proofs and Programs
A graduate level introduction to constructive logic, proofs, and programs.
  • Spring 1993, co-taught with Wilfried Sieg and Stanley Wainer, Department of Philosophy
  • Spring 1988
21-127 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.
15-810 Advanced Topics Theory: Typed Lambda-Calculus
Graduate introduction to typed lambda-calculi and their relation to programming languages.
  • Spring 1990, co-taught with Robert Harper
15-810 Advanced Topics Theory: Programming Languages and Type Theory
Graduate introduction to functional programming and type theory.
  • Spring 1989
15-810 Advanced Topics Theory: Inferential Programming
Graduate seminar on formal program development and program transformation.
  • Fall 1986, co-taught with Eugene Rollins
Theory of Computation
Undergraduate (senior level) course on automata, formal languages, and computation.
  • Spring 1982, co-taught with Dale Miller.

[ Home | Contact | Research | Publications | CV | Students ]
[ Projects | Courses | Conferences | Organizations | Journals ]

Frank Pfenning