CS2013-final-report

esults from programming language theory. To take another example, modern languages such as ML (and proposed
extensions of Java) include what are known as parameterized types to support flexible code re-use. Parameterized
types complicate compilers considerably because they must account for situations in which the type of a variable or
function argument is not known at compile time. The most effective methods for handling parameterized types rely
on typed intermediate languages with quite sophisticated type systems. Here again programming language theory
provides the foundation for building such compilers.
Programming language theory has many applications to programming practice. For example, “little languages” arise
frequently in software systems -- command languages, scripting languages, configuration files, mark-up languages,
and so on. All too often the basic principles of programming languages are neglected in their design, with all too
familiar results. After all, the argument goes, these are “just” scripting languages, or “just” mark-up languages, why
bother too much about them One reason is that what starts out as “just” an ad hoc little language often grows into
much more than that, to the point that it is, or ought to be, a fully-fledged language in its own right. Programming
language theory can serve as a guide to the design and implementation of special purpose, as well as general
purpose, languages.
Another application of the theory of programming languages is to provide a rigorous foundation for software
engineering. Formal methods for software engineering are grounded in the theory of specification and verification.
A specification is a logical formula describing the intended behavior of a program. There are all kinds of
specifications, ranging from simple typing conditions (“the result is a floating point number between 0 and 1”) to
complex invariants governing shared variables in a concurrent program. Verification is the process of checking that
the implementation indeed satisfies the specification. Much work has gone into the development of tools for
specifying and verifying programs. Programming language theory makes precise the connection between the code
and its specification, and provides the basis for constructing tools for program analysis.
The theory of programming languages provides a “reality check” on programming methodology, that part of
software engineering concerned with the codification of successful approaches to software development. For
example, the merits of object-oriented programming for software development are well known and widely touted.
Object-oriented methodology relies heavily on the notions of subtyping and inheritance. In many accounts these two
notions are confused, or even conflated into one concept, apparently because both are concerned with the idea of one
class being an enrichment of another. But careful analysis reveals that the two concepts are, and must be, distinct:
confusing them leads to programs that violate abstraction boundaries or even incur run-time faults.
The purpose of this course is to introduce the basic principles, methods, and results of programming languages to
undergraduate students who have completed the introductory sequence in computer science at Carnegie Mellon. I
intend for students to develop an appreciation for the benefits (and limitations) of the rigorous analysis of
programming concepts.
The development is based on type theory, a general theory of computation that encompasses all aspects of
programming languages, from the data with which we compute to the means by which we structure programs.
Programming language “features” are viewed as manifestations of type structure. Basic data structures such as
tuples arise as product types, trees and graphs arise as recursive types, and procedures arise as monadic function
types. Each language concept is defined by giving its statics, which specify how it interacts with other parts of a
program, and its dynamics, which specifies how it is executed on a computer. Type safety is the coherence of the
statics with the dynamics; safety is proved as a mathematical theorem governing each language feature. The
specific topics vary from one semester to the next, but the course typically covers finite and infinite data structures,
higher-order functions, continuations, mutable storage, data abstraction and polymorphism, so-called dynamic
typing, parallel computation, laziness, and concurrency, all presented in a single unifying framework.
What is the format of the course
Two 80 minute lectures per week, one 60 minute recitation, plus office hours with either the teaching assistants or
the professor or both.
- 381 -