Distributed functional reactive programming on actor-based runtime

  title={Distributed functional reactive programming on actor-based runtime},
  author={Kazuhiro Shibanai and Takuo Watanabe},
  journal={Proceedings of the 8th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control},
  • Kazuhiro Shibanai, Takuo Watanabe
  • Published 5 November 2018
  • Computer Science
  • Proceedings of the 8th ACM SIGPLAN International Workshop on Programming Based on Actors, Agents, and Decentralized Control
Reactive programming over a network is a challenging task because efficient elimination of temporary violations of data flow invariants, known as glitches, in a distributed setting is still an open issue. In this paper, we propose a method for constructing a distributed reactive programming system of which runtime guarantees the properties of single source glitch-freedom and the robustness against out-of-order messages. Based on the method, we developed a purely functional reactive programming… 
Trampoline variables: a general method for state accumulation in reactive programming
This paper introduces trampoline variables, a new general mechanism that allows reactive programs to manipulate state explicitly without resorting to imperative programming and shows that it is at least as powerful as existing built-in reactive operators.
Topology-Level Reactivity in Distributed Reactive Programs: Reactive Acquaintance Management using Flocks
This paper designs an acquaintance discovery mechanism to create a flock that automatically discovers prosumers on the network and design an acquaintance maintenance mechanism: a new type of operator for functional reactive programming languages that is called “deploy-*”, which enables correct and efficient reactions to time-varying collections of discovered prosumers.
Poker: visual instrumentation of reactive programs with programmable probes
The paper uses an application written in Stella to motivate the concepts provided by Poker, a visual instrumentation platform for reactive programs that features a canvas of so-called probes that can be dynamically wired into a running reactive program in order to instrument the running system.
Hailstorm: A Statically-Typed, Purely Functional Language for IoT Applications
Hailstorm is a high-level programming language with a strict typing discipline, that supports features like higher-order functions, tail-recursion, and automatic memory management, to program IoT devices in a declarative manner.
Asynchronous monad for reactive IoT programming
This paper proposes a push-pull reactive programming model for IoT application that uses push-streams for asynchronous computation such as data capturing and user controls and uses pull streams for synchronized computationsuch as data analysis.
Method for Organizing Network Requests in iOS Applications
A project to develop a method that provides an advantage to the developer in three areas to improve the usability of developing iOS applications and to reduce labor costs when developing and finalizing iOS applications.
Towards a Reactive Game Engine
This research presents a reactive, dependency-based framework for game engines using associations between components to establish the order in which they update using an existing reactive programming framework.
Smoothly Navigating between Functional Reactive Programming and Actors
We formally define an elegant multi-paradigm unification of Functional Reactive Programming, Actor Systems, and Object-Oriented Programming. This enables an intuitive form of declarative programming,
Efficient reordering and replay of execution traces of distributed reactive systems in the context of model-driven development
The experimental results show that compared to reordering based on logical timestamps using vector time (clocks), the approach reduces the size of the trace information collected by more than half while incurring similar runtime overhead.
Towards a statically scheduled parallel execution of an FRP language for embedded systems
The proposed method is based on a static scheduling algorithm and should run with a simple RTOS or without the help of operating systems, and some preliminary evaluation results using Linux-based systems demonstrate the effectiveness of the method.


Handling partial failures in distributed reactive programming
This paper introduces the novel concept of leased signals which allow both programmer and runtime to react to partial failures in distributed reactive applications and implements leased signals in a distributed reactive TypeScript framework for the development of microservice applications.
On the Semantics of Distributed Reactive Programming: The Cost of Consistency
It is shown that different applications require different levels of consistency and that manually implementing the required level on a middleware that provides a lower one annuls the abstraction improvements of reactive programming.
We have a DREAM: distributed reactive programming with consistency guarantees
This paper introduces three propagation semantics, namely causal, glitch free, and atomic, providing different trade-offs between costs and guarantees and describes how these semantics are concretely implemented in a Distributed REActice Middleware (DREAM), which exploits a distributed event-based dispatching system to propagate changes.
Distributed REScala: an update algorithm for distributed reactive programming
Distributed REScala is proposed, a reactive language with a change propagation algorithm that works without centralized knowledge about the topology of the dependency structure among reactive values and avoids unnecessary propagation of changes, while retaining safety guarantees (glitch freedom).
Fault-tolerant Distributed Reactive Programming
This paper's solution automatically stores and recovers program state to handle crashes, automatically updates and shares distributed parts of the state to provide eventual consistency, and handles errors in a fine-grained manner to allow precise manual control when necessary.
Towards Advanced Debugging Support for Actor Languages Studying Concurrency Bugs in Actor-based Programs
This paper presents initial work on a taxonomy of concurrent bugs for actor-based applications, and proposes debugging tooling to assist the development process of actor- based applications.
Deprecating the Observer Pattern with Scala.React
This work shows how to integrate different reactive programming abstractions into a single framework that help migrate from observer-based event handling logic to more declarative implementations.
Emfrp: a functional reactive programming language for small-scale embedded systems
A new functional reactive programming (FRP) language Emfrp designed to support small-scale embedded systems and provides simplicity and flexibility for describing complex time-dependent reactive behaviors without space and time leaks.
A survey on reactive programming
This survey describes and provides a taxonomy of existing reactive programming approaches along six axes: representation of time-varying values, evaluation model, lifting operations, multidirectionality, glitch avoidance, and support for distribution.
Deprecating the Observer Pattern with Scala
This work shows how to integrate different reactive programming abstractions into a single framework that help migrate from observer-based event handling logic to more declarative implementations.