Reactive behavior in object-oriented applications

Salvaneschi, Guido; Mezini, Mira

doi:10.1145/2451436.2451442

Cited by 19 publications

(15 citation statements)

References 43 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Often, a program needs to update its output efficiently to reflect input changes [23]. Instead of rerunning such a program from scratch on its updated input, incremental computation research looks for alternatives that are cheaper in a common scenario: namely, when the input change is much smaller than the input itself.…”

Section: Introductionmentioning

confidence: 99%

A theory of changes for higher-order languages

Cai

Giarrusso

Rendel

et al. 2014

Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

If the result of an expensive computation is invalidated by a small change to the input, the old result should be updated incrementally instead of reexecuting the whole computation. We incrementalize programs through their derivative. A derivative maps changes in the program's input directly to changes in the program's output, without reexecuting the original program. We present a program transformation taking programs to their derivatives, which is fully static and automatic, supports first-class functions, and produces derivatives amenable to standard optimization.We prove the program transformation correct in Agda for a family of simply-typed λ-calculi, parameterized by base types and primitives. A precise interface specifies what is required to incrementalize the chosen primitives.We investigate performance by a case study: We implement in Scala the program transformation, a plugin and improve performance of a nontrivial program by orders of magnitude.

show abstract

Section: Introductionmentioning

confidence: 99%

A theory of changes for higher-order languages

Cai

Giarrusso

Rendel

et al. 2014

Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

show abstract

“…Triggering an event in every point in the code where a variable on which other variables depend on is updated leads to code scatter- ing and tangling [32]. In addition, new events cannot be introduced transparently by clients: the original codebase must be modified by converting fields into observables and by adding event triggering.…”

Section: Event-based Languagesmentioning

confidence: 99%

REScala

Salvaneschi

Hintz

Mezini

2014

Proceedings of the 13th International Conference on Modularity

Self Cite

View full text Add to dashboard Cite

Traditionally, object-oriented software adopts the Observer pattern to implement reactive behavior. Its drawbacks are well-documented and two families of alternative approaches have been proposed, extending object-oriented languages with concepts from functional reactive and dataflow programming, respectively event-driven programming. The former hardly escape the functional setting; the latter do not achieve the declarativeness of more functional approaches.In this paper, we present RESCALA, a reactive language which integrates concepts from event-based and functional-reactive programming into the object-oriented world. RESCALA supports the development of reactive applications by fostering a functional declarative style which complements the advantages of objectoriented design.

show abstract

“…An automated detection of the impacts on relation among methods is undecidable in the general case [37]. DREAM solves this problem by asking the programmer to make this Listing 1 shows the definition of a simple Observable class: ObservableInteger.…”

Section: Observable Objectsmentioning

confidence: 99%

“…Similarly, the integration of reactive and object-oriented programming have been discussed in [37]. In future work, we plan to explore this integration in more detail, focusing on solutions for automated tracking of dependencies, better support for inheritance, and efficient strategies for recomputation of values.…”

Section: Related Workmentioning

confidence: 99%

We have a DREAM

Margara

Salvaneschi

2014

Proceedings of the 8th ACM International Conference on Distributed Event-Based Systems

Self Cite

View full text Add to dashboard Cite

The reactive programming paradigm has been proposed to simplify the development of reactive systems. It relies on programming primitives to express dependencies between data items and on runtime/middleware support for automated propagation of changes. Despite this paradigm is receiving increasing attention, defining the precise semantics and the consistency guarantees for reactive programming in distributed environments is an open research problem.This paper targets such problem by studying the consistency guarantees for the propagation of changes in a distributed reactive system. In particular, it introduces three propagation semantics, namely causal, glitch free, and atomic, providing different trade-offs between costs and guarantees. Furthermore, it describes how these semantics are concretely implemented in a Distributed REActice Middleware (DREAM), which exploits a distributed event-based dispatching system to propagate changes.We compare the performance of DREAM in a wide range of scenarios. This allows us to study the overhead introduced by the different semantics in terms of network traffic and propagation delay and to assess the efficiency of DREAM in supporting distributed reactive systems.

show abstract

Reactive behavior in object-oriented applications

Cited by 19 publications

References 43 publications

A theory of changes for higher-order languages

A theory of changes for higher-order languages

REScala

We have a DREAM

Contact Info

Product

Resources

About