CSCI 8980: Advanced Topics in Programming Languages
Fall 2006, Class Presentations

A solution is to use incremental garbage collection, which performs its function in time-bounded steps so as to avoid those pause times. Of course, this raises the issue of how to keep the garbage collector hidden from the "mutator" (user program).

Methods used for this purpose are the "read barrier" and the "write barrier," which keep an eye on each of those respective actions from the mutator. Of these, the write-barrier algorithm is the most useful for purely-functional languages, which perform no writes at all.

A theory has associated with it of a set of function symbols and equalities. For example, a theory of list operator terms has the equalities:

        car (cons (x, y)) = x
        cdr (cons (x, y)) = y
        cons (car (x), cdr (y)) = x

        cons (car (x), cdr (car (y))) = cdr (cons (y, x))

        y = cons (cons (a, cdr (x)), d)

We first look at work by Nelson and Oppen which uses the concept of graph congruence closures to derive a fast algorithm for deciding equality of terms in certain theories (such as the list operator theory above). We then look at work by Shostak that extends this algorithm to decide combinations of theories. For example, given a theory consisting of the combination of lists and linear arithmetic, Shostak's algorithm takes the formula

        5 + car (x + 1) = cdr (x + 2) + 3

        x = cons (cdr (x + 2) - 2, d) - 1

In the references below, the most important one to look at is the paper by Shostak. If you get through this, then the one to look at next is the paper by Nelson and Oppen.

The representation of primitive data types differs in each language. Also, there are some primitive data types like pointers in C, or native data types like lists in ML that may have no representation in the other language. Further more, the layout of aggregate data types such as tuples in ML and unions in C may require explicit mapping directives from the programmer in order for them to be used between languages.

One approach to interoperability is called Representation Level Interoperability (RLI). RLI hides such differences as byte orders, floating-point precisions, or array accessing mechanisms [3]. An example of RLI is the SML of NJ ~ C Foreign Function Interface library. This library provides a mapping between primitive data types as well as aggregate data types, however, the programmer must provide some details about data types and values that are passed from C to ML [4].

Another approach to interoperability is called Specification Level Interoperability (SLI). SLI extends RLI by hiding representation differences for abstract types as well as simple types [3]. An example of SLI is SML.NET. SML.NET is a compiler for Standard ML that targets the Mircrosoft Common Language Infrastructure, producing Microsoft Common Intermediate Language as its object code [5]. The Common Intermediate Language and the Common Language Runtime have been designed from the ground up to support high level programming language interoperability [6] in a transparent way. In this development environment, a programmer can make use of a data type or functions written in one language directly in another language. The translation or mapping of data representations is handled by the CIL [7].

As an example, say we want to write a library in ML that contains a binary tree datatype and we want to use this datatype in a program which we will write in C or some other imperative language. Two solutions for this trivial example will be presented, one using SML/NJ-C FFI and the other using SML.NET, in order to show how these data representation issues can be addressed and interoperability can be achieved.

Of the references below, [4] and [5] are the ones that you should read to get the most out of the presentation.

"... two features of functional languages in particular, higher-order functions and lazy evaluation, can contribute greatly to modularity.... Since modularity is the key to successful programming, functional languages are vitally important to the real world." [1]

In this talk, I will discuss the factors that lead programmers to adopt programming languages. I will summarize existing research and commentary from HCI researchers programming language educators and researchers, and industry pundits. I will conclude with a roundtable discussion on the future of programming languages.

Participants will get the most out of this presentation if they have had some small exposure to the object system in O'Caml, and if they have a basic understanding of unification in a function language like ML.