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

5th ACM SIGPLAN International Workshop on Reactive and Event-Based Languages and Systems (REBLS 2018), November 4, 2018, Boston, MA, USA

REBLS 2018 – Proceedings

Contents - Abstracts - Authors

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

Frontmatter

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 HPC technology and the ever increasing requirement for our applications to run on the web or on collaborating mobile devices. A number of publications on middleware and language design — so-called reactive and event-based languages and systems (REBLS) — 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.

Embedded Systems and IoT

Synthesizing Manually Verifiable Code for Statecharts
Steven Smyth, Christian Motika, and Reinhard von Hanxleden
(University of Kiel, Germany; Philotech Systementwicklung und Software, Germany)
Statecharts are an established mechanism to model reactive, state-oriented behavior of embedded systems. We here present an approach to automatically generate code from statecharts, with a particular focus on readability and ease of matching the generated code with the original model. This not only saves programming effort and reduces the error rate compared to manual coding, but it also facilitates the task of verifying that the code does what it is supposed to do. We have implemented this approach for the SCCharts language in an open-source framework. A user study confirmed that the generated code tends to be more readable than code from other code generators.

Publisher's Version
RHEA: A Reactive, Heterogeneous, Extensible, and Abstract Framework for Dataflow Programming
Orestis Melkonian and Angelos Charalambidis
(NCSR, Greece; Utrecht University, Netherlands)
Robotics and IoT applications are perfect candidates that can benefit from the functional reactive programming paradigm. Moreover, since a typical program can be represented as a dataflow graph, the application can be conceptually separated and distributed in different machines and the several graph partitions can run in parallel and possibly in different execution stacks. In this paper we propose a general-purpose reactive framework that can express complex applications, seamlessly and transparently integrating different sources and middlewares. The framework is abstract and extensible, making it easy to integrate with well-established technologies that rely on the PubSub model. We demonstrate the usability of the framework by providing application examples in the domain of robotics and IoT.

Publisher's Version

Multitier and Distributed Computing

Reactive Chatbot Programming
Guillaume Baudart, Martin Hirzel, Louis Mandel, Avraham Shinnar, and Jérôme Siméon
(IBM Research, USA; Clause, USA)
Chatbots are reactive applications with a conversational interface. They are usually implemented as compositions of client-side components and cloud-hosted services, including artificial-intelligence technology. Unfortunately, programming such reactive multi-tier applications with traditional programming languages is cumbersome. This paper introduces wcs-ocaml, a new multi-tier chatbot generator library designed for use with the reactive language ReactiveML. The paper explains our library with small didactic examples throughout, and closes with a larger case-study of a chatbot for authoring event-processing rules.

Publisher's Version
DISCOPAR: A Visual Reactive Programming Language for Generating Cloud-Based Participatory Sensing Platforms
Jesse Zaman, Kennedy Kambona, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
Participatory sensing (PS) platforms enable stakeholders to collect, analyse and visualise data for a particular interest. Despite high societal demand, developing a new PS platform remains a labour-intensive, nonreusable process that requires high technical expertise. We present DISCOPAR, a visual reactive flow-based domain-specific language geared towards the construction of reusable citizen observatories. With DISCOPAR, users interact with visual components to implement the various elements of a PS platforms without having to worry about its underlying technological complexities. We validate our approach through experiments using real-world empirical usability studies of ICT-agnostic users. The results show that DISCOPAR allows users with limited technological knowledge to create their own PS platform.

Publisher's Version
Skitter: A DSL for Distributed Reactive Workflows
Mathijs Saey, Joeri De Koster, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
Writing real-time applications that react to vast amounts of incoming data is a hard problem, as the volume of incoming data implies the need for distributed execution on a cluster architecture. We envision such an application can be created as a data processing pipeline which consists of a set of generic, reactive components, which may be reused in other applications. However, there is currently no programming model or framework that enables the reactive, scalable execution of such a pipeline on a cluster architecture. Our work introduces the notion of reactive workflows, a technique that combines concepts from scientific workflows and reactive programming. Reactive workflows enable the integration of these generic components into a single workflow that can be executed on a cluster architecture in a reactive, scalable way. To deploy these reactive workflows, we introduce a domain specific language, called Skitter. Skitter enables developers to write reactive components and compose these into reactive workflows, which can be distributed over a cluster by Skitter’s runtime system.

Publisher's Version

Visualization, Debugging, and Programming Techniques

Composable Higher-Order Reactors as the Basis for a Live Reactive Programming Environment
Bjarno Oeyen, Humberto Rodriguez Avila, Sam Van den Vonder, and Wolfgang De Meuter
(Vrije Universiteit Brussel, Belgium)
A live programming environment allows programmers to edit programs while they are running. This means that successive "edit steps" must not allow a programmer to bring the program in a form that does not make any sense to the underlying language processor (i.e., parser, compiler,...). Many live programming environments therefore rely on disciplined edit steps that are based on language elements such as objects, classes, and methods. Textual modifications to these elements are not seen as edit steps until some "accept" button is hit. Unfortunately, no such elements exist in current reactive languages. We present a new reactive language, called Haai, that is based on first-class higher-order reactors. Linguistically, Haai programs correspond to reactors or compositions of reactors. At run-time, reactors produce an infinite stream of values just like signals and behaviours in existing languages. Haai's live programming environment relies on textual modifications of entire reactors as its basic edit steps. Changing a reactor automatically updates all occurrences of that reactor in the reactive program, while it is running.

Publisher's Version
A Reactive Language for Analyzing Cloud Logs
Guillaume Baudart, Louis Mandel, Olivier Tardieu, and Mandana Vaziri
(IBM Research, USA)
Log analysis is required in many domains, and especially in the emerging field of cloud computing. Cloud applications are often built by composing diverse services. When something goes wrong, finding the root cause of the problem can be difficult. Many services are only reachable through their Application Programming Interfaces (APIs) with no possibility for live introspection. In this context, logs become an essential tool for monitoring and debugging. Cloud services typically generate very large quantities of log messages, with formats that may not be well specified and may vary over time. In this paper, we present CloudLens, a language for the analysis of semi-structured textual data as found in logs, and specify its formal semantics. CloudLens is a reactive language and views logs as streams of objects. Our objective is to facilitate exploring the contents of logs interactively and to write reusable analyses succinctly, using familiar constructs. We implemented an interpreter for the Apache Zeppelin notebook to provide an interactive IDE. Our prototype implementation is open source and we report on a detailed case study using logs from the Apache OpenWhisk project.

Publisher's Version

proc time: 0.71