The purpose of this web site is to gather and spread out information about ongoing work in the field of synchronous languages. These languages have been invented in the early 1980's (yes that was in the past century) to make the programming of reactive systems easier.
Any automatic control software is classified as a reactive system. Indeed, such software must react continuously to their environment. They differ from interactive systems (e.g. operating systems) by the fact that their reaction speed is imposed by the environment, because the environment cannot wait. Examples of such software include nuclear plant controllers, airplane flight systems, and so on.
The essential characteristics of reactive systems are:
Criticality: They are highly critical, just like the systems they control are critical.
Parallelism: At least the parallelism between the system and its environment must be taken into account during the specification. Moreover, it is very often convenient for the designer to conceive the system as a set of parallel components, cooperating in order to achieve the desired behaviour.
Determinism: A reactive system determines a sequence of output signals from a sequence of input signals in an unique way. This property makes their design, analysis, and debugging much easier. Thus it must be preserved by the implementation.
Classical programming tools are not well-suited to
reactive systems programming: Automata-based systems lack high-level
parallel programming primitives while asynchronous languages do not
respect the intrinsic determinism of reactive systems. Asynchronous
language inherit from the field of operating systems and shared
time. In particular, asynchronous parallelism is solved by
interleaving: The construct a||b
is either implemented as a;b or
as b;a, thus introducing an
unwanted non-determinism. This is the case of well known languages
like Occam and Ada which use rendezvous based mechanism
inspired by CSP. It is also the case of SDL which uses
waiting queues inspired by Petri Nets.
On the other hand, synchronous languages are based on
the simultaneity principle: The construct a||b is implemented as the
package ab, leaving to the
compiler the choice of the scheduling. Another way of viewing a
synchronous program consists of saying that all the parallel processes
evolve simultaneously, along a common discrete time scale. This is
known as the logical time abstraction: All the processes
compute one discrete time step at the same time. This is the approach
taken by the synchronous language
Esterel.
Another approach is to view a synchronous program as a dynamical system, specified as a system of dynamical equations. The job of the synchronous compiler consists then in solving this system of equations. This is the approach taken by the synchronous languages Lustre and Signal.
There are numerous advantages to the synchronous approach. The main one is that the temporal semantics is simplified, thanks to the aforementioned logical time abstraction. This leads to clear temporal constructs and easier time reasoning. Just like ML and Pascal are high level sequential programming languages, in the sense that they are typed and structured, synchronous languages are high level parallel languages in the sense that they are temporally typed and structured. Therefore, programming with ML reduces functional bugs, and programming with synchronous languages reduces temporal bugs.
Another key advantage is the reduction of state-space explosion, thanks to the discrete logical time abstraction: The systems evolves in a sequence of discrete steps, and nothing occurs between two successive steps. A first consequence is that program debugging, testing, and validating is made easier. In particular, formal verification of synchronous programs is possible with techniques like model checking. Another consequence is that synchronous language compilers are able to generate automatically embeddable code, with performances that can be measured precisely. Hence the reaction time of the software can be known at compile time, and can be compared with the desired sampling period. Thus control engineers can specify and tune their automatic control algorithm with synchronous languages, and then rely on the compiler to generate automatically embeddable code, therefore avoiding the tedious and error-prone task of actually implementing the code corresponding to their algorithm.
Historically, the first synchronous language is Esterel, developped at the Centre de Mathématiques Appliquées (CMA) of École des Mines de Paris, in Sophia-Antipolis, France, and later joined by people from INRIA. It is an imperative language that was originally inspired by CCS and SCCS. Esterel introduces constructs like preemption and communication by synchronous broadcast. It is devoted to the programming of discrete event systems. The Esterel Technologies company now markets an industrial version of the Esterel compiler. There exists several other synchronous languages. This is just a selection, presented in chronological order:
Lustre is a data-flow declarative functional language also inspired by Lucid. The Scade tool, initially developed by Verilog and Aerospatiale is based on Lustre. Scade is now marketed by Esterel Technologies.
Signal is also a data-flow declarative language, but it is relational instead of functional like Lustre. In this sense, it is more general than Lustre. Polychrony is the public domain Signal compiler, while Sildex is the commercial tool developed by TNI-Valiosys.
Argos is a purely synchronous version of the well known Statecharts formalism, which yields a number of advantages. In particular, Argos has a compositional semantics. SyncCharts and Mode Automata are both inspired from Argos.
Polis is a graphical tool for implementing Codesign Finite State Machines (CFSM). The model of computation behind CFSMs is a set of synchronous FSMs communicating asynchronously; It is therefore known as Globally Asynchronous Locally Synchronous (GALS). The Cierto VCC tool developed by Cadence is based on Polis.
SL, the Synchronous Language, is a variant of Esterel where hypotheses about signal presence or absence are not allowed. Whether a given signal is present or absent can only be decided at the end of a synchronous instant, hence reaction to a signal is delayed until the next instant. The main advantage is that causality problems are avoided. SL was the starting point of many other synchronous languages such as Sugar Cubes, Junior...
While Esterel, Argos, and SL are more suited to discrete event systems, Lustre, Signal and Polis are very close to the specification formalisms used by automatic control engineers: block diagrams, differential equations, data flow networks, automata, and so on.
Synchronous languages have recently seen a tremendous interest from leading companies developing automatic control software for critical applications, such as Schneider, Dassault, Aerospatiale, Snecma, Cadence, Texas, Thomson... For instance, Lustre is used to develop the control software for nuclear plants and Airbus planes. Esterel is used to develop DSP chips for mobile phones, to design and verify DVD chips, and to program the flight control software of Rafale fighters. And Signal is used to develop digital controllers for airplane engines. The key advantage pointed by these companies is that the synchronous approach has a rigorous mathematical semantics which allows the programmers to develop critical software faster and better.
In summary, synchronous programming is an interesting approach for designing and programming automatic control software. Synchronous languages have a well founded mathematical semantics which allows ideal temporal constructs as well as formal verification of the programs and automatic code generation. We think that they are ideally suited to programming automatic control software, because they are close to the classic specification formalisms used by control engineers, and also because they offer code generation tools that avoid the tedious and error-prone task of implementing the control algorithm after having specified it. These nice features were confirmed by their recent successes in automatic control industry.
The informations have been organised into several pages: Conferences, people and labs, industry partners, software, official bibliography references, useful related links, and a mailing list of people working in the field. Click on the corresponding links on the left frame.