SPLASH Workshops 2017
2017 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for Humanity (SPLASH Workshops 2017)
Powered by
Conference Publishing Consulting

4th ACM SIGPLAN International Workshop on Reactive and Event-Based Languages and Systems (REBLS 2017), October 23, 2017, Vancouver, BC, Canada

REBLS 2017 – Proceedings

Contents - Abstracts - Authors

4th ACM SIGPLAN International Workshop on Reactive and Event-Based Languages and Systems (REBLS 2017)


Title Page

Message from the Chairs
Reactive programming and event-based programming are two closely related programming styles that are becoming ever more important with the advent of advanced HCI technology and the ever increasing requirement for applications to run on the web or on collaborating mobile devices. A number of publications about middleware and language design - so-called reactive and event-based languages and systems - have already seen the light, but the field still raises several questions. For example, the interaction with mainstream language concepts is poorly understood, implementation technology is in its infancy and modularity mechanisms are almost totally lacking. Moreover, large applications are still to be developed and patterns and tools for developing reactive applications is an area that is vastly unexplored. This workshop gathers researchers in reactive and event-based languages and systems. The goal of the workshop is to exchange new technical research results and to define better the field by coming up with taxonomies and overviews of the existing work. We aim to create better cohesion in the community working on reactive and event-based programming, propose new solutions and come up with a clearer understanding of the boundaries of the field. We plan to discuss and exchange ideas about the fundamental paradigmatic problems that still need to be solved in order to reconcile reactive technologies with mainstream paradigms.


Handling Partial Failures in Distributed Reactive Programming
Florian Myter, Christophe Scholliers, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium; Ghent University, Belgium)
Distributed reactive programming enables programmers to reuse the abstractions provided by reactive programming to elegantly implement distributed systems. However, distributed reactive approaches have thus far neglected to address an inherent property of distributed systems: partial failures. This forces programmers to either disregard failures and write poor distributed code or try to detect failures manually (e.g. through time-outs and heartbeats). Moreover, this prohibits distributed reactive runtimes to garbage collect remote references to failed parts of the reactive network. In this paper we present a first attempt at failure handling for distributed reactive applications. To this end we introduce the novel concept of leased signals which allow both programmer and runtime to react to partial failures in distributed reactive applications. We implement leased signals in a distributed reactive TypeScript framework for the development of microservice applications.
Publisher's Version Article Search
A DSL for Compensable and Interruptible Executions
Hiroaki Inoue, Tomoyuki Aotani, and Atsushi Igarashi
(Kyoto University, Japan; Tokyo Institute of Technology, Japan)

Context-awareness is getting more and more important in software applications. Such an application runs depending on the time-varying status of the surrounding environment such as network connection, battery/energy charge and heat. Interruptions, or asynchronous exceptions, are useful to achieve context-awareness: if the environment changes, the execution of the application is interrupted reactively to stop and/or recover the internal state for adapting to the new environment. It is, however, difficult to program with interruptions modularly in most programming languages because their support is too basic and is based on synchronous exception handling mechanism such as trycatch.

We propose a domain-specific language ContextWorkflow for modular interruptible programs as a solution to the problem. An interruptible program is basically a workflow, i.e., a sequence of atomic computations with compensations. The uniqueness of ContextWorkflow is that, during its execution, a workflow watches the context, which is represented as a reactive value in functional reactive programming and instructs how the execution reflects the status of the surrounding environment.

Publisher's Version Article Search
FRP IoT Modules as a Scala DSL
Ben Calus, Bob Reynders, Dominique Devriese, Job Noorman, and Frank Piessens
(KU Leuven, Belgium)
With Internet of Things applications growing in size and popularity, physical sensor networks are more often running multiple complex applications. It becomes increasingly important to maintain these event-driven programs on embedded systems. Traditionally, event-driven applications such as sensor network applications are written using an imperative style of programming where different callback routines are registered to handle events. As the application complexity grows, the inverted control flow and reliance on shared global state makes this style of programming hard to maintain. Furthermore, sensor network applications are inherently distributed and are written by manually managing code-bases of sub-applications that go on all nodes separately. If security is important, the programmer needs to manually interface with low-level security primitives because there is no built-in notion of components. We propose a more maintainable approach where the developer essentially writes a first-order FRP program, containing code fragments in an embedded subset of C. From this FRP program, we generate efficient C code to be run on every node. Every module of the FRP program is compiled to a separate C module, making it easy to deploy modules to different nodes, and to enhance the security of the application by isolating modules from other software running on the nodes. Our implementation is based on a Scala EDSL that we use to let the user conveniently embed fragments of C code. The annotated C code gets compiled to Sancus, a security architecture for IoT nodes that supports the secure and distributed execution of the generated modules.
Publisher's Version Article Search
First-Class Reactive Programs for CPS
Christophe De Troyer, Jens Nicolay, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
Cyber-Physical Systems (CPS) are comprised of a network of devices that vary widely in complexity, ranging from simple sensors to autonomous robots. Traditionally, controlling and sensing these devices happens through API communication, in either push or pull-based fashion. We argue that the computational power of these devices is converging to the point where they can do autonomous computations. This allows application programmers to run programs locally on the sensors, thereby reducing the communication and workload of more central command and control entities. This work introduces the Potato framework that aims to make programming CPS systems intuitively easy and fast. Potato is based on three essential mechanisms: failure handling by means of leasing, distribution by means of first-class reactive programs, and intentional retroactive designation of the network by means of capabilities and dynamic properties. In this paper we focus on the reactive capabilities of our framework. Potato enables programmers to create and deploy first-class reactive programs on CPS devices at run time, abstracting away from the API approach. Each node in the network is equipped with a minimal actor-based middleware that can execute first-class reactive programs. We have implemented Potato as a library in Elixir and have used it to implement several small examples.
Publisher's Version Article Search
Tackling the Awkward Squad for Reactive Programming: The Actor-Reactor Model
Sam Van den Vonder, Joeri De Koster, Florian Myter, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
In his famous paper entitled "Tackling the Awkward Squad", Peyton Jones studies how features that traditionally did not fit in the functional programming paradigm can be added to a functional language via careful language design (e.g. using monads), instead of allowing programmers to sprinkle around impure expressions and ad-hoc library calls, thereby turning the entire program into a non-functional program. Similarly, in this paper, we identify a number of code characteristics that do not map onto the reactive programming paradigm but that are present in many real life reactive programs. We propose a novel Actor-Reactor model that can serve as the basis for future language designs that allow a programmer to use the awkward squad without making the reactive parts of the program accidentally non-reactive.
Publisher's Version Article Search

proc time: 0.02