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.

Publications

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.