CMSC 32001-1: Advanced Type Systems

Course Description: The prerequisite intro course on programming languages (CMSC 32100) has given you some basic vocabulary in the language of type systems. You learned about recursion, polymorphism, static and dynamic semantics, big-step and small-step semantics. You also learned about one of the most basic and ubiquitous tools in modern research on type systems, namely the method of proving type soundness (i.e. type safety) syntactically by progress and preservation. The goal of this advanced course is to further enrich your vocabulary and to expand your arsenal with a new and powerful tool for reasoning about typed programs, namely the method of logical relations.
While many theorems about type systems are provable by straightforward induction, some properties are much trickier to prove and require a clever insight into how to "strengthen the induction hypothesis". The method of logical relations provides such an insight, and it has been applied, generalized, and extended to prove a variety of interesting properties about typed programs. These include termination, strong normalization, decidability of type checking, contextual equivalence of programs, and validity of simple program transformations. We will introduce the idea as it originated--Tait's method for proving termination/strong normalization for the simply-typed lambda calculus--and eventually work our way up to equational reasoning about programs in a language supporting polymorphism, data abstraction, recursive functions, and recursive types. Although the logical relations method is often used in the setting of denotational semantics, we will focus on how to use it to do operational reasoning about typed programs.
When I say "we" will study and "we" will learn about these various topics, I really mean "we": in some cases I will be learning the material along with you! The topics I have chosen for this course are topics that I am knowledgeable about (to varying degrees) but would really like to understand more deeply, and teaching this course seems like a fun and interactive way to do that.

Grading: The grade is based primarily on homework and class participation. Attendance is mandatory, as some of the material we will be discussing is not adequately covered in the accompanying readings. Please let me know if you cannot attend class. The homeworks will be essentially theoretical in nature (e.g. proving theorems). If you have trouble with them, come talk to me. I am open to meeting with students at any time, but you must schedule an appointment. There will be no final exam. In any case, the workload is not intended to be terribly heavy. Since we are covering so much ground, however, you are unlikely to gain much from the course if you do not put in serious time outside of class to study and fully digest the material.

Textbook: The required textbook for the course is Advanced Topics in Types and Programming Languages, edited by Benjamin C. Pierce. This is the sequel to Pierce's Types and Programming Languages textbook, and it consists of ten chapters by different experts on, well, a variety of advanced topics in types and programming languages. We will not follow this book very closely, but for certain topics we will rely on it heavily. Regardless, it is an indispensable resource, and you should own both of the Pierce books if you are an aspiring PL researcher. For other topics, we will read selected research papers and excerpts from longer texts. For these I will provide links to PDF files in the bibliography section at the bottom of this page.

Lecture Notes: Aaron Turon has graciously TeXed up lecture notes for a number of the lectures. They are somewhat lacking in expository text, but are very helpful nonetheless. Thank you, Aaron!

Constantly Changing Syllabus

Bibliography

• Henk Barendregt. Lambda calculi with types. Handbook of Logic in Computer Science, Volume 2, 1992.
• Jean-Yves Girard. Proofs and types. Translated and with appendices by Paul Taylor and Yves Lafont, Cambridge University Press, 1990.
• Robert Harper. Type systems for programming languages. Draft of unpublished manuscript, 2000.
• Robert Harper and John C. Mitchell. Parametricity and variants of Girard's J operator. Information Processing Letters, 1999.
• John C. Reynolds. Types, abstraction and parametric polymorphism. Information Processing 83.
• Philip Wadler. Theorems for free!. In FPCA '89.