Rogério de Lemos

Software Engineering for Self-Adaptive Systems: A Second Research Roadmap

The goal of this roadmap paper is to summarize the state-of-the-art and identify research challenges when developing, deploying and managing self-adaptive software systems. Instead of dealing with a wide range of topics associated with the field, we focus on four essential topics of self-adaptation: design space for self-adaptive solutions, software engineering processes for self-adaptive systems, from centralized to decentralized control, and practical run-time verification & validation for self-adaptive systems. For each topic, we present an overview, suggest future directions, and focus on selected challenges. This paper complements and extends a previous roadmap on software engineering for self-adaptive systems published in 2009 covering a different set of topics, and reflecting in part on the previous paper. This roadmap is one of the many results of the Dagstuhl Seminar 10431 on Software Engineering for Self-Adaptive Systems, which took place in October 2010.

Architecting Dependable Systems V

What do you do to start reading architecting dependable systems vi? Searching the book that you love to read first or find an interesting book that will make you want to read? Everybody has difference with their reason of reading a book. Actuary, reading habit must be from earlier. Many people may be love to read, but not a book. Its not fault. Someone will be bored to open the thick book with small words to read. In more, this is the real condition. So do happen probably with this architecting dependable systems vi.

Reflecting on self-adaptive software systems

Self-adaptability has been proposed as an effective approach to automate the complexity associated with the management of modern-day software systems. While over the past decade we have witnessed significant progress in the manner in which such systems are designed, constructed, and deployed, there is still a lack of consensus among the engineers on some of the fundamental underlying concepts. In this paper, we attempt to alleviate this issue by exploring the crucial role of computational reflection in the context of self-adaptive software systems. We show that computational reflection forms the foundation of a self-adaptive system, and an understanding of its properties is a prerequisite to intelligent and predictable construction of such systems. Examining several systems in light of computational reflection has helped us to identify a number of key challenges, which we report on and propose as avenues of future research.

Evaluation of resilience in self-adaptive systems using probabilistic model-checking

The provision of assurances for self-adaptive systems presents its challenges since uncertainties associated with its operating environment often hamper the provision of absolute guarantees that system properties can be satisfied. In this paper, we define an approach for the verification of self-adaptive systems that relies on stimulation and probabilistic model-checking to provide levels of confidence regarding service delivery. In particular, we focus on resilience properties that enable us to assess whether the system is able to maintain trustworthy service delivery in spite of changes in its environment. The feasibility of our proposed approach for the provision of assurances is evaluated in the context of the Znn.com case study.

An architectural support for self-adaptive software for treating faults

Considering the current trend of building systems from existing components that allow neither code inspection nor change, the solution for enabling dynamic adaptation of software systems should not be intrusive in the way that components should be designed. The architectural approach for treating faults described in this paper, instead of providing mechanisms and techniques at the component level, it relies on the interactions between components for obtaining flexible software structures that are nevertheless robust to the occurrence of undesirable events.

Evolving an adaptive industrial software system to use architecture-based self-adaptation

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.

Software Engineering Processes for Self-Adaptive Systems

In this paper, we discuss how for self-adaptive systems some activities that traditionally occur at development-time are moved to run-time. Responsibilities for these activities shift from software engineers to the system itself, causing the traditional boundary between development-time and run-time to blur. As a consequence, we argue how the traditional software engineering process needs to be reconceptualized to distinguish both development-time and run-time activities, and to support designers in taking decisions on how to properly engineer such systems.

A fault-tolerant software architecture for component-based systems

Component-based software built from reusable software components is being used in a wide range of applications that have high dependability requirements. In order to achieve the required levels of dependability, it is necessary to incorporate into these complex systems means for coping with software faults. However, the problem is exacerbated if we consider the current trend of integrating off-the-shelf software components, from independent sources, which allow neither code inspection nor changes. To leverage the dependability properties of these systems, we need solutions at the architectural level that are able to guide the structuring of unreliable components into a fault-tolerant architecture. In this paper, we present an approach for structuring fault-tolerant component-based systems based on the C2 architectural style.

Software engineering for adaptive and self-managing systems

The objective of this workshop is to consolidate the interest in the software engineering community on autonomic, self-managing, self-healing, self-optimizing, self-configuring, and self-adaptive systems. The workshop will provide a forum for researchers to share new results, raise awareness of new adaptive concerns, and promote collaboration among the community. This workshop will be the first of several to assess progress and identify challenges in this important area.

Dynamic plans for integration testing of self-adaptive software systems

Self-adaptive software systems are able to modify their own structure and/or behaviour at run-time in order to cope with changes. During software self-adaptation, new components may be incorporated to the software system. One crucial aspect when incorporating new components is to test them for guaranteeing that they can interoperate as specified. However, this aspect has been often neglected when considering architectural reconfiguration. To deal with this problem, this paper presents an approach for the dynamic generation of plans for conducting the integration testing of self-adaptive software systems. In order to evaluate our approach, we have developed a prototype application that has been used to conduct some experiments, and to demonstrate the feasibility of our approach.