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

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 http://star.cs.bris.ac.uk/projects/tempo.html.

Staff

Steve Gregory.

Publications

• Gregory, S. and Ramirez, R. Tempo: a declarative concurrent programming language. In Proceedings of the 12th International Conference on Logic Programming (Kanagawa, June). MIT Press, 1995.
• Gregory, S. Derivation of concurrent algorithms in Tempo. In Proceedings of LOPSTR95: Fifth International Workshop on Logic Program Synthesis and Transformation (Arnhem, September 1995). Springer Verlag, 1996.
• Gregory, S. A declarative approach to concurrent programming. In Proceedings of PLILP97: Proceedings of the 9th International Symposium on Programming Languages, Implementations, Logics, and Programs (Southampton, September 1997). Springer-Verlag, 1997.