Self-adaptive Software Research Articles

Applying Bigraph Theory to Self-Adaptive Software Architecture

Applying Bigraph Theory to Self-Adaptive Software Architecture

Self-adaptive software

Software systems dealing with distributed applications in changing environments normally require human supervision to continue operation in all conditions. These (re-)configuring, troubleshooting, and in general maintenance tasks lead to costly and time-consuming procedures during the operating phase. These problems are primarily due to the open-loop structure often followed in software development. Therefore, there is a high demand for management complexity reduction, management automation, robustness, and achieving all of the desired quality requirements within a reasonable cost and time range during operation. Self-adaptive software is a response to these demands; it is a closed-loop system with a feedback loop aiming to adjust itself to changes during its operation. These changes may stem from the software system's self (internal causes, e.g., failure) or context (external events, e.g., increasing requests from users). Such a system is required to monitor itself and its context, detect significant changes, decide how to react, and act to execute such decisions. These processes depend on adaptation properties (called self-* properties), domain characteristics (context information or models), and preferences of stakeholders. Noting these requirements, it is widely believed that new models and frameworks are needed to design self-adaptive software. This survey article presents a taxonomy, based on concerns of adaptation, that is, how , what , when and where , towards providing a unified view of this emerging area. Moreover, as adaptive systems are encountered in many disciplines, it is imperative to learn from the theories and models developed in these other areas. This survey article presents a landscape of research in self-adaptive software by highlighting relevant disciplines and some prominent research projects. This landscape helps to identify the underlying research gaps and elaborates on the corresponding challenges.

Auto-adaptation de composants logiciels. Mécanismes d'auto-adaptation de la structure de composants appliqués aux environnements ubiquitaires

The creation of information systems able to be executed in ubiquitous environments, involves a better taking into account of the runtime context in order to ensure service continuity. However, in component-based software engineering, information systems are built by assembling standalone components which must adapt themselves to the current context. To deal with this issue, we propose in this paper an approach aiming at generating a self-adaptive software component from a standalone component. This property allows the component to adapt its structure according its use context.

Coordinated management of hardware and software self-adaptivity

Self-adaptivity is the capability of a system to adapt itself dynamically to achieve its goals. Self-adaptive systems will be widely used in the future both to efficiently use system resources and to ease the management of complex systems. The frameworks for self-adaptivity developed so far usually concentrate either on self-adaptive software or on self-adaptive hardware, but not both. In this paper, we propose a model of self-adaptive systems and we describe how to manage self-adaptivity at all levels (both hardware and software) by means of a decentralized control algorithm. The key advantage of decentralized control is in the simplicity of the local controllers. Simulation results are provided to show the main characteristics of the model and to discuss it.

Study on Environmental Changes Processing in Deep Web Integration Based on Knowledge

Based on the research on the dependence of the components in the deep Web integration (executive partial order and knowledge dependency), a knowledge-based method is given to process the changes in such integration, which includes environmental changes processing model, a self-adaptive software architecture and algorithm. This method can provide a reference to the further research or toward application for the large-scale deep Web integration. The experimental results show that the method can not only process the changes, but also highly improve the performance of the integrated system.

적응형 소프트웨어를 위한 프로덕트 라인 아키텍처 개발

최근의 유비쿼터스 컴퓨팅 환경에서 요구되는 새로운 패러다임의 소프트웨어인 적응형 소프트웨어는 외부 환경 즉 문맥의 변화를 인식하고 자신의 운영 상태를 평가하여 스스로 동작행위를 바꾸는 능력을 가진 소프트웨어이다. 적응형 소프트웨어를 개발하기 위해서는 문맥에 대한 분석 및 설계와 더불어 동적인 문맥에 따라 적절히 대응할 수 있는 소프트웨어의 구조 및 행위를 설계하는 과정이 필요하다. 이것은 일반적인 소프트웨어보다 소프트웨어가 적응해야 하는 상황을 모델링 하는 기술이 필요하기 때문에 더 많은 노력이 필요하다. 본 논문에서는 재사용을 통해 개발의 효율성을 높이고자 적응형 소프트웨어를 위한 프로덕트 라인 아키텍처와 아키텍처 산출물의 템플릿을 제안한다. 아키텍처 산출물들은 프로덕트 라인의 공통성과 가변성을 명시적으로 표현하여 체계적인 핵심자산의 재사용 활동을 지원한다. In the latest intelligent computing environments, the self-adaptive software, as new software paradigm, which modifies its own behavior in response to changes in its operating environment is needed. To develop the self-adaptive software, it is necessary to analyze and design the context of software as well as the structure and the behavior of software. We need more efforts for self-adaptive software development than for traditional software development because we need more activities and technologies like context modeling and adaptation to develop the self-adaptive software. In this paper, we present the product line architecture for self-adaptive software and templates of artifacts to improve the efficiency of development through a reuse methodology. The artifacts of the architecture support the systematic reuse activities of core assets by expressing the commonality and variability of product line.

On environment-driven software model for Internetware

Internetware is envisioned as a general software paradigm for the application style of resources integration and sharing in the open, dynamic and uncertain platforms such as the Internet. Continuing the agent-based Internetware model presented in a previous paper, in this paper, after an analysis of the behavioral patterns and the technical challenges of environment-driven applications, a software-structuring model is proposed for environment-driven Internetware applications. A series of explorations on the enabling techniques for the model, especially the modeling, management and utilization of context information are presented. Several prototypical systems have also been built to prove the concepts and evaluate the techniques. These research efforts make a further step toward the Internetware paradigm by providing an initial framework for the construction of context-aware and self-adaptive software application systems in the open network environment.

Software Architecture-based Approach to Self-adaptive Function for Intelligent Robots

Abstract An intelligent service robot helps human users with providing various services such as bringing a newspaper, recommending TV programs, and preparing meals. Each service can be accomplished by coordinating various motion actuations that are activated based on sensory data. Due to the limitation of robot computing-resources such as CPU usage and memory, the software components that implement such motion actuations can not be loaded and executed at the same time as the complexity of the service increases. That is, those components may compete with each other for the limited computing-resources, and this may result an unexpected behavior of the robot. In this paper, we propose a software architecture-based approach for self-adaptive function that optimizes the use of computing resources by supporting dynamic re-deployment of software components. Organizations of motion actuations for providing services are modeled by software architecture that describes required components and their configurations. In our approach, when a resource problem is detected, components are re-deployed across single-board computers (SBCs) in the robot while maintaining the functional and quality requirements of the components and configuration among them represented in the software architecture. We designed the self-adaptive software framework and implemented a prototype of it. We also had an experiment of our approach on an infotainment robot, and successfully proved the effectiveness of the architecture-based self-adaptive function.

A polynomial dynamic system approach to software design for attractivity requirement

Because of the widespread increasing application of Web services and autonomic computing, self-adaptive software is an area gaining increasing importance. Control theory provides a theoretical foundation for self-adaptive software. In this paper, we propose the use of the supervisory control theory of discrete event dynamic systems (DEDS) to provide a rigorous foundation for designing software for reactive systems. This paper focuses in particular on design of software with an attractivity requirement. It studies this problem using the polynomial dynamic system (PDS) model of DEDS. A necessary and sufficient condition for software existence and two algorithms for such software design are presented.

Towards a component framework for architecture-based self-adaptive applications

Self-adaptive software is an efficient way to cope with highly dynamic nature of the environment where it is situated. In this paper, from the perspective of software architecture, we propose a component framework for supporting the architecture-based design and development of self-adaptive applications. It captures some key elements of the research on software architecture and provides more flexible facilities to decouple interacting components. Based on that, a prototype is implemented to demonstrate its feasibility, and at last a case study is presented to illustrate our framework.

Automatic recovery from software failure

A model-based approach to self-adaptive software.

Dynamic Self-Adapting Software Architecture for Replica Management in Grids

Single data replica management strategy can not meet the complexity and diverseness in data grid. This paper proposes a dynamic self-adapting replica management architecture (DSA-RM) driven by software architecture (SA). In DSA-RM, architecture descriptions are shared by the whole grid environment as a system kernel to schedule various replica management components that are adapted to various application and VO in data grid. By the abstraction of DSA-RM, the paper describes the formal definitions of replica management components and discusses the dynamic self-adapting regulation of component evolution and multiplication in dynamic environment. By these regulations, the DSA-RM's framework and algorithms of multiplication are designed. Experimental results show that the DSA-RM can effectively promote the performance of grid system. Finally, the project of applying the

Architectural runtime configuration management in support of dependable self-adaptive software

The dynamic nature of some self-adaptive software systems can result in potentially unpredictable adaptations, which may be detrimental to overall system dependability by diminishing trust in the adaptation process. This paper describes our initial work with architectural runtime configuration management in order to improve dependability and overall system usefulness by maintaining a record of reconfigurations and providing support for architectural recovery operations. Our approach---fully decoupled from self-adaptive systems themselves and the adaptation management processes governing their changes---provides for better adaptation visibility and self-adaptive process dependability. We elaborate on the vision for our overall approach, present early implementation and testing results from prototyping efforts, and discuss our future plans.

Self adaptivity in Grid computing

Optimizing a given software system to exploit the features of the underlying system has been an area of research for many years. Recently, a number of self-adapting software systems have been desig...

Towards a rule model for self-adaptive software

Most self-adaptive software use rules explicitly or implicitly to decide how to react to monitored events. Meanwhile, rules are usually scattered in different procedures, which makes procedures more complex. This paper proposes a Rule Model, which is used to extract scattered rules from different procedures, so as to enhance the self-adaptive ability of software. The paper presents what is Rule Model, including: three key concepts (event, parameter, and rule), hierarchical organization, role in application, and XML-based representation. The paper also introduces how to map declarative rules inside one deployable application to executable rules inside one rule engine, based on one J2EE-compliant application server.

A controller synthesis algorithm for building self-adaptive software

A controller synthesis algorithm for building self-adaptive software

An Agent-Based Self-Adaptive Software Process Model

Traditional software process models are mostly static, mechanical, and passive. Traditional approach requires modeler to determine all the possible conditions the software process will encounter and to define explicitly the solutions into a process model. It lacks the ability to allow further deliberations when the modeled environment changes. This paper presents an Agent-based self-adaptive software process model. In this approach, software process is modeled as peers: process Agents. These software process Agents can adapt themselves to the software process environment and act with initiative and autonomy. When the process environment changes, the process

A controller synthesis algorithm for building self-adaptive software

A novel approach for building self-adaptive software based on a controller synthesis algorithm is presented. Self-adaptive software is a relatively new idea aiming at producing applications that can readily adapt in the face of changing user needs, desires and environment. Self-adaptive software has multiple ways of accomplishing its purpose, enough knowledge of its construction and is capable of changing behaviour when it does not accomplish its goal or when better functionality or performance is possible. The presented approach for building self-adaptive software uses ontological models of software components, which represent the environment, the composition, the required behaviour, and the possible configurations for the self-adaptive software. Self-adaptation is based on a supervisory control algorithm that reconfigures and controls software components in order to achieve their required behaviour.

Self-adapting software for numerical linear algebra and LAPACK for clusters

This article describes the context, design, and recent development of the LAPACK for clusters (LFC) project. It has been developed in the framework of Self-Adapting Numerical Software (SANS) since we believe such an approach can deliver the convenience and ease of use of existing sequential environments bundled with the power and versatility of highly tuned parallel codes that execute on clusters. Accomplishing this task is far from trivial as we argue in the paper by presenting pertinent case studies and possible usage scenarios.

A System for Building Intelligent Agents that Learn to Retrieve and Extract Information

We present a system for rapidly and easily building instructable and self-adaptive software agents that retrieve and extract information. Our Wisconsin Adaptive Web Assistant (WAWA) constructs intelligent agents by accepting user preferences in the form of instructions. These user-provided instructions are compiled into neural networks that are responsible for the adaptive capabilities of an intelligent agent. The agent's neural networks are modified via user-provided and system-constructed training examples. Users can create training examples by rating Web pages (or documents), but more importantly WAWA's agents uses techniques from reinforcement learning to internally create their own examples. Users can also provide additional instruction throughout the life of an agent. Our experimental evaluations on a `home-page finder' agent and a `seminar-announcement extractor' agent illustrate the value of using instructable and adaptive agents for retrieving and extracting information.