LUSTRE: a declarative language for real-time programming
POPL '87 Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Incremental attribute evaluation: a flexible algorithm for lazy update
ACM Transactions on Programming Languages and Systems (TOPLAS)
Report on the programming language Haskell: a non-strict, purely functional language version 1.2
ACM SIGPLAN Notices - Haskell special issue
An incremental algorithm for a generalization of the shortest-path problem
Journal of Algorithms
ICFP '97 Proceedings of the second ACM SIGPLAN international conference on Functional programming
The Amulet Environment: New Models for Effective User Interface Software Development
IEEE Transactions on Software Engineering
The sugarCubes tool box: a reactive Java framework
Software—Practice & Experience
Incremental evaluation of computational circuits
SODA '90 Proceedings of the first annual ACM-SIAM symposium on Discrete algorithms
A debate on language and tool support for design patterns
Proceedings of the 27th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Functional reactive programming from first principles
PLDI '00 Proceedings of the ACM SIGPLAN 2000 conference on Programming language design and implementation
The Programming Language Aspects of ThingLab, a Constraint-Oriented Simulation Laboratory
ACM Transactions on Programming Languages and Systems (TOPLAS)
Lessons learned about one-way, dataflow constraints in the Garnet and Amulet graphical toolkits
ACM Transactions on Programming Languages and Systems (TOPLAS)
POPL '77 Proceedings of the 4th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
System Design with SystemC
Incremental evaluation for attribute grammars with application to syntax-directed editors
POPL '81 Proceedings of the 8th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Functional reactive programming, continued
Proceedings of the 2002 ACM SIGPLAN workshop on Haskell
Frappé: Functional Reactive Programming in Java
PADL '01 Proceedings of the Third International Symposium on Practical Aspects of Declarative Languages
Integrating Constraints with an Object-Oriented Language
ECOOP '92 Proceedings of the European Conference on Object-Oriented Programming
Metastructures versus Attributed Variables in the Context of Extensible Unification
PLILP '92 Proceedings of the 4th International Symposium on Programming Language Implementation and Logic Programming
Compiling Constraint Handling Rules into Prolog with Attributed Variables
PPDP '99 Proceedings of the International Conference PPDP'99 on Principles and Practice of Declarative Programming
Automatic detection and repair of errors in data structures
OOPSLA '03 Proceedings of the 18th annual ACM SIGPLAN conference on Object-oriented programing, systems, languages, and applications
ReactiveML: a reactive extension to ML
PPDP '05 Proceedings of the 7th ACM SIGPLAN international conference on Principles and practice of declarative programming
An experimental analysis of self-adjusting computation
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
An Introduction to Design Patterns in C++ with Qt 4 (Bruce Perens Open Source)
An Introduction to Design Patterns in C++ with Qt 4 (Bruce Perens Open Source)
Programming finite-domain constraint propagators in Action Rules
Theory and Practice of Logic Programming
Principles of Constraint Programming
Principles of Constraint Programming
Self-adjusting computation: (an overview)
Proceedings of the 2009 ACM SIGPLAN workshop on Partial evaluation and program manipulation
Transactional memory with strong atomicity using off-the-shelf memory protection hardware
Proceedings of the 14th ACM SIGPLAN symposium on Principles and practice of parallel programming
CEAL: a C-based language for self-adjusting computation
Proceedings of the 2009 ACM SIGPLAN conference on Programming language design and implementation
Flapjax: a programming language for Ajax applications
Proceedings of the 24th ACM SIGPLAN conference on Object oriented programming systems languages and applications
A Case for Automated Debugging Using Data Structure Repair
ASE '09 Proceedings of the 2009 IEEE/ACM International Conference on Automated Software Engineering
Traceable data types for self-adjusting computation
PLDI '10 Proceedings of the 2010 ACM SIGPLAN conference on Programming language design and implementation
Crossing state lines: adapting object-oriented frameworks to functional reactive languages
FLOPS'06 Proceedings of the 8th international conference on Functional and Logic Programming
Embedding dynamic dataflow in a call-by-value language
ESOP'06 Proceedings of the 15th European conference on Programming Languages and Systems
Elixir: a system for synthesizing concurrent graph programs
Proceedings of the ACM international conference on Object oriented programming systems languages and applications
Reactive behavior in object-oriented applications: an analysis and a research roadmap
Proceedings of the 12th annual international conference on Aspect-oriented software development
Hi-index | 0.00 |
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 we propose a novel approach that smoothly combines the two paradigms without placing undue burden on the programmer. In our framework, programmers can define ordinary statements of the imperative host language that enforce constraints between objects stored in special memory locations designated as "reactive". Differently from previous approaches, reactive objects can be of any legal type in the host language, including primitive data types, pointers, arrays, and structures. Statements defining constraints are automatically re-executed every time their input memory locations change, letting a program behave like a spreadsheet where the values of some variables depend upon the values of other variables. The constraint solving mechanism is handled transparently by altering the semantics of elementary operations of the host language for reading and modifying objects. We provide a formal semantics and describe a concrete embodiment of our technique into C/C++, showing how to implement it efficiently in conventional platforms using off-the-shelf compilers. We discuss common coding idioms and relevant applications to reactive scenarios, including incremental computation, observer design pattern, and data structure repair. The performance of our implementation is compared to ad hoc problem-specific change propagation algorithms, as well as to language-centric approaches such as self-adjusting computation and subject/observer communication mechanisms, showing that the proposed approach is efficient in practice.