Self-adaptive Software Modeling Based on Contextual Requirements

The ability of self-adaptive software in responding to change is determined by contextual requirements, i.e. a requirement in capturing relevant context-atributes and modeling behavior for system adaptation. However, in most cases, modeling for self-adaptive software is does not take into consider the requirements evolution based on contextual requirements. This paper introduces an approach through requirements modeling languages directed to adaptation patterns to support requirements evolution. The model is prepared through contextual requirements approach that is integrated into MAPE-K (monitor, anayze, plan, execute - knowledge) patterns in goal-oriented requirements engineering. As an evaluation, the adaptation process is modeled for cleaner robot. The experimental results show that the requirements modeling process has been able to direct software into self-adaptive capability and meet the requirements evolution

Leveraging Self-Adaptive Dynamic Software Architecture

Software systems are growing complex due to the technological innovations and integration of businesses. There is ever increasing need for changes in the software systems. However, incorporating changes is time consuming and costly. Self-adaptation is therefore is the desirable feature of any software that can have ability to adapt to changes without the need for manual reengineering and software update. To state it differently robust, self adaptive dynamic software architecture is the need of the hour. Unfortunately, the existing solutions available for self-adaptation need human intervention and have limitations. The architecture like Rainbow achieved self-adaptation. However, it needs to be improves in terms of quality of service analysis and mining knowledge and reusing it for making well informed decisions in choosing adaptation strategies. In this paper we proposed and implemented Enhanced Self-Adaptive Dynamic Software Architecture (ESADSA) which provides automatic self-adaptation based on the runtime requirements of the system. It decouples self-adaptation from target system with loosely coupled approach while preserves cohesion of the target system. We built a prototype application that runs in distributed environment for proof of concept. The empirical results reveal significance leap forward in improving dynamic self-adaptive software architecture

Data reduction in the ITMS system through a data acquisition model with self-adaptive sampling rate

Long pulse or steady state operation of fusion experiments require data acquisition and processing systems that reduce the volume of data involved. The availability of self-adaptive sampling rate systems and the use of real-time lossless data compression techniques can help solve these problems. The former is important for continuous adaptation of sampling frequency for experimental requirements. The latter allows the maintenance of continuous digitization under limited memory conditions. This can be achieved by permanent transmission of compressed data to other systems. The compacted transfer ensures the use of minimum bandwidth. This paper presents an implementation based on intelligent test and measurement system (ITMS), a data acquisition system architecture with multiprocessing capabilities that permits it to adapt the system’s sampling frequency throughout the experiment. The sampling rate can be controlled depending on the experiment’s specific requirements by using an external dc voltage signal or by defining user events through software. The system takes advantage of the high processing capabilities of the ITMS platform to implement a data reduction mechanism based in lossless data compression algorithms which are themselves based in periodic deltas

An MDE approach for Runtime Monitoring and Adapting Component-based Systems: Application to WIMP User Interface Architectures

In certain systems, software must be adapted at runtime to the requirements and changes occurring in the context. A strategy to achieve this goal is to model such systems as software architectures making use of the Component-based Software Engineering (CBSE). Thus, the system can be adapted through the reconfiguration of the software architectures. In this paper we present a schema for the adaptation of software architectures at runtime based on the system context observation. The software system is defined by means of architectural models at two levels: abstract and concrete. We use a trading process to regenerate concrete architectural models from their abstract definitions and a component repository. We also use Model-Driven Engineering (MDE) techniques to transform at runtime such models in order to achieve the system adaptation to the monitored context by using observers. This article describes a case study of component-based user interfaces to illustrate our approach.Ministerio de Ciencia e Innovación TIN2010-15588Ministerio de Ciencia e Innovación TRA2009-0309Ministerio de Ciencia e Innovación TIN2008-03107Junta de Andalucía TIC-611

Resolving Architectural Mismatches of COTS Through Architectural Reconciliation

The integration of COTS components into a system under development entails architectural mismatches. These have been tackled, so far, at the component level, through component adaptation techniques, but they also must be tackled at an architectural level of abstraction. In this paper we propose an approach for resolving architectural mismatches, with the aid of architectural reconciliation. The approach consists of designing and subsequently reconciling two architectural models, one that is forward-engineered from the requirements and another that is reverse-engineered from the COTS-based implementation. The final reconciled model is optimally adapted both to the requirements and to the actual COTS-based implementation. The contribution of this paper lies in the application of architectural reconciliation in the context of COTS-based software development. Architectural modeling is based upon the UML 2.0 standard, while the reconciliation is performed by transforming the two models, with the help of architectural design decisions.

Open Programming Language Interpreters

Context: This paper presents the concept of open programming language interpreters and the implementation of a framework-level metaobject protocol (MOP) to support them. Inquiry: We address the problem of dynamic interpreter adaptation to tailor the interpreter's behavior on the task to be solved and to introduce new features to fulfill unforeseen requirements. Many languages provide a MOP that to some degree supports reflection. However, MOPs are typically language-specific, their reflective functionality is often restricted, and the adaptation and application logic are often mixed which hardens the understanding and maintenance of the source code. Our system overcomes these limitations. Approach: We designed and implemented a system to support open programming language interpreters. The prototype implementation is integrated in the Neverlang framework. The system exposes the structure, behavior and the runtime state of any Neverlang-based interpreter with the ability to modify it. Knowledge: Our system provides a complete control over interpreter's structure, behavior and its runtime state. The approach is applicable to every Neverlang-based interpreter. Adaptation code can potentially be reused across different language implementations. Grounding: Having a prototype implementation we focused on feasibility evaluation. The paper shows that our approach well addresses problems commonly found in the research literature. We have a demonstrative video and examples that illustrate our approach on dynamic software adaptation, aspect-oriented programming, debugging and context-aware interpreters. Importance: To our knowledge, our paper presents the first reflective approach targeting a general framework for language development. Our system provides full reflective support for free to any Neverlang-based interpreter. We are not aware of any prior application of open implementations to programming language interpreters in the sense defined in this paper. Rather than substituting other approaches, we believe our system can be used as a complementary technique in situations where other approaches present serious limitations

Automatically generating adaptive logic to balance non-functional tradeoffs during reconfiguration

Increasingly, high-assurance software systems apply selfreconfiguration in order to satisfy changing functional and non-functional requirements. Most self-reconfiguration approaches identify a target system configuration to provide the desired system behavior, then apply a series of reconfiguration instructions to reach the desired target configuration. Collectively, these reconfiguration instructions define an adaptation path. Although multiple satisfying adaptation paths may exist, most self-reconfiguration approaches select adaptation paths based on a single criterion, such as minimizing reconfiguration cost. However, different adaptation paths may represent tradeoffs between reconfiguration costs and other criteria, such as performance and reliability. This paper introduces an evolutionary computationbased approach to automatically evolve adaptation paths that safely transition an executing system from its current configuration to its desired target configuration, while balancing tradeoffs between functional and non-functional requirements. The proposed approach can be applied both at design time to generate suites of adaptation paths, as well as at run time to evolve safe adaptation paths to handle changing system and environmental conditions. We demonstrate the effectiveness of this approach by applying it to the dynamic reconfiguration of a collection of remote data mirrors, with the goal of minimizing reconfiguration costs while maximizing reconfiguration performance and reliability

The SATIN component system - a metamodel for engineering adaptable mobile systems

Mobile computing devices, such as personal digital assistants and mobile phones, are becoming increasingly popular, smaller, and more capable. We argue that mobile systems should be able to adapt to changing requirements and execution environments. Adaptation requires the ability-to reconfigure the deployed code base on a mobile device. Such reconfiguration is considerably simplified if mobile applications are component-oriented rather than monolithic blocks of code. We present the SATIN (system adaptation targeting integrated networks) component metamodel, a lightweight local component metamodel that offers the flexible use of logical mobility primitives to reconfigure the software system by dynamically transferring code. The metamodel is implemented in the SATIN middleware system, a component-based mobile computing middleware that uses the mobility primitives defined in the metamodel to reconfigure both itself and applications that it hosts. We demonstrate the suitability of SATIN in terms of lightweightedness, flexibility, and reusability for the creation of adaptable mobile systems by using it to implement, port, and evaluate a number of existing and new applications, including an active network platform developed for satellite communication at the European space agency. These applications exhibit different aspects of adaptation and demonstrate the flexibility of the approach and the advantages gaine

A hybrid approach combining control theory and AI for engineering self-adaptive systems

Control theoretical techniques have been successfully adopted as methods for self-adaptive systems design to provide formal guarantees about the effectiveness and robustness of adaptation mechanisms. However, the computational effort to obtain guarantees poses severe constraints when it comes to dynamic adaptation. In order to solve these limitations, in this paper, we propose a hybrid approach combining software engineering, control theory, and AI to design for software self-adaptation. Our solution proposes a hierarchical and dynamic system manager with performance tuning. Due to the gap between high-level requirements specification and the internal knob behavior of the managed system, a hierarchically composed components architecture seek the separation of concerns towards a dynamic solution. Therefore, a two-layered adaptive manager was designed to satisfy the software requirements with parameters optimization through regression analysis and evolutionary meta-heuristic. The optimization relies on the collection and processing of performance, effectiveness, and robustness metrics w.r.t control theoretical metrics at the offline and online stages. We evaluate our work with a prototype of the Body Sensor Network (BSN) in the healthcare domain, which is largely used as a demonstrator by the community. The BSN was implemented under the Robot Operating System (ROS) architecture, and concerns about the system dependability are taken as adaptation goals. Our results reinforce the necessity of performing well on such a safety-critical domain and contribute with substantial evidence on how hybrid approaches that combine control and AI-based techniques for engineering self-adaptive systems can provide effective adaptation