Schedule of Classes

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

We introduce some fundamental mechanisms to study programming languages: judgments describe potential facts in the domain of discourse, rules allow deriving new judgments from judgments that are known to hold, and derivations are full justification of judgments.

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.

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.

We examine a language that offers the notion of pattern as a (mostly) generic replacement for destructors associated with individual constructs. In order to achieve a usable progress theorem, patterns shall be exhaustive. It is also useful to flag out redundant patterns, which often hide a programming error.

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.

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.

Up to this point, the distinction between an eager and a lazy construct has been a matter of how the evaluation rules were chosen to be define. Another approach is to lift this distinction to the level of types, so that the programmer can choose the interpretation based on the type of the particular construct he/she decides to use. Yet another approach is to design a type for lazy objects, which can be used within any constructor. This latter approach is called a suspension.

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.

Effect-free programming languages provide plenty of opportunities for the parallel evaluation of subcomputations. Specifically, unless an evaluation depends on the result of another, they can be executed in parallel. Dependencies and theorical execution time can be measured by equipping the evaluation semantics with an abstract notion of cost, which is then used to calculate useful figures such as the number of steps in a purely sequential setup (work) and the time in a maximally parallel environment (depth).

Allowing actions to send or receive data promotes synchronization to a communication mechanism. This becomes particularly powerful when communication channels are themselves seen as data and a mechanism is provided to create them on the fly: this gives rise to the notion of private channel. The semantics of communicating processes is open-ended in the sense that several alternative models coexists. Among them is the decision on whether a sending process should wait till its message has been received, or proceed with its computation.

We discuss coroutines as a specific form of concurrency. Coroutines pass control among each other in a programmatic way, possibly exchanging values as they do so.

This lecture examines the basics of the separate compilation of modules or libraries from a program that uses them. It defines an abstract linker.