Synchronous data-flow is a programming paradigm which has been successfully applied in reactive systems. In this context, it can be characterized as some class of static bounded memory data-flow networks. In particular, these networks are not recursively defined, and obey some kind of "synchronous" constraints (clock calculus). Based on Kahn's relationship between data-flow and stream functions, the synchronous constraints can be related to Wadler's listlessness, and can be seen as sufficient conditions ensuring listless evaluation. As a by-product, those networks enjoy efficient compiling techniques. In this paper, we show that it is possible to extend the class of static synchronous data-flow to higher order and dynamical networks, thus giving sense to a larger class of synchronous data-flow networks.

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.

This paper presents an attempt to characterize synchronous stream functions within the framework of co-iteration and to use this characterization in building a compiler for (higher order and recursive) synchronous data-flow programs. First length-preserving functions are considered and we show that streams equipped with such functions form a Cartesian-closed category. Then this point of view is extended toward non length-preserving ones and we stress the use of "empty" values in handling this case. Finally, the implementation we did of this material in a synchronous stream package built on top of an ML-like language is briefly described.

We propose a framework for building deadlock-free systems from deadlock-free components. The framework is based on a methodology for the layered construction of systems by superposing three layers. A layer of components, an interaction model and a restriction layer. The interaction model specifies the possible interactions between components. The restriction layer restricts the behavior of the two lower layers by a global constraint. Layered structuring allows separating three orthogonal aspects in system construction. Apart from its methodological interest it makes technically possible the definition of a unique and powerful associative composition operator. We study sufficient deadlock-freedom conditions for systems built from deadlock-free components and given interaction model and restriction. We also provide a sufficient condition for individual deadlock-freedom of the components of such systems.

this paper, we propose a framework for component-based modeling that brings some answers to the above issues. The framework uses an abstract layered model of components. It integrates and simplifies results about modeling timed systems by using timed automata with dynamic priorities [5, 1]

Abstract. We propose in this paper a historical perspective of programming issues found in the implementation of control systems, based on the author’s observations for more than fifteen years, but especially during the Crisys Esprit project. We show that in contrast with the asynchronous tradition of computer scientists, control engineers were naturally led to a synchronous practice that was later formalised and generalised by computer people. But, we also show that, for the sake of robustness and distribution those practitioners had to incorporate some degree of asynchrony in this synchronous approach and we try to comment the resulting programming style. 1

Introduction 1.1 Advanced Real-Time Systems The evolution of information sciences and technologies is characterized by the extensive integration of embedded components in systems used in various application areas, from telecommunications to automotive, manufacturing, medical applications, e-commerce etc. In most cases, embedded components are real-time systems that continuously interact with other systems and the physical world. Integration and continuous interaction of software and hardware components makes the assurance of global quality a major issue in system design. The failure of a component may have catastrophic consequences on systems performance, security, safety, availability etc. Building embedded real-time systems of guaranteed quality, in a cost-eective manner, raises challenging scienti c and technological problems. Existing theory, techniques and technology are of little help as they fail to provide a global framework relating various design parameters to system dyn

Lustre is a data-flow programming language for reactive purposes, which has been given a synchronous operational semantic. Static checks called "clock calculus" restrict Lustre programs to those data-flow networks which can be executed synchronously. As a by-product of this restriction, Lustre programs enjoy efficient compiling techniques. Yet, due to its reactive origin, Lustre applies only to static networks. We show here, that both this operational semantic, and clock calculus can be extended toward accounting for general functional features : abstraction, application and recursion. This allows us to give sense to both higher order, and dynamical synchronous data-flow networks, which can thus be expected to share the same efficient compiling techniques. 1. Introduction 1.1. Some milestones in data-flow programming In the seventies, the Lucid language was proposed 2;1 as a way of overcoming the lack of efficency of functional languages by providing them with stream based iteration...

Introduction 1.1. Flots de donn'ees Dans les ann'ees 70, le langage Lucid a 'et'e propos'e [2, 1], pour pallier l'inefficacit'e des langages fonctionnels, en introduisant un style d'it'eration fond'e sur les suites de valeurs. A peu pr`es `a la meme 'epoque, Gilles Kahn montrait [13] que la s'emantique de r'eseaux de processus asynchrones et d'eterministes, communiquant par des files d'attente, pouvait se d'ecrire comme des syst`emes d"equations de suites, tr`es voisins des programmes Lucid. Parall`element, le concept d"evaluation paresseuse 'emergeait comme un outil pratique [10, 16], permettant d'introduire dans les langages de programmation des types de donn'ees infinis, comme les suites, et maintenant, des langages fonctionnels modernes, comme Lazy ML ou Haskell permettent d"ecrire tr`es facilement des programmes `a la Lucid ou `a la Kahn, en apportant de nombreuse facilit'es d'expression, tels la curryfic

Synchronous languages [Hal93] have been designed to help in the conception of reactive systems, especially critical reactive systems (planes, power plants control...). Synchrony is a program property which ensures bounded reaction-time and memory at execution. Synchronous languages statically check this property. However, in a critical context, it may be needed to have it formally proved, or more generally to prove program properties. In this work we are interested in Lucid-Synchrone [PCCH01] (LS for short), a data-ow synchronous language. We present here a natural and shallow embedding of LS into the Coq proof assistant. This embedding concerns both the dynamic and the static semantics of the language, such that synchrony analysis is obtained for free. Moreover, it gives us a denotational semantics of LS in Coq and is thus a good starting point for designing a prover for LS programs in Coq, following [Fil99, Par95] approach. This semantics can also be used to experiment with the language: we have used it here to propose a notion of recursive functions for LS, as a generalization of recursive streams. The main originality of this work is to apply the \clocks as types" paradigm (see [Cas92]) in the design of a formal semantics for a synchronous language. This paradigm consists in expressing static synchronization constraints with a restricted form of dependent types. We show here that such a type system is a subsystem of Coq type system. This paper is an extended version of [BH01]. 2 CONTENTS Contents 1