Reactive imperative programming with dataflow constraints

@inproceedings{Demetrescu2011ReactiveIP,
  title={Reactive imperative programming with dataflow constraints},
  author={Camil Demetrescu and Irene Finocchi and Andrea Ribichini},
  booktitle={OOPSLA '11},
  year={2011}
}
Dataflow languages provide natural support for specifying constraints between objects in dynamic applications, where programs need to react efficiently to changes of their environment. Researchers have long investigated how to take advantage of dataflow constraints by embedding them into procedural languages. Previous mixed imperative/dataflow systems, however, require syntactic extensions or libraries of ad hoc data types for binding the imperative program to the dataflow solver. In this paper… 
Reactive Imperative Programming with Dataflow Constraints
TLDR
This article shows that one-way dataflow constraints, largely explored in the context of interactive applications, can be seamlessly integrated in any imperative language and can be used as a general paradigm for writing performance-critical reactive applications that require efficient incremental computations.
QL : Language-Integrated Live Data Views
TLDR
i3QL provides a declarative SQL-like syntax and is based on incremental versions of operators from relational algebra, enriched with support for general recursion, and optimizes user-defined queries by applying algebraic laws and partial evaluation.
Reactive Traversal of Recursive Data Types
TLDR
The proposed mechanism to traverse recursive data types incrementally, in successive reactions to external input events, is designed for the synchronous language Céu, inheriting all of its concurrency functionality and safety properties.
Methods for architecting software
TLDR
It is concluded that the methods considered and implemented into a framework provide a way of architecting event-driven software in ways that increases the abstraction level and introduce new possibilities for debugging event- driven applications.
Reactive Programming Paradigm for Development User Interfaces
The article discusses the relevance of using the paradigm for user interfaces development. The essence of the reactive programming paradigm, its features and disadvantages are described. The
Formalisation et exécutabilité du langage "EditionPattern" au sein de la plate-forme Openflexo
TLDR
This document proposes, in this document, an architecture for promoting semantics sharing between models in Openflexo, an opensource modeling tool dedicated to collaborative modeling.
Reactive caching for composed services: polling at the speed of push
TLDR
This work presents an alternative reactive polling API and reactive caching algorithm that combines the conceptual simplicity of polling with the efficiency of push-based change propagation, and presents a fault-tolerant distributed algorithm for reactive caching that guarantees eventual consistency.
Reactive Caching for Composed Services
TLDR
This work presents an alternative reactive polling API and reactive caching algorithm that combines the conceptual simplicity of polling with the efficiency of push-based change propagation, and presents a faulttolerant distributed algorithm for reactive caching that guarantees eventual consistency.
Migrating business logic to an incremental computing DSL: a case study
TLDR
It is found that the migrated code has better validatability; it is straightforward to establish that a program ‘does the right thing’; and the performance is better than the previous hand-written incremental computing solution.
The Soot framework for Java program analysis: a retrospective
TLDR
relevant features of Soot are described, its development process is summarized, and useful features for future program analysis frameworks are discussed.
...
...

References

SHOWING 1-10 OF 66 REFERENCES
Crossing State Lines: Adapting Object-Oriented Frameworks to Functional Reactive Languages
TLDR
This paper studies the adaptation of the object-oriented toolkit MrEd to the functional reactive language FrTime, and presents a basic strategy for adaptation and discusses abstraction techniques based on mixins and macros that allow us to adapt numerous properties in many widget classes with minimal code duplication.
Introduction to Operational Semantics
TLDR
This chapter presents the syntax of a programming language, IMP, a small language of while programs, described by rules which specify how its expressions are evaluated and its commands are executed, and how these rules furnish a basis for simple proofs of equivalence between commands.
Integrating Constraints with an Object-Oriented Language
TLDR
Kaleidoscope'91 uses a class-based object model, multi-methods, and constraint constructors to integrate cleanly the encapsulation and abstraction of a state-of-the-art object-oriented language with the declarative aspects of constraints.
ReactiveML: a reactive extension to ML
TLDR
ReactiveML is a programming language dedicated to the implementation of complex reactive systems as found in graphical user interfaces, video games or simulation problems based on the reactive model introduced by Boussinot.
Embedding Dynamic Dataflow in a Call-by-Value Language
TLDR
FrTime, an extension of Scheme designed for writing interactive applications that embeds dynamic dataflow within a call-by-value functional language, is described and a formal semantics of its evaluation model is presented.
Compiling Constraint Handling Rules into Prolog with Attributed Variables
We introduce the most recent and advanced implementation of constraint handling rules (CHR) in a logic programming language, which improves both on previous implementations (in terms of completeness,
CEAL: a C-based language for self-adjusting computation
TLDR
The design and implementation of CEAL are described and it is shown that CEAL is effective in practice: compiled self-adjusting programs respond to small modifications to their data by orders of magnitude faster than recomputing from scratch while slowing down a from-scratch run by a moderate constant factor.
Flapjax: a programming language for Ajax applications
TLDR
Flapjax provides two key features that simplify writing these applications: it provides event streams, a uniform abstraction for communication within a program as well as with external Web services, and the language itself is reactive: it automatically tracks data dependencies and propagates updates along those dataflows.
LUSTRE: a declarative language for real-time programming
TLDR
This work describes its semantics by means of structural inference rules and shows how to use this semantics in order to generate efficient sequential code, namely, a finite state automaton which represents the control of the program.
Functional reactive programming, continued
TLDR
Of particular interest are the AFRP combinators that support dynamic collections and continuation-based switching and it is shown how these combinators can be used to express systems with an evolving structure that are difficult to model in more traditional dataflow languages.
...
...