Coherent reaction

Side effects are both the essence and bane of imperative programming. The programmer must carefully coordinate actions to manage their side effects upon each other. Such coordination is complex, error-prone, and fragile. Coherent reaction is a new model of change-driven computation that coordinates effects automatically. State changes trigger events called reactions that in turn change other states. A coherent execution order is one in which each reaction executes before any others that are affected by its changes. A coherent order is discovered iteratively by detecting incoherencies as they occur and backtracking their effects. Unlike alternative solutions, much of the power of imperative programming is retained, as is the common sense notion of mutable state. Automatically coordinating actions lets the programmer express what to do, not when to do it. Coherent reactions are embodied in the Coherence language, which is specialized for interactive applications like those common on the desktop and web. The fundamental building block of Coherence is the dynamically typed mutable tree. The fundamental abstraction mechanism is the virtual tree, whose value is lazily computed, and whose behavior is generated by coherent reactions.

[1]  Benjamin C. Pierce,et al.  Combinators for bi-directional tree transformations: a linguistic approach to the view update problem , 2005, POPL '05.

[2]  Shriram Krishnamurthi,et al.  Embedding Dynamic Dataflow in a Call-by-Value Language , 2006, ESOP.

[3]  David Harel,et al.  Statecharts: A Visual Formalism for Complex Systems , 1987, Sci. Comput. Program..

[4]  George T. Heineman,et al.  An Instance-Oriented Approach to Constructing Product Lines from Layers , 2005 .

[5]  A. Taivalsaari,et al.  Prototype-Based Object-Oriented Programming: Concepts, Languages, and Applications , 2001 .

[6]  John Field,et al.  Reactors: A data-oriented synchronous/asynchronous programming model for distributed applications , 2007, Theor. Comput. Sci..

[7]  Lambert Meertens,et al.  Designing Constraint Maintainers for User Interaction , 1998 .

[8]  Alan C. Kay The early history of Smalltalk , 1993, HOPL-II.

[9]  Wilson C. Hsieh,et al.  SuperGlue: Component Programming with Object-Oriented Signals , 2006, ECOOP.

[10]  Stephen L. Burbeck,et al.  Applications programming in smalltalk-80: how to use model-view-controller (mvc) , 1987 .

[11]  Gérard Berry,et al.  The Esterel Synchronous Programming Language: Design, Semantics, Implementation , 1992, Sci. Comput. Program..

[12]  Paul Hudak,et al.  Functional reactive animation , 1997, ICFP '97.

[13]  Jonathan Edwards Modular Generation and Customization , 2008 .

[14]  Jennifer Widom,et al.  Database Systems: The Complete Book , 2001 .

[15]  Nicolas Spyratos,et al.  Update semantics of relational views , 1981, TODS.

[16]  Brad A. Myers,et al.  The P rototype-Instance Object Systems in Amulet and Garnet , 1998 .

[17]  Benjamin C. Pierce,et al.  Relational lenses: a language for updatable views , 2006, PODS '06.

[18]  Jonathan Edwards,et al.  First Class Copy & Paste , 2006 .

[19]  Adam Nathan,et al.  Windows Presentation Foundation Unleashed , 2006 .

[20]  John Freeman,et al.  Property models: from incidental algorithms to reusable components , 2008, GPCE '08.

[21]  Philip Wadler,et al.  Monads for functional programming , 1995, NATO ASI PDC.

[22]  Paul Hudak,et al.  Arrows, Robots, and Functional Reactive Programming , 2002, Advanced Functional Programming.

[23]  Amir Pnueli,et al.  On the Development of Reactive Systems , 1989, Logics and Models of Concurrent Systems.

[24]  Jack B. Dennis,et al.  First version of a data flow procedure language , 1974, Symposium on Programming.

[25]  John Hughes,et al.  Why Functional Programming Matters , 1989, Comput. J..

[26]  Gottfried Vossen,et al.  Transactional Information Systems: Theory, Algorithms, and the Practice of Concurrency Control and Recovery , 2002 .

[27]  Jonathan Edwards,et al.  Subtext: uncovering the simplicity of programming , 2005, OOPSLA '05.

[28]  M N Wegman What it's like to be a POPL referee; or how to write an extended abstract so that it is more likely to be accepted , 1986, SIGP.

[29]  Nicolas Halbwachs,et al.  LUSTRE: A declarative language for programming synchronous systems* , 1987 .

[30]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[31]  Stephen J. Mellor,et al.  Executable UML - A Foundation for Model-Driven Architecture , 2002, Addison Wesley object technology series.

[32]  Stephen Travis Pope,et al.  A cookbook for using the model-view controller user interface paradigm in Smalltalk-80 , 1988 .

[33]  David P. Reed,et al.  Implementing atomic actions on decentralized data , 1983, TOCS.

[34]  Terence John Parr,et al.  Enforcing strict model-view separation in template engines , 2004, WWW '04.

[35]  P Black Andrew,et al.  Timber: A Programming Language for Real-Time Embedded Systems , 2002 .

[36]  Umeshwar Dayal,et al.  On the correct translation of update operations on relational views , 1982, TODS.

[37]  Nicolas Halbwachs,et al.  LUSTRE: a declarative language for real-time programming , 1987, POPL '87.

[38]  Andy Hunt Pragmatic Thinking and Learning: Refactor Your Wetware (Pragmatic Programmers) , 2008 .

[39]  Antero Taivalsaari,et al.  Prototype-based programming : concepts, languages, and applications , 1999 .

[40]  Frederick P. Brooks,et al.  No Silver Bullet: Essence and Accidents of Software Engineering , 1987 .

[41]  Gul A. Agha,et al.  ACTORS - a model of concurrent computation in distributed systems , 1985, MIT Press series in artificial intelligence.

[42]  Paul Hudak,et al.  Conception, evolution, and application of functional programming languages , 1989, CSUR.