In this article, we present a novel fault injection framework for system call invocation errors, calledPhoebe.Phoebeis unique as follows; First,Phoebeenables developers to have full observability of system call invocations. Second,Phoebegenerates error models that are realistic in the sense that they mimic errors that naturally happen in production. Third,Phoebeis able to automatically conduct experiments to systematically assess the reliability of applications with respect to system call invocation errors in production. We evaluate the effectiveness and runtime overhead ofPhoebeon two real-world applications in a production environment for a single software stack: Java. The results show thatPhoebesuccessfully generates realistic error models and is able to detect important reliability weaknesses with respect to system call invocation errors. To our knowledge, this novel concept of “realistic error injection”, which consists of grounding fault injection on production errors, has never been studied before.

Software systems contain resilience code to handle those failures and unexpected events happening in production. It is essential for developers to understand and assess the resilience of their systems. Chaos engineering is a technology that aims at assessing resilience and uncovering weaknesses by actively injecting perturbations in production. In this paper, we propose a novel design and implementation of a chaos engineering system in Java calledChaosMachine. It provides a unique and actionable analysis on exception-handling capabilities in production, at the level of try-catch blocks. To evaluate our approach, we have deployedChaosMachineon top of 3 large-scale and well-known Java applications totaling$630k$lines of code. Our results show thatChaosMachinereveals both strengths and weaknesses of the resilience code of a software system at the level of exception handling.

Nowadays, every vehicle is wirelessly connected, often by both itself and its passengers. The same goes for all the continuously growing number of devices alongside the transportation infrastructure. This induces an abundance of data that can be used to direct traffic efficiently, optimize the transportation infrastructure, avoid accidents, lower emissions from transportation and so forth. To create coherence among the messages related to a Cooperative and Intelligent Transportation System (C-ITS), an ETSI message type standard has been developed. The next hurdle is how to facilitate receiving and processing millions of C-ITS messages in real-time. We present a feasibility study on how these C-ITS messages can be received, processed and distributed. Our novel approach is to bridge C-ITS message types over MQTT, to Apache Kafka, with fault-tolerance, horizontal scalability, and low latency. We have engineered both an MQTT-Kafka source connector and a Kafka-MQTT sink connector, by utilizing the Kafka Connector API. These facilitate an easy configurable topic mapping between MQTT and Kafka, from vehicles and roadside units to a central application, and in the opposite direction. Our experiments with this bridging technology, performed on a modest desktop computer with a single instance Kafka setup, show the feasibility by managing to source and sink CAM messages with low latency.

Modern software systems interact with multiple 3rd party dependencies such as the OS file system, libraries, databases or remote services. To verify these interactions, developers write so-called "integration tests" that exercise the software within a specific environment. These tests are not only difficult to write as their environment is complicated, but they are also brittle because changes outside the code (i.e., in the environment) might make them fail unexpectedly. Integration tests are thus underused whereas they could help find many more issues. We hence propose CAMP, a tool that amplifies an existing integration test by exploring variations of the given environment. The tests that CAMP generates alter the services orchestration, the software stacks, the individual components' configuration or any combination thereof. We used CAMP to amplify tests from the Sphinx and Atom open-source projects, and in both cases, we were able to spot undocumented issues related to incompatible environments.

A recurring issue in generative approaches, in particular if they generate code for multiple target languages, is logging. How to ensure that logging is performed consistently for all the supported languages? How to ensure that the specific semantics of the source language, e.g. a modeling language or a domain-specific language, is reflected in the logs? How to expose logging concepts directly in the source language, so as to let developers specify what to log? This paper reports on our experience developing a concrete logging approach for ThingML, a textual modeling language built around asynchronous components, statecharts and a first-class action language, as well as a set of "compilers" targeting C, Go, Java and JavaScript.

Automated diversity is a promising mean of increasing the security of software systems. However, current automated diversity techniques operate at the bottom of the software stack (operating system and compiler), yielding a limited amount of diversity. We present a novel Model-Driven Engineering approach to the diversification of communicating systems, building on abstraction, model transformations and code generation. This approach generates significant amounts of diversity with a low overhead, and addresses a large number of communicating systems, including small communicating devices.

Advances in the Internet of Things (IoT) domain thrusts home automation into the spotlight. Home automation is a heterogeneous realm with various and often not compatible technologies. As any not standardized area, this realm is always disrupted by new, emerging technologies and standards. Home is a dynamic environment which constantly grows and evolves. To keep up with changes, home automation algorithms are tweaked and modified over time. To tackle diversity, we employ model driven approaches to weave different technologies and facilitate home automation tasks. We show how modelling techniques improve portability, scalability and simulation of the home automation features. We present two use-cases developed in cooperation with industry partners, report our experience in applying ThingML and the Arrowhead framework in the home automation domain.

Modern industrial control applications gradually take advantage of well-defined state-of-the-art distributed software architecture principles and framework designs, including corresponding modeling techniques. Moreover, the advent of this new era goes way beyond current modeling tool-chains via the application of mature meta-model driven software engineering paradigms. In the frame of the Arrowhead ARTEMIS project these techniques are to showcase the synergies between multi-level meta-model driven design and SOA based dynamic model-aware run-time framework components. This paper reports on the on-going engineering efforts in this domain by showing the generic architecture and by explaining some of the current implementation details through a prototypical tool-chain and a simple model example.

The Arrowhead project aims to address the technical and applicative issues associated with cooperative automation based on Service Oriented Architectures. The problems of developing such kind of systems are mainly due to the lack of adequate development and service documentation methodologies, which would ease the burden of reusing services on different applications. The Arrowhead project proposes a technical framework to efficiently support the development of such systems, which includes several tools for documentation of services and to support the development of SOA-based installations. The work presented in this paper describes the approach which has been developed for the first generation pilots to support the documentation of their structural services. Each service, system and system-of-systems within the Arrowhead Framework must be documented and described in such way that it can be implemented, tested and deployed in an interoperable way. This paper presents the first steps of realizing the Arrowhead vision for interoperable services, systems and systems-of-systems.

In the landscape of cloud computing, the competition between providers has led to an ever growing number of cloud solutions offered to consumers. The ability to run and manage multi-cloud systems (i.e., applications on multiple clouds) allows exploiting the peculiarities of each cloud solution and hence optimising the performance, availability, and cost of the applications. However, these cloud solutions are typically heterogeneous and the provided features are often incompatible. This diversity hinders the proper exploitation of the full potential of cloud computing, since it prevents interoperability and promotes vendor lock-in, as well as it increases the complexity of development and administration of multi-cloud systems. This problem needs to be addressed promptly. In this paper, we provide a classification of the state-of-the-art of cloud solutions, and argue for the need for model-driven engineering techniques and methods facilitating the specification of provisioning, deployment, monitoring, and adaptation concerns of multi-cloud systems at design-time and their enactment at run-time.

Modern software systems need to be continuously available under varying conditions. Their ability to dynamically adapt to their execution context is thus increasingly seen as a key to their success. Recently, many approaches were proposed to design and support the execution of Dynamically Adaptive Systems (DAS). However, the ability of a DAS to evolve is limited to the addition, update or removal of adaptation rules or reconfiguration scripts. These artifacts are very specific to the control loop managing such a DAS and runtime evolution of the DAS requirements may affect other parts of the DAS. In this paper, we argue to evolve all parts of the loop. We suggest leveraging recent advances in model-driven techniques to offer an approach that supports the evolution of both systems and their adaptation capabilities. The basic idea is to consider the control loop itself as an adaptive system.

Security is a key-challenge for software engineering, especially when considering access control and software evolutions. No satisfying solution exists for maintaining the alignment of access control policies with the business logic. Current implementations of access control rely on the separation between the policy and the application code. In practice, this separation is not so strict and some rules are hard-coded within the application, making the evolution of the policy difficult. We propose a new methodology for implementing security-driven applications. From a policy defined by a security expert, we generate an architectural model, reflecting the access control policy. We leverage the advances in the [email protected] domain to keep this model synchronized with the running system. When the policy is updated, the architectural model is updated, which in turn reconfigures the running system. As a proof of concept, we apply the approach to the development of a library management system.

Since software systems need to be continuously available under varying conditions, their ability to evolve at runtime is increasingly seen as one key issue. Modern programming frameworks already provide support for dynamic adaptations. However the high-variability of features in Dynamic Adaptive Systems (DAS) introduces an explosion of possible runtime system configurations (often called modes) and mode transitions. Designing these configurations and their transitions is tedious and error-prone, making the system feature evolution difficult. While Aspect-Oriented Modeling (AOM) was introduced to improve the modularity of software, this paper presents how an AOM approach can be used to tame the combinatorial explosion of DAS modes. Using AOM techniques, we derive a wide range of modes by weaving aspects into an explicit model reflecting the runtime system. We use these generated modes to automatically adapt the system. We validate our approach on an adaptive middleware for home-automation currently deployed in Rennes metropolis.