Schedule of Classes

We outline the course, its goals, and talk about various administrative issues.

We present a general method to prove properties of derivable judgments. We also look at derivations lacking a justification for some of judgments and reify it as the new form of hypothetical judgments. We examine some elementary properties of these judgments. Finally, we define transition systems as a special form of judgment.

We give a judgmental representation of strings, that allow expressing the concrete syntax of a language and show that the productions in a context-free grammar are nothing but rules in disguise. Derivations are then a representation of the intrinsic structure of a sentence and, once streamlined, yield abstract syntax trees, an efficient notation for syntactic expressions.

Binding constructs are pervasive in programming (and other) languages. Because of this, it is convenient to define an infrastructure that allows to efficiently work with them. Abstract binding trees do precisely that at the level of syntax, and are just abstract syntax trees when no binders are present. General judgments are a similar abstraction at the judgment level. We identify α-conversion and substitution as fundamental operations associated with binders. Deductive systems that embed both hypothetical and general judgments form an eminently flexible representation tool for a large class of languages.

We define a simple spreadsheet-like language but, unlike spreadsheets, introduce types to classify atomic objects. Typing rules are introduced next to classify expressions: they define its static semantics. Execution rules describe how to evaluate expressions and constitute its dynamic semantics. We show several approaches to defining the dynamic semantics of a language, and compare them.

How do we know that that rules we have defined make sense? We prove it mathematically. The key results are type preservation (types provide a track from which execution can never gets off) and progress (execution always knows what to do next). We trace back the very possibility of proving these theorems to the interaction between two types of rules, introduction and elimination forms, from which we extract a general design principle. We conduct these proofs in the transition semantics and discuss issues with the evaluation semantics. We conclude by examining dynamic errors.

We define a new language with just (non-recursive) functions and observe how the static and dynamic semantics play out. This involves the introduction of closures to handle scoping issues in an environment-based evaluation semantics.

Obtaining an interesting language with functions and numbers requires including some form of recursion. We show two approaches: the first, primitive recursion, includes a recursor that allows to define all and only the functions that can be obtained through a predetermined number of iterations (for-loops) which yields necessarily total functions; the second, general recursion, supports dynamically bounded iterations (while-loops) and allows possibly partial functions.

We now examine language that support fixed-length tupling constructs. We begin with 2-tuple (pairs) and 0-tuple (unit), extend it to generic tuples, and then define records as labeled tuples and objects as self-referential records. We then consider safe languages constructs that allow the same data structure to represent objects of possibly different types (variants). The underlying mathematical concept is that of sum. As for products, we consider, binary, nullary, n-ary and labeled sums. As concrete examples, we define the type of Booleans and options.

Natural numbers, lists, string have something in common: they all specify infinite objects, and each is built in the same regular way. This suggests that there is a common underlying principle that they share. This is the recursive type construction, which allows to define a type based on itself. Once this principle is exposed, we have a mechanism to define our favorite recursive types: not just the above, but also trees, objects, recursive functions, etc. In this lecture, we examine how recursive types work and how the machinery they rely upon is hidden in practical programming languages.

All the languages we have seen so far are typed, and there are good reasons for this. We look at two untyped languages and show how things can get nasty quickly without types. The first one is actually not too bad: the simply typed λ-calculus has just functions, is Turing-complete, but is not fun to program in. The second is an untyped version of Plotkin's PCF: we now need to check at run time that operations make sense. This essentially builds typechecking into the execution semantics, with loss in performance because we need to check that expressions are valid all the time - in particular each time we recurse.

We show how the untyped PCF can be compiled into the typed PCF extended with errors and a type representing untyped expressions. This exercise exposes the actual tagging and checking that goes on in an untyped implementation and makes sources of inefficency evident. This embedding in a typed framework also provides an opportunity to use the type system to carry out simple but effective optimizations aimed at mitigating the overhead of tag creation and checking. In many cases, this can push out tagging and checking at the functions or module boundaries. We then show that the type of untyped expressions can be simulated directly within PCF.

We now look at polymorphism, which allows writing universal functions that work on arguments of any type. We see that polymorphism, although it has a straightforward definition in terms of universal types, yields surprising expressive power. Finally, we examine restricted forms of polymorphism that simplifies typechecking.

Powerful module languages can hide the implementation of a function, yet providing it through a publicized interface. We trace this mechanism down to existential types, which are in a sense dual to the universal types that underly polymorphism.

We revisit the semantics of a language and bring it closer to actual implementations. In particular, we model the pending operations in a program by pushing them onto a stack and retrieving them when their operands have been reduced to values. This stack semantics is particularly useful when we extend our language with constructs that alter the normal control flow of a language.

A prime example of using a stack machine is the intoduction of exceptions, which, when raised, have the effect of unwinding the stack until the next handler is reached. The same mechanism provides a simple way to handle run-time errors.

Having made the control stack explicit in the description of the semantics of a language, it is a small step to reify it into a construct of this language. This is this very primitive that languages supporting continuations provide. We describe the formal basis of continuations and show how they are used both to carry out a computation and to recover from failure.

One of the most surprising and far reaching observations in the theory of programming languages is that nearly all forms of types work in the same way as logical operators. This is known as the Curry-Howard isomorphism. With types interpreted as formulas, expressions get interpreted as proofs. This opens the doors to endless possibilities: proofs (at least in some logics) have computational content and can be executed; programs can be generated automatically as proofs of formulas corresponding to appropriately constrained types; our knowledge of logic can inform our understanding of programming languages, and vice versa; new logics are worth exploring in the same way as new programming constructs are.

It is intuitively appealing to see some types as special cases of other types, for example an integer as a real number or a 3-D point as a 2-D point with extra information. This is called subtyping: the ability of providing a value of the subtype whenever a value of the supertype is expected, and the formal mechanism that governs it is the rule of subsumption. As a side-effect, expressions do not have any more a unique type.

A subtyping relation at the level of the arguments of a type constructor propagates to a subtyping relation at the level of the type constructor itself. The way the resulting relation goes depends on the specific constructor and on the specific argument. This is called variance: covariance if the subtyping relation at the constructor level goes in the same direction as the argument, contravariance if it flow in the opposite direction.

So far, repeated evaluations of the same expression always produce the same value: expressions are self-contained and the result depends only on the text of the expression. A common departure from this model is found in languages featuring a memory and operations to access and manipulate it. The basic building block is the reference cell, which significantly alters the model examined so far, to the point of allowing simulating recursion.

The standard treatment of storage effects, discussed in the last lecture, is driven by the evaluation semantics, in the sense that it is impossible to know whether an expression will be effectful by looking at its type alone. Another approach is to mark the possibility of an effect in the type of expressions. This is achieved using a typing device called a monad.

An eager semantics evaluates an argument exactly one (even if it is never used). A lazy semantics partially evaluates it each time it is encountered. In each case, there is the risk of doing more work than strictly necessary. Call-by-need optimizes this process by evaluating an argument the first time it is encountered but remembering the obtained value for future uses.

The mechanism supporting extreme laziness in a call-by-need semantics is readily adapted to enable extreme eagerness in a setting supporting parallel executions: rather than waiting until the value of an argument is needed, the idea is to evaluate it speculatively, in parallel with other such evaluations, so that it is there the first time it is needed.

In practice, the number of parallel evaluations is limited by the number of available processing units. The expected execution time depends on the underlying architecture, but can be estimated accurately using Brent's Theorem in common instances.

Expressions so far have been self-contained: they were evaluated from an initial state to a final value without interaction with the external world. The possibility of interaction gives rise to the notion of a process, with synchronization actions causing run-time events. A natural next step consists in considering the interactions among several processes (one of them possibly modeling the external world), hence capturing distributed system.