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.:

• Programs are "obviously correct"; no separate proof is required.
• Programs can easily be manipulated, transformed, etc.
• Programs can be "declaratively debugged".

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.

The following documents on Tempo are available:

• An overall description of Tempo, published in ICLP95 (see abstract).
• A description of a version of Tempo, which is a superset of the original language (see abstract).
• A paper on the derivation of concurrent algorithms using Tempo (see abstract).
• A paper about Tempo++, an object-oriented extension of Tempo (see abstract).
• A paper comparing Tempo, Tempo++, and Petri nets (see abstract).
• The User's Guide for Tempo for Windows contains more detailed information about Tempo implementation.