This special issue is devoted to the synchronous approach to reactive and real-time programming. This introductory paper presents and discusses the application fields and the principles of synchronous programming. The major concern of the synchronous approach is to base synchronous programming languages on math-ematical models. This makes it possible to handle compilation, logical correctness proofs, and verifications of real-time programs in a formal way, leading to a clean and precise methodology for design and programming. 1. INTRODUCTION: REAL-TIME AND REACTIVE SYSTEMS It is commonly accepted to call real-time a program or system that receives external interrupts or reads sensors connected to the physical world and outputs commands to it. Real-time programming is an essential industrial activ-

: The state/transition paradigm has been used extensively for the description of event-driven, parallel systems. However, the lack for hierarchic structure in such descriptions usually prevents us from using this paradigm in a real programming language. We propose the Argos language for reactive systems. The basic components of a program are input/output-labeled transition systems verifying reactivity (a property similar to input-enabling in IOautomata) . The composition operations (parallel composition and refinement, providing hierarchy) are based upon the synchronous broadcast mechanism of Esterel. We define the language formally in an algebraic framework, and give an operational semantics. The main result is the compositionality of the semantics; we prove that the bisimulation of models induces an equivalence which is a congruence for the operators we propose. An interesting point is the way we introduce hierarchy in a compositional way. 1 1 Introduction The problem ...

We propose a method for the implementation and analysis of real-time systems, based on the compilation of specifications into extended automata. Such a method has been already adopted for the so called "synchronous" real-time programming languages.

Modern embedded computing systems tend to be heterogeneous in the sense of being composed of subsystems with very different characteristics, which communicate and interact in a variety of ways---synchronous or asynchronous, buffered or unbuffered, etc. Obviously, when designing such systems, a modeling language needs to reflect this heterogeneity. Today's modeling environments usually offer a variant of what we call amorphous heterogeneity to address this problem. This paper argues that modeling systems in this manner leads to unexpected and hard-to-analyze interactions between the communication mechanisms and proposes a more structured approach to heterogeneity, called hierarchical heterogeneity to solve this problem. It proposes a model structure and semantic framework that support this form of heterogeneity, and discusses the issues arising from heterogeneous component interaction and the desire for component reuse. It introduces the notion of domain polymorphism as a way to address these issues.

... This paper describes an extension of the C programming language called RC (for `Reactive C') to program reactive systems. The language RC is described, then some programming examples are given to illustrate the reactive approach. The main RC notions come directly from the Esterel synchronous programming language. Finally, the Esterel and RC languages are compared.

This paper addresses the problem of automatizing the production of test sequences for reactive systems. We particularly focus on two points: (1) generating relevant inputs, with respect to some knowledge about the environment in which the system is intended to run; (2) checking the correctness of the test results, according to the expected behavior of the system. We propose to use synchronous observers to express both the relevance and the correctness of the test sequences. In particular, the relevance observer is used to randomly choose inputs satisfying temporal assumptions about the environment. These assumptions may involve both Boolean and linear numerical constraints. A prototype tool, called Lurette, has been developed and experimented, which works on observers written in the Lustre programming language. 1 Introduction The term reactive system was introduced by David Harel and Amir Pnueli [12], and is now commonly accepted to designate systems that permanently interac...

. In the field of reactive system programming, dataflow synchronous languages like Lustre [BCH + 85,CHPP87] or Signal [GBBG85] offer a syntax similar to block-diagrams, and can be efficiently compiled into C code, for instance. Designing a system that clearly exhibits several "independent" running modes is not difficult since the mode structure can be encoded explicitly with the available dataflow constructs. However the mode structure is no longer readable in the resulting program; modifying it is error prone, and it cannot be used to improve the quality of the generated code. We propose to introduce a special construct devoted to the expression of a mode structure in a reactive system. We call it mode-automaton, for it is basically an automaton whose states are labeled by dataflow programs. We also propose a set of operations that allow the composition of several mode-automata (parallel and hierarchic compositions taken from Argos [Mar92]), and we study the properties...

A system is said to be reactive if it interacts continuously with an environment, at a speed imposed by the environment. The system deals with inputs and outputs and the languages for programming reactive systems aim at describing the complex ordering and causality relations between the inputs and the corresponding outputs. The synchronous approach, based upon the assumption that a system reacts in zero time, allows the definition of compositional semantics for various kinds of language constructs, in data-flow frameworks (Lustre [3], Signal [4]) as well as in imperative frameworks (Esterel [1, 2], Argos [8]). In this paper we take advantage of this compositionality property to define the mixing of data-flow constructs with automaton compositions in a single language. We apply the results to Lustre and Argos, and discuss some implementation issues. 1 Introduction According to the classification of computer systems introduced by A. Pnueli and D. Harel [6], a system is either transform...

The paper introduces a higher-order synchronous data-flow language in which communication channels may themselves transport programs. This provides a mean to dynamically reconfigure data-flow processes. The language comes as a natural and strict extension of both Lustre and Lucid Synchrone. This extension is conservative, in the sense that a first-order restriction of the language can receive the same semantics. We illustrate the expressivity of the language with some examples, before giving the formal semantics of the underlying calculus. The language is equipped with a polymorphic type system allowing types to be automatically inferred and a clock calculus rejecting programs for which synchronous execution cannot be statically guaranteed. To our knowledge, this is the first higher-order synchronous data-flow language where stream functions are first class citizens. Categories and Subject Descriptors C.3 [Special-purpose and application-based systems]: Real-time and embedded systems; D.3.2 [Language classifications]: Data-flow languages; F.3.2 [Semantics of programming languages]: Operational semantics.

. We propose to apply the verification techniques available for Timed Graphs [ACD90], and particularly the symbolic model-checking algorithm of [HNSY92], to the Argos [Mar92] synchronous language. We extend the language with a single delay construct that allows to express watchdogs and timeouts, at any level in the parallel or hierarchic structure of a program. We define the semantics of this extended language in terms of Timed Graphs, and show that it is a "convenient" extension of the pure Argos synchronous semantics. Indeed, for discrete time, the two semantics coincide. The Timed Graph semantics can be viewed as a continuous time semantics for Argos. We extend the Argos compiler and connect it to the kronos tool which implements the abovementioned model-checking algorithm. 1 Introduction The synchronous languages for real-time systems, like Lustre [CHPP87], Esterel [BG88, BG92], Signal [GBBG85], Statecharts [Har87] and Argos [Mar92] traditionally deal with multiform tim...