REBLS '18: "Reactive Chatbot Programming ..."
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.
@InProceedings{REBLS18p21,
author = {Guillaume Baudart and Martin Hirzel and Louis Mandel and Avraham Shinnar and Jérôme Siméon},
title = {Reactive Chatbot Programming},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {21--30},
doi = {10.1145/3281278.3281282},
year = {2018},
}
Publisher's Version
REBLS '18: "A Reactive Language for Analyzing ..."
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.
@InProceedings{REBLS18p61,
author = {Guillaume Baudart and Louis Mandel and Olivier Tardieu and Mandana Vaziri},
title = {A Reactive Language for Analyzing Cloud Logs},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {61--70},
doi = {10.1145/3281278.3281280},
year = {2018},
}
Publisher's Version
REBLS '18: "RHEA: A Reactive, Heterogeneous, ..."
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.
@InProceedings{REBLS18p11,
author = {Orestis Melkonian and Angelos Charalambidis},
title = {RHEA: A Reactive, Heterogeneous, Extensible, and Abstract Framework for Dataflow Programming},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {11--20},
doi = {10.1145/3281278.3281279},
year = {2018},
}
Publisher's Version
REBLS '18: "Skitter: A DSL for Distributed ..."
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.
@InProceedings{REBLS18p41,
author = {Mathijs Saey and Joeri De Koster and Wolfgang De Meuter},
title = {Skitter: A DSL for Distributed Reactive Workflows},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {41--50},
doi = {10.1145/3281278.3281281},
year = {2018},
}
Publisher's Version
REBLS '18: "DISCOPAR: A Visual Reactive ..."
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.
@InProceedings{REBLS18p31,
author = {Jesse Zaman and Kennedy Kambona and Wolfgang De Meuter},
title = {DISCOPAR: A Visual Reactive Programming Language for Generating Cloud-Based Participatory Sensing Platforms},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {31--40},
doi = {10.1145/3281278.3281285},
year = {2018},
}
Publisher's Version
REBLS '18: "Skitter: A DSL for Distributed ..."
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.
@InProceedings{REBLS18p41,
author = {Mathijs Saey and Joeri De Koster and Wolfgang De Meuter},
title = {Skitter: A DSL for Distributed Reactive Workflows},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {41--50},
doi = {10.1145/3281278.3281281},
year = {2018},
}
Publisher's Version
REBLS '18: "Composable Higher-Order Reactors ..."
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.
@InProceedings{REBLS18p51,
author = {Bjarno Oeyen and Humberto Rodriguez Avila and Sam Van den Vonder and Wolfgang De Meuter},
title = {Composable Higher-Order Reactors as the Basis for a Live Reactive Programming Environment},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {51--60},
doi = {10.1145/3281278.3281284},
year = {2018},
}
Publisher's Version
REBLS '18: "Reactive Chatbot Programming ..."
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.
@InProceedings{REBLS18p21,
author = {Guillaume Baudart and Martin Hirzel and Louis Mandel and Avraham Shinnar and Jérôme Siméon},
title = {Reactive Chatbot Programming},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {21--30},
doi = {10.1145/3281278.3281282},
year = {2018},
}
Publisher's Version
REBLS '18: "DISCOPAR: A Visual Reactive ..."
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.
@InProceedings{REBLS18p31,
author = {Jesse Zaman and Kennedy Kambona and Wolfgang De Meuter},
title = {DISCOPAR: A Visual Reactive Programming Language for Generating Cloud-Based Participatory Sensing Platforms},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {31--40},
doi = {10.1145/3281278.3281285},
year = {2018},
}
Publisher's Version
REBLS '18: "Reactive Chatbot Programming ..."
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.
@InProceedings{REBLS18p21,
author = {Guillaume Baudart and Martin Hirzel and Louis Mandel and Avraham Shinnar and Jérôme Siméon},
title = {Reactive Chatbot Programming},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {21--30},
doi = {10.1145/3281278.3281282},
year = {2018},
}
Publisher's Version
REBLS '18: "A Reactive Language for Analyzing ..."
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.
@InProceedings{REBLS18p61,
author = {Guillaume Baudart and Louis Mandel and Olivier Tardieu and Mandana Vaziri},
title = {A Reactive Language for Analyzing Cloud Logs},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {61--70},
doi = {10.1145/3281278.3281280},
year = {2018},
}
Publisher's Version
REBLS '18: "RHEA: A Reactive, Heterogeneous, ..."
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.
@InProceedings{REBLS18p11,
author = {Orestis Melkonian and Angelos Charalambidis},
title = {RHEA: A Reactive, Heterogeneous, Extensible, and Abstract Framework for Dataflow Programming},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {11--20},
doi = {10.1145/3281278.3281279},
year = {2018},
}
Publisher's Version
REBLS '18: "Synthesizing Manually Verifiable ..."
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.
@InProceedings{REBLS18p1,
author = {Steven Smyth and Christian Motika and Reinhard von Hanxleden},
title = {Synthesizing Manually Verifiable Code for Statecharts},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {1--10},
doi = {10.1145/3281278.3281283},
year = {2018},
}
Publisher's Version
REBLS '18: "Composable Higher-Order Reactors ..."
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.
@InProceedings{REBLS18p51,
author = {Bjarno Oeyen and Humberto Rodriguez Avila and Sam Van den Vonder and Wolfgang De Meuter},
title = {Composable Higher-Order Reactors as the Basis for a Live Reactive Programming Environment},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {51--60},
doi = {10.1145/3281278.3281284},
year = {2018},
}
Publisher's Version
REBLS '18: "Composable Higher-Order Reactors ..."
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.
@InProceedings{REBLS18p51,
author = {Bjarno Oeyen and Humberto Rodriguez Avila and Sam Van den Vonder and Wolfgang De Meuter},
title = {Composable Higher-Order Reactors as the Basis for a Live Reactive Programming Environment},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {51--60},
doi = {10.1145/3281278.3281284},
year = {2018},
}
Publisher's Version
REBLS '18: "Skitter: A DSL for Distributed ..."
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.
@InProceedings{REBLS18p41,
author = {Mathijs Saey and Joeri De Koster and Wolfgang De Meuter},
title = {Skitter: A DSL for Distributed Reactive Workflows},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {41--50},
doi = {10.1145/3281278.3281281},
year = {2018},
}
Publisher's Version
REBLS '18: "Reactive Chatbot Programming ..."
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.
@InProceedings{REBLS18p21,
author = {Guillaume Baudart and Martin Hirzel and Louis Mandel and Avraham Shinnar and Jérôme Siméon},
title = {Reactive Chatbot Programming},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {21--30},
doi = {10.1145/3281278.3281282},
year = {2018},
}
Publisher's Version
REBLS '18: "Reactive Chatbot Programming ..."
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.
@InProceedings{REBLS18p21,
author = {Guillaume Baudart and Martin Hirzel and Louis Mandel and Avraham Shinnar and Jérôme Siméon},
title = {Reactive Chatbot Programming},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {21--30},
doi = {10.1145/3281278.3281282},
year = {2018},
}
Publisher's Version
REBLS '18: "Synthesizing Manually Verifiable ..."
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.
@InProceedings{REBLS18p1,
author = {Steven Smyth and Christian Motika and Reinhard von Hanxleden},
title = {Synthesizing Manually Verifiable Code for Statecharts},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {1--10},
doi = {10.1145/3281278.3281283},
year = {2018},
}
Publisher's Version
REBLS '18: "A Reactive Language for Analyzing ..."
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.
@InProceedings{REBLS18p61,
author = {Guillaume Baudart and Louis Mandel and Olivier Tardieu and Mandana Vaziri},
title = {A Reactive Language for Analyzing Cloud Logs},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {61--70},
doi = {10.1145/3281278.3281280},
year = {2018},
}
Publisher's Version
REBLS '18: "Composable Higher-Order Reactors ..."
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.
@InProceedings{REBLS18p51,
author = {Bjarno Oeyen and Humberto Rodriguez Avila and Sam Van den Vonder and Wolfgang De Meuter},
title = {Composable Higher-Order Reactors as the Basis for a Live Reactive Programming Environment},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {51--60},
doi = {10.1145/3281278.3281284},
year = {2018},
}
Publisher's Version
REBLS '18: "A Reactive Language for Analyzing ..."
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.
@InProceedings{REBLS18p61,
author = {Guillaume Baudart and Louis Mandel and Olivier Tardieu and Mandana Vaziri},
title = {A Reactive Language for Analyzing Cloud Logs},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {61--70},
doi = {10.1145/3281278.3281280},
year = {2018},
}
Publisher's Version
REBLS '18: "Synthesizing Manually Verifiable ..."
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.
@InProceedings{REBLS18p1,
author = {Steven Smyth and Christian Motika and Reinhard von Hanxleden},
title = {Synthesizing Manually Verifiable Code for Statecharts},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {1--10},
doi = {10.1145/3281278.3281283},
year = {2018},
}
Publisher's Version
REBLS '18: "DISCOPAR: A Visual Reactive ..."
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.
@InProceedings{REBLS18p31,
author = {Jesse Zaman and Kennedy Kambona and Wolfgang De Meuter},
title = {DISCOPAR: A Visual Reactive Programming Language for Generating Cloud-Based Participatory Sensing Platforms},
booktitle = {Proc.\ REBLS},
publisher = {ACM},
pages = {31--40},
doi = {10.1145/3281278.3281285},
year = {2018},
}
Publisher's Version