Results 1  10
of
16
Ultrametric Semantics of Reactive Programs
"... Abstract—We describe a denotational model of higherorder functional reactive programming using ultrametric spaces and nonexpansive maps, which provide a natural Cartesian closed generalization of causal stream functions and guarded recursive definitions. We define a type theory corresponding to thi ..."
Abstract

Cited by 8 (3 self)
 Add to MetaCart
Abstract—We describe a denotational model of higherorder functional reactive programming using ultrametric spaces and nonexpansive maps, which provide a natural Cartesian closed generalization of causal stream functions and guarded recursive definitions. We define a type theory corresponding to this semantics and show that it satisfies normalization. Finally, we show how reactive programs written in this language may be implemented efficiently using an imperatively updated dataflow graph, and give a separation logic proof that this lowlevel implementation is correct with respect to the highlevel semantics. I.
Abstraction of clocks in synchronous dataflow systems
, 2008
"... Synchronous dataflow languages such as Lustre manage infinite sequences or streams as basic values. Each stream is associated to a clock which defines the instants where the current value of the stream is present. This clock is a type information and a dedicated type system — the socalled clockc ..."
Abstract

Cited by 7 (5 self)
 Add to MetaCart
Synchronous dataflow languages such as Lustre manage infinite sequences or streams as basic values. Each stream is associated to a clock which defines the instants where the current value of the stream is present. This clock is a type information and a dedicated type system — the socalled clockcalculus — statically rejects programs which cannot be executed synchronously. In existing synchronous languages, it amounts at asking whether two streams have the same clocks and thus relies on clock equality only. Recent works have shown the interest of introducing some relaxed notion of synchrony, where two streams can be composed as soon as they can be synchronized through the introduction of a finite buffer (as done in the SDF model of Edward Lee). This technically consists in replacing typing by subtyping. The present paper introduces a simple way to achieve this relaxed model through the use of clock envelopes. These clock envelopes are set of concrete clocks which are not necessarily periodic. This allows to model various features in realtime embedded software such as bounded jitter as found in videosystems, execution time of realtime processes and scheduling resources or the communication through buffers. We present the algebra of clock envelopes and its main theoretical properties.
A Semantic Model for Graphical User Interfaces
, 2011
"... We give a denotational model for graphical user interface (GUI) programming in terms of the cartesian closed category of ultrametric spaces. The metric structure allows us to capture natural restrictions on reactive systems, such as causality, while still allowing recursively defined values. We capt ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
We give a denotational model for graphical user interface (GUI) programming in terms of the cartesian closed category of ultrametric spaces. The metric structure allows us to capture natural restrictions on reactive systems, such as causality, while still allowing recursively defined values. We capture the arbitrariness of user input (e.g., a user gets to decide the stream of clicks she sends to a program) by making use of the fact that the closed subsets of a metric space themselves form a metric space under the Hausdorff metric, allowing us to interpret nondeterminism with a “powerspace ” monad on ultrametric spaces. The powerspace monad is commutative, and hence gives rise to a model of linear logic. We exploit this fact by constructing a mixed linear/nonlinear domainspecific language for GUI programming. The linear sublanguage naturally captures the usage constraints on the various linear objects in GUIs, such as the elements of a DOM or scene graph. We have implemented this DSL as an extension to OCaml, and give examples demonstrating that programs in this style can be short and readable.
Divide and recycle: types and compilation for a hybrid synchronous language
 In ACM SIGPLAN/SIGBED Languages, Compilers, Tools & Theory for Embedded Systems (LCTES
, 2011
"... Hybrid modelers such as SIMULINK have become corner stones of embedded systems development. They allow both discrete controllers and their continuous environments to be expressed in a single language. Despite the availability of such tools, there remain a number of issues related to the lack of repr ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
Hybrid modelers such as SIMULINK have become corner stones of embedded systems development. They allow both discrete controllers and their continuous environments to be expressed in a single language. Despite the availability of such tools, there remain a number of issues related to the lack of reproducibility of simulations and to the separation of the continuous part, which has to be exercised by a numerical solver, from the discrete part, which must be guaranteed not to evolve during a step. Starting from a minimal, yet fullfeatured, LUSTRElike synchronous language, this paper presents a conservative extension where dataflow equations can be mixed with ordinary differential equations (ODEs) with possible reset. A type system is proposed to statically distinguish discrete computations from continuous ones and to ensure that signals are used in their proper domains. We
Lucyn: a nSynchronous Extension of Lustre
"... Synchronous functional languages such as Lustre or Lucid Synchrone define a restricted class of Kahn Process Networks which can be executed with no buffer. Every expression is associated to a clock indicating the instants when a value is present. A dedicated type system, the clock calculus, checks ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
Synchronous functional languages such as Lustre or Lucid Synchrone define a restricted class of Kahn Process Networks which can be executed with no buffer. Every expression is associated to a clock indicating the instants when a value is present. A dedicated type system, the clock calculus, checks that the actual clock of a stream equals its expected clock and thus does not need to be buffered. The nsynchrony relaxes synchrony by allowing the communication through bounded buffers whose size is computed at compiletime. It is obtained by extending the clock calculus with a subtyping rule which defines buffering points. This paper presents the first implementation of the nsynchronous model inside a Lustrelike language called Lucyn. The language extends Lustre with an explicit buffer construct whose size is automatically computed during the clock calculus. This clock calculus is defined as an inference type system and is parametrized by the clock language and the algorithm used to solve subtyping constraints. We detail here one algorithm based on the abstraction of clocks, an idea originally introduced in [5]. The paper presents a simpler, yet more precise, clock abstraction for which the main algebraic properties have been proved in Coq. Finally, we illustrate the language on various examples including a video application.
HigherOrder Functional Reactive Programming in Bounded Space
"... Functional reactive programming (FRP) is an elegant and successful approach to programming reactive systems declaratively. The high levels of abstraction and expressivity that make FRP attractive as a programming model do, however, often lead to programs whose resource usage is excessive and hard to ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
Functional reactive programming (FRP) is an elegant and successful approach to programming reactive systems declaratively. The high levels of abstraction and expressivity that make FRP attractive as a programming model do, however, often lead to programs whose resource usage is excessive and hard to predict. In this paper, we address the problem of space leaks in discretetime functional reactive programs. We present a functional reactive programming language that statically bounds the size of the dataflow graph a reactive program creates, while still permitting use of higherorder functions and highertype streams such as streams of streams. We achieve this with a novel linear type theory that both controls allocation and ensures that all recursive definitions are wellfounded. We also give a denotational semantics for our language by combining recent work on metric spaces for the interpretation of higherorder causal functions with lengthspace models of spacebounded computation. The resulting category is doubly closed and hence forms a model of the logic of bunched implications.
TOWARDS SAFE AND EFFICIENT FUNCTIONAL REACTIVE PROGRAMMING
, 2011
"... Functional Reactive Programming (FRP) is an approach to reactive programming where systems are structured as networks of functions operating on timevarying values (signals). FRP is based on the synchronous dataflow paradigm and supports both continuoustime and discretetime signals (hybrid systems ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Functional Reactive Programming (FRP) is an approach to reactive programming where systems are structured as networks of functions operating on timevarying values (signals). FRP is based on the synchronous dataflow paradigm and supports both continuoustime and discretetime signals (hybrid systems). What sets FRP apart from most other reactive languages is its support for systems with highly dynamic structure (dynamism) and higherorder reactive constructs (higherorder dataflow). However, the price paid for these features has been the loss of the safety and performance guarantees provided by other, less expressive, reactive languages. Statically guaranteeing safety properties of programs is an attractive proposition. This is true in particular for typical application domains for reactive programming such as embedded systems. To that end, many existing reactive languages have type systems or other static checksthatguaranteedomainspecificconstraints, suchasfeedbackbeingwellformed(causality analysis). However, comparedwithFRP,theyarelimitedintheircapacitytosupportdynamism andhigherorderdataflow. Ontheotherhand, asestablishedstatictechniquesdonotsufficefor highly structurally dynamic systems, FRP generally enforces few domainspecific constraints, leaving the FRP programmer to manually check that the constraints are respected. Thus, there
A hybrid synchronous language with hierarchical automata: static typing and translation to synchronous code
 in EMSOFT ’11
"... Hybrid modeling tools like Simulink have evolved from simulation platforms into development platforms on which testing, verification and code generation are also performed. It is critical to ensure that the results of simulation, compilation and verification are consistent. Synchronous languages hav ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
Hybrid modeling tools like Simulink have evolved from simulation platforms into development platforms on which testing, verification and code generation are also performed. It is critical to ensure that the results of simulation, compilation and verification are consistent. Synchronous languages have addressed these issues but only for discrete systems. Reprising earlier work, we present a hybrid modeler built from a synchronous language and an offtheshelf numerical solver. The main novelty is a language with hierarchical automata that can be arbitrarily mixed with dataflow and ordinary differential equations (ODEs). A type system statically ensures that discrete state changes are aligned with zerocrossing events and that the function passed to the numerical solver has no sideeffects during integration. Welltyped programs are compiled by sourcetosource translation into synchronous code which is then translated into sequential code using an existing synchronous language compiler. Categories and Subject Descriptors C.3 [Specialpurpose and applicationbased systems]: Realtime and embedded systems; D.3.2 [Language classifications]: Dataflow languages
An Ultrametric Model of Reactive Programming
, 2010
"... We describe a denotational model of higherorder functional reactive programming using ultrametric spaces, which provide a natural Cartesian closed generalization of causal stream functions. We define a domainspecific language corresponding to the model. We then show how reactive programs written i ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We describe a denotational model of higherorder functional reactive programming using ultrametric spaces, which provide a natural Cartesian closed generalization of causal stream functions. We define a domainspecific language corresponding to the model. We then show how reactive programs written in this language may be implemented efficiently using an imperatively updated dataflow graph and give a higherorder separation logic proof that this lowlevel implementation is correct with respect to the highlevel semantics.