https://hal.inria.fr/inria-00075711/document

The ESTEREL synchronous programming language: design, semantics, implementation

The authors describe LUSTRE, a data flow synchronous language designed for programming reactive systems-such as automatic control and monitoring systems-as well as for describing hardware. The data flow aspect of LUSTRE makes it very close to usual description tools in these domains (block-diagrams, networks of operators, dynamical sample-systems, etc.), and its synchronous interpretation makes it well suited for handling time in programs. Moreover, this synchronous interpretation allows it to be compiled into an efficient sequential program. The LUSTRE formalism is very similar to temporal logics. This allows the language to be used for both writing programs and expressing program properties, which results in an original program verification methodology. >

/pdf/the-synchronous-data-flow-programming-language-lustre-2j8zn4zee2.pdf

The synchronous data flow programming language LUSTRE

This book presents a synthesis of recent works concerning reactive system design. The term `reactive system' has been introduced in order to avoid ambiguities often involved with the term `real-time system' which, while being best-known and suggestive, has been assigned so many different meanings that it is almost inevitably misunderstood. Industrial Process control system, transportation control and supervision systems, signal processing systems, etc. are examples of the systems we have in mind. Four programming languages are presented, which share the same underlying synchronous model: based on Robin Milner's pioneering works about synchronous process algebras, this model consists in considering that a program instantaneously reacts to events, or that the machine execution time is negligible with respect to the response delays of its environment. Using this abstract point of view, the time behavior of a system can be formalized in a very simple and elegant way. The languages presented are ESTEREL, a textual imperative language; ARGOS, a graphical language inspired by STATECHARTS; and LUSTRE and SIGNAL, two declarative languages. After a tutorial description of the languages, illustrated by various examples, a set of related tools is presented: compilers to sequential and distributed code, silicon compilers, verification tools.

http://www-verimag.imag.fr/~halbwach/newbook.pdf

Synchronous programming of reactive systems

Twelve years ago, Proceedings of the IEEE devoted a special section to the synchronous languages. This paper discusses the improvements, difficulties, and successes that have occured with the synchronous languages since then. Today, synchronous languages have been established as a technology of choice for modeling, specifying, validating, and implementing real-time embedded applications. The paradigm of synchrony has emerged as an engineer-friendly design method based on mathematically sound tools.

/pdf/the-synchronous-languages-12-years-later-55re7ed5k3.pdf

The synchronous languages 12 years later

Handbook of the International Phonetic Association: A Guide to the Use of the International Phonetic Alphabet

This paper presents the language LUSTRE, whose main application field is the programming of automatic control and signal processing systems. In this field, design is tra- ditionally driven by means of two types of tools. First, specifications are often systems of equations (differential or finite difference equations, boolean equations, . . .). Second, implementations are often nets of operators connected with wires (switches, gates, analog diagrams). Such tools present several ad&tag- as a basis for

https://www.cse.unsw.edu.au/~plaice/archive/JAP/P-ACM_POPL87-lustre.pdf

LUSTRE: A declarative language for programming synchronous systems*

LUSTRE is a synchronous data-flow language for programming systems which interact with their environments in real-time. After an informal presentation of the language, we describe its semantics by means of structural inference rules. Moreover, we show how to use this semantics in order to generate efficient sequential code, namely, a finite state automaton which represents the control of the program. Formal rules for program transformation are also presented.

LUSTRE: a declarative language for real-time programming

Transition systems the synchronous product of transition systems transition system logics verification of properties of transition systems fixpoints in transition systems software tools.

Finite transition systems: semantics of communicating systems

A method for controlling versions of software and other hierarchically structured entities is presented. Using the variant structure principle, a particular version of an entire system is formed by combining the most relevant existing versions of the various components of the system. An algebraic version language that allows histories (numbered series), subversions (or variants), and joins is described. It is shown that the join operation is simply the lattice least upper bound and together with the variant structure principle, provides a systematic framework for recombining divergent variants. The utility of this approach is demonstrated using LEMUR, a programming environment for modular C programs, which was developed using itself. The ways in which this notion of versions is related to the possible world semantics of intensional logic are discussed. >

http://www.cse.unsw.edu.au/~plaice/archive/JAP/P-TOSE93-lemur.pdf

John Plaice

Papers

LUSTRE: A declarative language for programming synchronous systems*

LUSTRE: a declarative language for real-time programming

Finite transition systems: semantics of communicating systems

A new approach to version control

Distributed Communities on the Web