SEAMS 2013 – Proceedings

Science in the Cloud (Keynote)
Joe Hellerstein
(Google, USA)
Recent trends in science have made computational capabilities an essential part of scientific discovery. This is often referred to as enhanced scientific discovery, or eScience. eScience has been an integral part of high energy physics for several decades due to the complexity and volume of data produced by experiments. In the 1990s, eScience become central to biology with the sequencing of the human genome. More recently, eScience has become integral to neuroscience to understand neural circuits and human behavior. It is my view that the demands of 21st century science will mean that eScience is largely done in the Cloud. There are several reasons for this. Foremost, many of the computing requirements of scientists are bursty, requiring massive capabilities for short periods of time. This requirement is well suited to the Cloud. Second, 21st century science will frequently require the publication of large datasets such as the Allen Institute's Brain Atlas and the world wide network of genomics data. Hosting these datasets in public clouds will be much easier than requiring individual scientists (or even universities) to build their own data hosting systems. Third, progress in science increasingly requires collaborations among many distributed groups. Thecloud can greatly facilitate these collaborations. This talk discusses the requirements for science in the Cloud, and efforts underway to address these requirements. I will provide considerable detail about Google's Exacycle project that is donating one billion core hours to scientific discovery in molecular modeling, drug analysis, and astronomy.

A 10-Year Perspective on Software Engineering Self-Adaptive Systems (Keynote)
David Garlan
(CMU, USA)
In 2002 I helped organize the 1st ACM Workshop on Self-healing Systems (WOSS), a workshop that eventually morphed into this SEAMS Conference. As with SEAMS today, the goal then was to bring researchers together to gain a better understanding of the software engineering challenges and approaches for this emerging area. Now, just over 10 years later, it seems a fitting time to reflect back on the progress of the field during this formative period and to consider some of the broader implications for the software engineering agenda. In particular, in this talk I will try to tease out some common themes and research challenges that have emerged as the core concerns for this subfield. I will also do a bit of soul-searching to reflect on my own research agenda in architecture-based self-adaptation as exemplified by the Rainbow System -- considering both the decisions that we made that were good, and the ones that I think need to be revisited.

Evaluation

Do External Feedback Loops Improve the Design of Self-Adaptive Systems? A Controlled Experiment
Danny Weyns, M. Usman Iftikhar, and Joakim Söderlund
(Linnaeus University, Sweden)
Providing high-quality software in the face of uncertainties, such as dealing with new user needs, changing availability of resources, and faults that are difficult to predict, raises fundamental challenges to software engineers. These challenges have motivated the need for self-adaptive systems. One of the primary claimed benefits of self-adaptation is that a design with external feedback loops provide a more effective engineering solution for self-adaptation compared to a design with internal mechanisms. While many efforts indicate the validity of this claim, to the best of our knowledge, no controlled experiments have been performed that provide scientifically founded evidence for it. Such experiments are crucial for researchers and engineers to underpin their claims and improve research. In this paper, we report the results of a controlled experiment performed with 24 final-year students of a Master in Software Engineering program in which designs based on external feedback loops are compared with designs based on internal mechanisms. The results show that applying external feedback loops can reduce control flow complexity and fault density, and improve productivity. We found no evidence for a reduction of activity complexity.

Evolving an Adaptive Industrial Software System to Use Architecture-Based Self-Adaptation
Javier Cámara, Pedro Correia, Rogério de Lemos, David Garlan, Pedro Gomes, Bradley Schmerl, and Rafael Ventura
(University of Coimbra, Portugal; University of Kent, UK; CMU, USA; Critical Software, Portugal)
Although architecture-based self-adaptation has been widely used, there is still little understanding about the validity and tradeoffs of incorporating it into real-world software-intensive systems which already feature built-in adaptation mechanisms. In this paper, we report on our experience in integrating Rainbow, a platform for architecture-based self-adaptation, and an industrial middleware employed to monitor and manage highly populated networks of devices. Specifically, we reflect on aspects such as the effort required for framework customization and legacy code refactoring, performance improvement, and the impact of architecture-based self-adaptation on system evolution.

Requirements and Architectural Approaches to Adaptive Software Systems: A Comparative Study
Konstantinos Angelopoulos, Vítor E. Silva Souza, and João Pimentel
(University of Trento, Italy; UFES, Brazil; UFPE, Brazil)
The growing interest in adaptive software systems has resulted in a number of different proposals for the design of adaptive systems. Some approaches adopt architectural models, whereas others model adaptation options, at the level of requirements. This dichotomy has motivated us to perform a comparative study between two proposals for the design of adaptive systems: the Rainbow Framework (architecture-based) and our own proposal, Zanshin (requirements-based). This evaluation paper reports on our methodology and results. It also provides a comparison between the use of architectural and requirements models as centrepieces of adaptation, offering guidelines for the future research in the field of adaptive systems.

Services

On Estimating Actuation Delays in Elastic Computing Systems
Alessio Gambi, Daniel Moldovan, Georgiana Copil, Hong-Linh Truong, and Schahram Dustdar
(TU Vienna, Austria; University of Lugano, Switzerland)
Elastic controllers autonomically adjust the allocation of resources in cloud computing systems. Usually such controllers assume that control actions will take immediate effect. In clouds, however, actuation times may be long, and the controllers can hardly guarantee acceptable levels of service if they neglect these actuation delays. Therefore, the ability to correctly estimate the time that control actions take effect on the systems is crucial. However, detecting actuation delays in elastic computing systems is challenging because cloud systems provide only inaccurate and incomplete data about reconfigurations timing.
In this paper, we tackle the problem of estimating the delay of control actions in elastic systems. We identify recurring types of changes in the monitored metrics and requirements to properly carry out the estimation. Based on that, we develop a novel framework for the actuation delays estimation that utilizes change point detection techniques. We conduct several experiments with real-world systems to illustrate the feasibility and applicability of our framework.

Self-Adaptive and Sensitivity-Aware QoS Modeling for the Cloud
Tao Chen and Rami Bahsoon
(University of Birmingham, UK)
Given the elasticity, dynamicity and on-demand nature of the cloud, cloud-based applications require dynamic models for Quality of Service (QoS), especially when the sensitivity of QoS tends to fluctuate at runtime. These models can be autonomically used by the cloud-based application to correctly self-adapt its QoS provision. We present a novel dynamic and self-adaptive sensitivity-aware QoS modeling approach, which is fine-grained and grounded on sound machine learning techniques. In particular, we combine symmetric uncertainty with two training techniques: Auto-Regressive Moving Average with eXogenous inputs model (ARMAX) and Artificial Neural Network (ANN) to reach two formulations of the model. We describe a middleware for implementing the approach. We experimentally evaluate the effectiveness of our models using the RUBiS benchmark and the FIFA 1998 workload trends. The results show that our modeling approach is effective and the resulting models produce better accuracy when compared with conventional models.

QoS-Aware Fully Decentralized Service Assembly
Vincenzo Grassi, Moreno Marzolla, and Raffaela Mirandola
(University of Rome Tor Vergata, Italy; University of Bologna, Italy; Politecnico di Milano, Italy)
Large, distributed software systems are increasingly common in today geographically distributed IT infrastructures. A key challenge for the software engineering community is how to efficiently and effectively manage such complex systems. Extending software services with autonomic capabilities has been suggested as a possible way to address this challenge. Ideally, self-management capabilities should be based on fully distributed, peer-to-peer (P2P) architectures in order to try to overcome the scalability and robustness problems of centralized solutions. Within this context, we propose an approach for the adaptive self-assembly of distributed services, based on a simple epidemic protocol. Our approach is based on the three-layer reference model for adaptive systems, and is centered on the use of a gossip protocol to achieve decentralized information dissemination and decision making. The goal of our system is to build and maintain an assembly of services that, besides functional requirements, is able to fulfill global quality of service (QoS) and structural requirements. A set of simulation experiments is used to assess the effectiveness of our approach in terms of convergence speed towards the optimal solution, and resilience to failures.

Learning and Updates

Formalizing Correctness Criteria of Dynamic Updates Derived from Specification Changes
Valerio Panzica La Manna, Joel Greenyer, Carlo Ghezzi, and Christian Brenner
(Politecnico di Milano, Italy; University of Paderborn, Germany)
Modern software-intensive systems often have to be updated to adapt to unpredicted changes in their environments or to satisfy unpredicted requirement changes. Many systems, however, cannot be easily shut down or are expected to run continuously. Therefore, they must be updated dynamically, at run-time. Especially for critical systems, dynamic updates must be safe and performed as soon as possible. We recently studied the relationship between specification changes and dynamic updates and defined a criterion for when a system can safely disregard its current obligations and how it should change its behavior to satisfy the new specification. In this paper, we study further examples that show that stronger and weaker variants of our original criterion are relevant when engineering dynamically updating software. We formalize these criteria and discuss their safety. Moreover, we provide a tool for synthesizing dynamically updating controllers from changes in scenario-based specifications that respect the new criteria.

Run-Time Adaptation of Mobile Applications using Genetic Algorithms
Gustavo G. Pascual, Mónica Pinto, and Lidia Fuentes
(University of Málaga, Spain)
Mobile applications run in environments where the context is continuously changing. Therefore, it is necessary to provide support for the run-time adaptation of these applications. This support is usually achieved by middleware platforms that offer a context-aware dynamic reconfiguration service. However, the main shortcoming of existing approaches is that both the list of possible configurations and the plans to adapt the application to a new configuration are usually specified at design-time. In this paper we present an approach that allows the automatic generation at run-time of application configurations and of reconfiguration plans. Moreover, the generated configurations are optimal regarding the provided functionality and, more importantly, without exceeding the available resources (e.g. battery). This is performed by: (1) having the information about the application variability available at runtime using feature models, and (2) using a genetic algorithm that allows generating an optimal configuration at runtime. We have specified a case study and evaluated our approach, and the results show that it is efficient enough as to be used on mobile devices without introducing an excessive overhead.

Guaranteeing Robustness in a Mobile Learning Application using Formally Verified MAPE Loops
Didac Gil de la Iglesia and Danny Weyns
(Linnaeus University, Sweden)
Mobile learning applications support traditional indoor lectures with outdoor activities using mobile devices. An example scenario is a team of students that use triangulation techniques to learn properties of geometrical figures. In previous work, we developed an agent-based mobile learning application in which students use GPS-enabled phones to calculate distances between them. From practical experience, we learned that the required level of GPS accuracy is not always guaranteed, which undermines the use of the application. In this paper, we explain how we have extended the existing application with a self-adaptation layer, making the system robust to degrading GPS accuracy. The self-adaptive layer is conceived as a set of interacting MAPE loops (Monitor-Analysis-Plan-Execute), distributed over the phones. To guarantee the robustness requirements, we formally specify the self-adaptive behaviors using timed automata, and the required properties using timed computation tree logic. We use the Uppaal tool to model the self-adaptive system and verify the robustness requirements. Finally, we discuss how the formal design supported the implementation of the self-adaptive layer on top of the existing application.

Case Studies and Decision-Making

Engineering Adaptation with Zanshin: An Experience Report
Genci Tallabaci and Vítor E. Silva Souza
(University of Trento, Italy; UFES, Brazil)
The Zanshin framework adopts a Requirements Engineering perspective to the design of adaptive systems and is centered around the idea of feedback loops. Evaluation experiments conducted so far have used simulations, limiting the strength of our conclusions on the viability of our proposal. In this paper, we report on the experience of applying Zanshin to an existing base system, a software that simulates an Automated Teller Machine (ATM), available online, drawing conclusions on the applicability of the frameworks potential in real-life situations.

Diagnosing Architectural Run-Time Failures
Paulo Casanova, David Garlan, Bradley Schmerl, and Rui Abreu
(CMU, USA; University of Porto, Portugal)
Self-diagnosis is a fundamental capability of self-adaptive systems. In order to recover from faults, systems need to know which part is responsible for the incorrect behavior. In previous work we showed how to apply a design-time diagnosis technique at run time to identify faults at the architectural level of a system. Our contributions address three major shortcomings of our previous work: 1) we present an expressive, hierarchical language to describe system behavior that can be used to diagnose when a system is behaving different to expectation; the hierarchical language facilitates mapping low level system events to architecture level events; 2) we provide an automatic way to determine how much data to collect before an accurate diagnosis can be produced; and 3) we develop a technique that allows the detection of correlated faults between components. Our results are validated experimentally by injecting several failures in a system and accurately diagnosing them using our algorithm.

Dynamic Decision Networks for Decision-Making in Self-Adaptive Systems: A Case Study
Nelly Bencomo, Amel Belaggoun, and Valerie Issarny
(INRIA, France)
Bayesian decision theory is increasingly applied to support decision-making processes under environmental variability and uncertainty. Researchers from application areas like psychology and biomedicine have applied these techniques successfully. However, in the area of software engineering and specifically in the area of self-adaptive systems (SASs), little progress has been made in the application of Bayesian decision theory. We believe that techniques based on Bayesian Networks (BNs) are useful for systems that dynamically adapt themselves at runtime to a changing environment, which is usually uncertain. In this paper, we discuss the case for the use of BNs, specifically Dynamic Decision Networks (DDNs), to support the decision-making of self-adaptive systems. We present how such a probabilistic model can be used to support the decision-making in SASs and justify its applicability. We have applied our DDN-based approach to the case of an adaptive remote data mirroring system. We discuss results, implications and potential benefits of the DDN to enhance the development and operation of self-adaptive systems, by providing mechanisms to cope with uncertainty and automatically make the best decision.

Qualities

Self-Adaptive Containers: Building Resource-Efficient Applications with Low Programmer Overhead
Wei-Chih Huang and William J. Knottenbelt
(Imperial College London, UK)
Despite advances in operating system resource management and the availability of standardised container libraries, developing scalable high-capacity applications remains a non-trivial endeavour. Naive implementations of fundamental algorithms often rapidly exhaust system resources under heavy load. Resolving this via manual refactoring is usually possible but requires significant programmer effort, an effort which often has to be repeated in order to meet the resource constraints encountered in each different execution environment. This paper proposes a library of self-adapting containers which provide a ready route to developing scalable applications with low programmer overhead. Given an execution environment, the library flexibly adapts its use of data structures in an effort to meet programmer-specified service level objectives. The library features a mechanism for tighter functionality specification than that provided by standard container libraries. This enables greater scope for efficiency optimisations, including the exploitation of probabilistic data structures and out-of-core storage. We have demonstrated the capabilities of the proposed library through a prototype implementation in C++. We show that when a Breadth First Search explicit state space exploration algorithm is executed, using the proposed library reduces insertion time by 68.5%, search time by 86.1%, and primary memory usage by 90.1% compared with the Standard Template Library.

Synthesizing Self-Adaptive Connectors Meeting Functional and Performance Concerns
Antinisca Di Marco, Paola Inverardi, and Romina Spalazzese
(University of L'Aquila, Italy)
Today's networked environment is characterized by a wide variety of heterogeneous systems that dynamically decide to interoperate to achieve some goal. In this context, systems meet and know each other at runtime when they want to start to interoperate. Given the huge heterogeneity and dynamism characterizing the described environment, automated solutions appear to be the only way to achieve interoperability timely and with the needed level of flexibility. We already proposed an approach to the automated synthesis of connectors (or mediators) to reconcile protocols diversities and to allow systems interoperability.
In this paper, building upon our previous work, we describe a solution to the automated synthesis of connectors: (a) that takes into account performance concerns during the synthesis process and (b) whose synthesized connectors are (self-)adaptive with respect to runtime performance requirements changes. By reasoning on systems' specification, the approach first produces a mediator that satisfies the functional requirements. Then it acts on the produced mediator to let it satisfy performance issues and to make it (self-)adaptive.

Video

High-Quality Specification of Self-Adaptive Software Systems
Markus Luckey and Gregor Engels
(University of Paderborn, Germany)
Today's software systems have to cope with changing environments while at the same time facing high non-functional requirements such as flexibility and dependability. Recently, these non-functional requirements are addressed using self-adaptivity features, that is, the system monitors its environment and adjusts its structure or behavior in reaction to changes.
In classical model-driven software engineering approaches, self-adaptivity introduces additional complexity since self-adaptation features are distributed in a cross-cutting manner at various different locations in the models, resulting in a tightly interwoven model landscape that is hard to understand and maintain. A particular solution to cope with this problem is the separation of concerns (SoC) to focus on the specific concern of self-adaptivity and allow in-depth analyses. Applying SoC requires suitable development processes, languages, and techniques, e.g., for quality assurance, to be available.
In this paper, we present a method for the specification of self-adaptive software systems using a UML based concern-specific modeling language called Adapt Case Modeling Language (ACML) that allows the separated and explicit specification of self-adaptivity concerns. Based on formal semantics we show how to apply quality assurance techniques to the modeled self-adaptive system, which enable the provisioning of hard guarantees concerning self-adaptivity characteristics such as adaptation rule set stability and deadlock freedom. Further, we show how the language and techniques integrate with existing software development processes.

Evolution

Improving Context-Awareness in Self-Adaptation using the DYNAMICO Reference Model
Gabriel Tamura, Norha M. Villegas, Hausi A. Müller, Laurence Duchien, and Lionel Seinturier
(Icesi University, Colombia; University of Victoria, Canada; INRIA, France; University of Lille, France)
Self-adaptation mechanisms modify target systems dynamically to address adaptation goals, which may evolve continuously due to changes in system requirements. These changes affect values and thresholds of observed context variables and monitoring logic, or imply the addition and/or deletion of context variables, thus compromising self-adaptivity effectiveness under static monitoring infrastructures. Nevertheless, self-adaptation approaches often focus on adapting target systems only rather than monitoring infrastructures. Previously, we proposed DYNAMICO, a reference model for self-adaptive systems where adaptation goals and monitoring requirements change dynamically. This paper presents an implementation of DYNAMICO comprising our SMARTERCONTEXT monitoring infrastructure and QOS-CARE adaptation framework in a self-adaptation solution that maintains its context-awareness relevance. To evaluate our reference model we use self-adaptive system properties and the Znn.com exemplar to compare the Rainbow system with our DYNAMICO implementation. The results of the evaluation demonstrate the applicability, feasibility, and effectiveness of DYNAMICO, especially for self-adaptive systems with context-awareness requirements.

Law and Adaptivity in Requirements Engineering
Silvia Ingolfo and Vítor E. Silva Souza
(University of Trento, Italy; UFES, Brazil)
The great impact that law has on the design of software systems has been widely recognized in past years. However, little attention has been paid to the challenge of coping with variability characterizing the legal domain (e.g., multiple ways to comply with a given law, frequent updates to regulations, different jurisdictions, etc.) on the design of software systems. This position paper advocates the use of adaptation mechanisms in order to support regulatory compliance for software systems. First we show an example of how Zanshin, a requirements-based adaptation framework, can be used to design a system that adapts to legal requirements to accommodate legal variability. Then we examine how legal texts can be analyzed as sources for parameters and indicators needed to support adaptation. As motivating running example we consider legal situations concerning the Google driverless car and its recent legalization in the highways of Nevada and soon also in California.

Towards Run-Time Testing of Dynamic Adaptive Systems
Erik M. Fredericks, Andres J. Ramirez, and Betty H. C. Cheng
(Michigan State University, USA)
It is challenging to design, develop, and validate a dynamically adaptive system (DAS) that satisfies requirements, particularly when requirements can change at run time. Testing at design time can help verify and validate that a DAS satisfies its specified requirements and constraints. While offline tests may demonstrate that a DAS is capable of satisfying its requirements before deployment, a DAS may encounter unanticipated system and environmental conditions that can prevent it from achieving its objectives. In working towards a requirements-aware DAS, this paper proposes run-time monitoring and adaptation of tests as another technique for evaluating whether a DAS satisfies, or is even capable of satisfying, its requirements given its current execution context. To this end, this paper motivates the need and identifies challenges for adaptively testing a DAS at run time, as well as suggests possible methods for leveraging offline testing techniques for verifying run-time behavior.

RPC Automation: Making Legacy Code Relevant
Andreas Bergen, Yağız Onat Yazır, Hausi A. Müller, and Yvonne Coady
(University of Victoria, Canada)
Due to the well-known issues with Remote Proce- dure Calls (RPC), the rather simple idea of modifying legacy applications—that have low spatial locality to the data they need to process—to execute all of their procedures via RPC is not a feasible option. A more realistic and feasible alternative is to provide a self-management mechanism that can dynamically monitor and alter the execution of an existing application by selectively modifying certain procedures to execute remotely when it is necessary to improve spatial locality. In this paper we describe the motivations behind such a self-management mechanism, and outline an initial design. In addition, we in- troduce our vision for the required profiling component of these applications. As such, we introduce the Automated Legacy system Remote Procedure Call mechanism (ALRPC). It automatically converts existing monolithic C applications into a distributed system semi-automatically. Thus automation is a key criterion for successfully competing with existing remote procedure tools for legacy applications and with newer solutions such as SOAP and REST [12], [21]. ALRPC is the core component to convert mono- lithic applications into distributable self-adaptive RPC systems. The empirical results collected from our initial experiments show that our mechanism’s level of automation outperforms existing industry strength tools and improves development time. At the same time our mechanism is able to correctly function with a significant code base and shows acceptable performance in initial tests.