On Evaluating Self-Adaptive Software

Software systems in domains like Smart Cities, the Internet of Things or autonomous cars are coined by a high degree of distribution across several independent computing devices and the requirement to be able to adjust themselves to varying situations in their operational environment. Self-adaptive software systems are a natural choice to implement such context-dependent software systems. A multitude of approaches already implement self-adaptive systems and some consider even distribution aspects.Yet, none of the existing solutions supports the coordination of adaptation operations spanning multiple independent nodes, which is necessary to ensure a consistent adaptation even in presence of network errors or node failures. In this paper, we tackle this challenge to execute adaptations in distributed self-adaptive software systems in a coordinated manner. We present a protocol that enables the self-adaptive software system to execute correlated adaptations on multiple nodes in a transactional manner ensuring an atomic and consistent transition of the distributed system from its source to the desired target configuration. The protocol is validated to be free of deadlocks for any given adaptation at any point in time using a model-checking approach. The performance of our approach is investigated in experiments that emulate the protocol's execution on real devices for different sizes of distributed applications and adaptation scenarios.

New generations of industrial control systems offer higher performance, are networked and can be controlled remotely. Following this progress, the complexity of such systems increases through heterogeneous systems, hardware and more capable software. This may lead to an increase of unreliability and insecurity. Self-adaptive software systems offer a mean of dealing with complexity by monitoring a control system, detecting anomalies and adapting the control system to problems. Regarding such methods, industrial control systems have the advantage of being less dynamic. The network topology is fixed, devices rarely change, and the functionality of all the resources is known in principle. In this work, we examine this advantage and present the potential of self-adaptive software systems. The context of the presented work is control systems for hydropower units.

Self-adaptive software (SAS) needs to handle complex software changes at runtime which are multiple, interrelated and unpredictable. However, existing specialized toolkits or platforms for SAS cannot fully assist the software in handling the changes with all the characteristics mentioned above at the same time. Therefore, based on the theories on MultiAgent Systems (MASs) and Search-based Software Engineering (SBSE), this paper proposes a reference architecture of SAS to handle the changes, and provides an Agent-based. Development toolkit and operAtion PlaTform for self-adaptive systems, called ADAPT, to support the development and operation of SAS according to the reference architecture. ADAPT can effectively handle complex changes with Agent technology and search-based planning method. It can also achieve automation in a way to reduce the burden of developers. Moreover, it provides adaptive abilities to SAS from the design time to runtime, reflecting the used methods in the whole process of software engineering.

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.

When computational process occurs in uncertain environments, the environmental changes often cause unpredictable influence on the computation. Self-adaptive software is one of the possible ways to tackle and handle this motivation. It evaluates its own behavior and surrounding environment, and adapts itself when the evaluation indicates that it is not accomplishing what the system is intended to do, or when better functionality is possible. Since one of the objectives of role models is to support object adaptation to the environment through role binding mechanism, it is expected that role modeling can be conveniently used to build self-adaptive systems. This paper provides some essential features or mechanisms of self-adaptive systems which are intended to be captured by adaptive role models. We propose Self-Epsilon model, an extension of our developed role-based model Epsilon, to combine and integrate all those features with role-based mechanisms into a single model. This paper also shows how the model can be applied to practically design and implement self-adaptive systems. We illustrate our approach through a case study of a simplified system of coordinated traffic jam monitoring used in some related work. The evaluation shows the reasonable and acceptable scalability of our model implementation in the framework.

In this research, we propose a lighting control system for environments with multiple light sources, including a natural light source and an artificial light source, based on a self–adaptive software control system. We also propose an algorithm for optimization between control devices in a multi-lighting environment, and evaluation methods for self-adaptive software in an Internet of Things environment. Based on these proposals, a simulation is carried out.

Self-adaptation ability is particularly desirable for mission critical software (MCS). This paper proposes a fuzzy control-based approach to provide a systematic, engineering, and intuitive way for programmers to achieve software self adaptation. This approach uses fuzzy logic to handle uncertainty in software, uses natural-language style to describe self-adaptation logic, and makes control visible in software. These greatly shorten the knowledge and semantics gap between control engineering and software engineering, and reduce the realization difficulty of software self-adaptation. We illustrate our approach through the development of an adaptive MCS application in process control systems.

In an environment of ever-growing numbers of IoT devices and distributed software systems, we face particular challenges regarding updates and maintenance of the underlying system. Generally, this maintenance of all nodes would require human interaction and is costly and time-consuming. A solution to that are self-adaptive software systems (SAS) [1], [2], which handle the growing complexity of distributed software systems by enabling run-time adaptation. Decentralized solutions [3] for SAS (dSAS) have been developed recently to eliminate single points of failures and bottlenecks compared to centralized approaches where the adaptation logic relies on a single node. However, dSAS require a sophisticated coordination mechanism to ensure a reliable adaptation process on multiple, decentralized devices. Existing approaches for the coordination of the adaptation execution [4]–[6] are based on concepts of the Two-Phase-Commit (2PC) protocol [7] to execute structural adaptations which modify the systems architecture depending on the current context. They ensure a consistent outcome of the adaptation on all nodes - either all adaptations are performed or rolled back - and thus, in any case, a consistent system configuration. In case of an error or disconnection during the adaptation, intermediate changes and modifications get reverted to their original state. This imposes a drawback for self-optimizing (i.e., increasing performance, efficiency, and quality) [8] adaptations, where the system should work even if one node fails to adapt. A rollback is non-essential when the whole system can continue working even if the execution failed for parts of the system. In our system model, this partial adaptation improves the overall task execution. Our work aims to tackle those issues of a strict transactional approach for adaptation by introducing a relaxed consistency constraint for dSAS. We present a protocol for coordinating adaptation operations performed by a set of distributed nodes that allows the different outcomes of participating nodes. Nodes detect inconsistencies and aim to recover when the failed node is ready again.

Self-adaptive software systems are those able to manage changing operating conditions dynamically and autonomously. Currently, most proposals in this field rely on an explicit representation of the constituent elements and goals of the system. This approach is suitable for systems where constituent elements are well known at design time. However, in systems where new elements may dynamically enter or leave the execution environment, it is not possible to obtain a predefined description of the system's architecture nor a complete specification of its goals. Paradigmatic examples of such systems can be found in ubiquitous computing, or dynamic web service discovery and composition, where new adaptability problems arise, such as the (dis)connection of unforeseen elements to an already running system, or ensuring properties of the composition among services, which cannot be addressed at static verification time since the state space of the system is not closed anymore. In this paper, we present our approach for the composition and resolution of interface mismatch among services in ubiquitous computing environments, dynamically reconfiguring the system as new services are integrated or disconnected.

Chapter 6 - Automated Inference Techniques to Assist With the Construction of Self-Adaptive Software

Software engineering principles: A systematic mapping study and a quantitative literature review

The article discusses the use of a constructive approach to building a program that is systematically cultivated in software engineering and made possible by a number of fundamental results obtained in programming theory. On the first, based on the structural theorem, reasonably was refused to use the go to operator and proposed a structured programming method, which provided a real way to create understandable programs. On the second, the concept of a subroutine, although it was used only to reduce routine work in the programming process, was the first means of modular presentation of programs. Later, the block and the subroutine formed the basis of block-oriented (procedural, subroutine) languages and the procedural (subroutine) programming method. In the third, to answer questions related to the definition of boundaries, sizes, and building module, the concept of connecting parts that make up a module and connections to indicate the connection between modules; specific modularization criteria; proposed a device module based on the concept of information hiding were introduced. The module is implemented in the programming language Modula, and later Modula-2. The concept of a module based on the modular (compositional) programming method. In the Simula 67 language, the foundations of object-oriented languages were introduced. They developed through the work on the concepts of inheritance, late binding and links, and were completed by the development of object-oriented languages and object-oriented (classification) programming. Thus, a framework for reuse, systematic reuse and component software development was created. Now these works are developing in the direction of research and creation of software as system of systems, using the link between system analysis and software engineering, and developing software system engineering. In the article, for learning the basics of programming, as a tool that allows clarifying the concept of program design, classification is used. As a classification feature - the level of encapsulation, which is based on the principles of software engineering – encapsulation and multi-level presentation -, is used. Applying the principle of encapsulation at different levels of representation program structure corresponding to different degrees of software abstraction, the concept of encapsulation level was obtained. Using this concept, you can find out the types of software constructions and the corresponding methods of programming (construction) programs. Using introduced the concepts and the constructive approach to building the program, the author created the didactics of the basics of programming, which was deployment through lectures for students of the specialty “Software Engineering” (121) and a textbook of the author for students and post-graduate students of the specialty. Problems in programming 2019; 3: 45-57

Over the past few years, we have witnessed a paradigm shift on the programming models and on architectural styles, which have been used to design and implement large-scale service-oriented systems. More specifically, the classic message-oriented and remote procedure call paradigm has gradually evolved to the resource-oriented architectural style, inspired by concepts pertinent to the World Wide Web. This shift has been primarily driven by multifaceted functional and non-functional requirements of Web enabled large-scale service offering systems. These requirements include enhanced interoperability, lightweight integration, scalability, enhanced performance, even looser coupling, and less dependence on shifting technology standards. As a consequence, several, and sometimes antagonistic, architectures, design patterns, and programming paradigms have emerged on a quest to overcome the constantly expanding enterprise software needs. In the context of resource-oriented architectures, the Representational State Transfer (REST) architectural style has gained considerable attention due to its simplicity, uniformity, and flexibility. More specifically, the potential for scalability and loose coupling, the uniformity of interfaces, and the efficient bridging of enterprise software systems with the Web are significant factors for software architects and engineers to consider REST when designing, implementing, composing, and deploying service-oriented systems. These issues stir discussion among academics and practitioners about how to properly apply REST constraints both with respect to the development of new enterprise systems and to the migration and adaptation of existing service-oriented systems to RESTful architectures. In this chapter, the authors discuss issues and challenges related to the adaptation of existing service-oriented systems to a RESTful architecture. First, they present the motivation behind such an adaptation need. Second, the authors discuss related adaptation theory, techniques, and challenges that have been recently presented in the research literature. Third, they identify and present several considerations and dimensions that the adaptation to REST entails, and the authors present frameworks to assess resource-oriented designs with regard to compliance to REST. Fourth, the authors introduce an adaptation framework process model in the context of enterprise computing systems and technologies, such as Model Driven Engineering and Service Component Architecture (SCA). Furthermore, they discuss open challenges and considerations on how such an adaptation process to REST can be extended, in order to yield systems that best conform to the REST architectural style and the corresponding REST constraints. Finally, the chapter is concluded with a summary and a discussion on the points raised and on some emerging trends in this area.

Software lifecycles are becoming an increasingly important issue for computational science & engineering (CSE) software. The process by which a piece of CSE software begins life as a set of research requirements and then matures into a trusted high-quality capability is both commonplace and extremely challenging. Although an implicit lifecycle is obviously being used in any effort, the challenges of this process-respecting the competing needs of research vs. production-cannot be overstated. Here we describe a proposal for a well-defined software life-cycle process based on modern Lean/Agile software engineering principles. What we propose is appropriate for many CSE software projects that are initially heavily focused on research but also are expected to eventually produce usable high-quality capabilities. The model is related to TriBITS, a build, integration and testing system, which serves as a strong foundation for this lifecycle model, and aspects of this lifecycle model are ingrained in the TriBITS system. Indeed this lifecycle process, if followed, will enable large-scale sustainable integration of many complex CSE software efforts across several institutions.

Software Engineering principles have connections with design science, including cybersecurity concerns pertaining to vulnerabilities, trust and reputation. The work of this paper surveys, identifies, establishes and explores these connections. Identification and addressing of security issues and concerns during the early phases of software development life cycle, especially during the requirements analysis and design phases; and importance of inclusion of security requirements have also been illustrated. In addition to that, effective and efficient strategies and techniques to prevent, mitigate and remediate security vulnerabilities by the application of the principles of trust modelling and design science research methodology have also been presented.