Skip to main content

Tempo: a declarative concurrent programming language

The ideal of declarative programming is that a program acts as its own specification, which gives many well known benefits, e.g.:

Unfortunately, even ``declarative'' languages tend to resort to imperative (``non-logical'') features for some purposes, particularly for interaction with their environment, e.g., I/O. This is perhaps especially true in concurrent programming, where a lot of programming effort goes into ensuring that processes correctly interact with each other.

Concurrent logic programming languages (e.g., Parlog, KL1, etc.) are declarative in the sense that a program explicitly describes the final result (if any) that it computes. However, the other aspects of a program's behaviour have to be preserved by proper use of the language's control features (e.g., modes). (Reactive programs are often not intended to produce a final result, and these cannot be considered declarative at all.)

Tempo is an attempt to solve this problem. Tempo is a declarative language based on classical first-order logic, which has a simple, concurrent, procedural interpretation. It improves on traditional concurrent logic programming languages in that a program can explicitly specify its safety properties, not just the final result computed (which is a special case of a safety property). This means, for example, that a Tempo program can be manipulated using standard program transformation techniques without affecting its correct behaviour. By raising the level of concurrent programming in this way, the likelihood of programming errors is reduced and the reliability of concurrent software increased. More details of this work are available on


Steve Gregory.