Search

In the past years, machine learning (ML) has become a popular approach to support self-adaptation. While ML techniques enable dealing with several problems in self-adaptation, such as scalable decision-making, they are also subject to inherent challenges. In this paper, we focus on one such challenge that is particularly important for self-adaptation: ML techniques are designed to deal with a set of predefined tasks associated with an operational domain; they have problems to deal with new emerging tasks, such as concept shift in input data that is used for learning. To tackle this challenge, we present \textit{lifelong self-adaptation}: a novel approach to self-adaptation that enhances self-adaptive systems that use ML techniques with a lifelong ML layer. The lifelong ML layer tracks the running system and its environment, associates this knowledge with the current tasks, identifies new tasks based on differentiations, and updates the learning models of the self-adaptive system accordingly. We present a reusable architecture for lifelong self-adaptation and apply it to the case of concept drift caused by unforeseen changes of the input data of a learning model that is used for decision-making in self-adaptation. We validate lifelong self-adaptation for two types of concept drift using two cases., Comment: This paper has been accepted in "Software Engineering for Adaptive and Self-Managing Systems" (SEAMS) 2022

Product line engineering emerged from a fruitful interaction of applied research in academia, industry research, and software engineering practice. SPLC was created as the primary venue to exchange ideas on this emerging topic and integrate the communities. Yet, today, SPLC is mostly regarded as an academic conference with little industry participation. Since a strong integration of academia and industry is often seen positive, here, we try to better understand motivations for practitioners to visit academic conferences like SPLC and the impact this has on such conferences. This analysis is based on nine systematic interviews with practitioners and researchers, who have been members of the SPLC community and other leading software engineering communities for a long time. Our preliminary results clarify the relevance and interest of practitioners and researchers to exchange knowledge and learn when attending scientific software engineering conferences such as SPLC. Yet, the results also highlight the differences between the goals of industry and academic conference participants, which often lead to inefficiencies and even barriers for constructive interaction at scientific conferences such as SPLC. We use this as a basis for pointing out further discussion points, both from the perspective of the interviewees as well as the authors.

Software systems are playing an increasingly important role in many domains of our society. To ensure that software will support the public good, software engineers, who create and maintain the software, shall adhere to ethical principles. A joint task force of IEEE and ACM has brought such a set of principles together in a Code of Ethics. These principles describe responsibilities for software engineers and guidelines to assist them when making decisions in the benefit of public good. With the emergence of computing systems that take autonomous decisions, there is growing consensus that new ethical principles will be required. Since self-adaptive systems are characterized by autonomy, the need for new principles applies to these systems. Based on the Code of Ethics and leveraging on ongoing initiatives, we suggest an initial set of new ethical principles for autonomous and self-adaptive systems as an inspiration for an extended Code of Ethics for this important class of systems.

When a self-adaptive system needs to adapt, it has to analyze the possible options for adaptation, i.e., the adaptation space. For systems with large adaptation spaces, this analysis process can be resource- and time-consuming. One approach to tackle this problem is using machine learning techniques to reduce the adaptation space to only the relevant adaptation options. However, existing approaches only handle threshold goals, while practical systems often need to address also optimization goals. To tackle this limitation, we propose a two-stage learning approach called Deep Learning for Adaptation Space Reduction (DLASeR). DLASeR applies a deep learner first to reduce the adaptation space for the threshold goals and then ranks these options for the optimization goal. A benefit of deep learning is that it does not require feature engineering. Results on two instances of the DeltaIoT artifact (with different sizes of adaptation space) show that DLASeR outperforms a state-of-the-art approach for settings with only threshold goals. The results for settings with both threshold goals and an optimization goal show that DLASeR is effective with a negligible effect on the realization of the adaptation goals. Finally, we observe no noteworthy effect on the effectiveness of DLASeR for larger sizes of adaptation spaces.

The technology-driven transformation process continues to spawn novel, growth-oriented digital application domains and platforms. The user base of these society-level software systems consists of a larger proportion of the community and that involve a large set of stakeholder groups. In case of an incident there is a public demand from a variety of stakeholders for multilateral intervention in order to correct the behavior of the software system. For software engineering as a technical discipline that has been fostered and matured in corporate and organizational context, this is a major challenge because it has to deal with a multitude of multidisciplinary stakeholders and their concerns. In order to stimulate further discussions, we discuss software governance on societal level and identify future research challenges of this increasingly relevant topic.

We present preliminary insights into the perception of researchers and practitioners of the software product line (SPL) community on previous, current, and future research efforts. We were particularly interested in up-and-coming and outdated topics and whether the views of academics and industry researchers differ. Also, we compared the views of the community with the results of an earlier literature survey published at SPLC 2018. We conducted a questionnaire-based survey with attendees of SPLC 2018. We received 33 responses (about a third of the attendees) from both, very experienced attendees and younger researchers, and from academics as well as industry researchers. We report preliminary findings regarding popular and unpopular SPL topics, topics requiring further work, and industry versus academic researchers' views. Differences between academic and industry researchers become visible only when analyzing comments on open questions. Most importantly, while topics popular among respondents are also popular in the literature, topics respondents think require further work have often already been well researched. We conclude that the SPL community needs to do a better job preserving and communicating existing knowledge and particularly also needs to widen its scope.

The study presented in this paper aims to provide evidence for the hypothesis that software product line research has been changing and that the works in industry and academia have diverged over time. We analysed a subset (140) of all (593) papers published at the Software Product Line Conference (SPLC) until 2017. The subset was randomly selected to cover all years as well as types of papers. We assessed the research type of the papers (academic or industry), the kind of evaluation (application example, empirical, etc.), and the application domain. Also, we assessed which product line life-cycle phases, development practices, and topics the papers address. We present an analysis of the topics covered by academic vs. industry research and discuss the evolution of these topics and their relation over the years. We also discuss implications for researchers and practitioners. We conclude that even though several topics have received more attention than others, academic and industry research on software product lines are actually rather in line with each other.

Empirical software engineering (SE) research is often criticized for poorly designed and reported studies, a lack of replications to build up bodies of knowledge, and little practical relevance. In this paper, we discuss issues in empirical software architecture research as an illustration of these issues in one subfield of SE and as a step towards better understanding empirical research in SE in general. Based on feedback from software architecture researchers and practitioners, we explore why, despite persistent discussions in the SE research community, there are still disagreements about why and how to conduct empirical research. Then, we explore how empirical SE research can progress beyond "one-off" studies and endless "new and exciting" results toward SE research as a mature science. This would allow us to establish foundations for evaluating existing and future empirical research and help researchers design and publish better studies.

Software systems are increasingly expected to cope with variable workloads, component failures and other uncertainties through self-adaptation. As such, self-adaptive software has been the subject of intense research over the past decade [3, 4, 9, 10].

© 2016 ACM. An increasingly important concern of software engineers is handling uncertainties at design time, such as environment dynamics that may be dificult to predict or requirements that may change during operation. The idea of self-Adaptation is to handle such uncertainties at runtime, when the knowledge becomes available. As more systems with strict requirements require self-Adaptation, providing guarantees for adaptation has become a high-priority. Providing such guarantees with traditional architecture-based approaches has shown to be chal-lenging. In response, researchers have studied the application of control theory to realize self-Adaptation. However, existing control-Theoretic approaches applied to adapt software systems have primarily focused on satisfying only a single adaptation goal at a time, which is often too restrictive for real applica-tions. In this paper, we present Simplex Control Adaptation, SimCA, a new approach to self-Adaptation that satisfies mul-tiple goals, while being optimal with respect to an additional goal. SimCA oers robustness to measurement inaccuracy and environmental disturbances, and provides guarantees. We evaluate SimCA for two systems with strict requirements that have to deal with uncertainties: An underwater vehicle system used for oceanic surveillance, and a tele-Assistance system for health care support. ispartof: pages:229-241 ispartof: Proceedings of the 2016 24th ACM SIGSOFT International Symposium on Foundations of Software Engineering vol:13-18-November-2016 pages:229-241 ispartof: International Symposium on Foundations of Software Engineering location:Seattle, WA, USA date:13 Nov - 18 Nov 2016 status: published

Continuous change changes everything; it introduces various uncertainties, which may harm the sustainability of software systems. We argue that integrating runtime adaptation and evolution is crucial for the sustainability of software systems. Realising this integration calls for a radical change in the way software is developed and operated. Our position is that we need to Design for Sustainability. To that end, we present: (i) the AdEpS model (Adaptation and Evolution processes for Sustainability) to handle and mitigate uncertainties by means of integrating runtime adaptation and evolution, and (ii) a set of engineering principles to design software systems that facilitate the application of the AdEpS model to build sustainable software.

Variability is commonly understood as the ability of a software system or software artifact (e.g., component) to be changed so that it fits a specific context. Variability allows adapting the structure of a software system, its behavior, or underlying processes. These adaptations are enabled through variation points and variants as options that can be selected at these variation points. So far, variability has mainly been studied in the classic software product line domain. However, variability is not limited to product lines or families, but imposes challenges on software development in general. Many other types of today's software systems are built with variability in mind; one prominent type is self-adaptive systems that are capable to adapt autonomously at runtime, another is dynamic software product lines that combines principles from product lines with self-adaptation. In this talk, I summarize the results of an extensive survey we recently performed on the use of variability in software systems in general [1]. Based on our findings, I present dimensions of variability in software engineering. This empirically grounded set of core dimensions provides a step towards an integrated perspective of variability in software systems, spanning across loosely coupled research areas in the software engineering community. To conclude, I outline some interesting opportunities for future research.

The 8th European Conference on Software Architecture (ECSA) held August 25-29, 2014 in Vienna Austria, organized four workshops. These workshops provide fora for exchanging ideas and theories that are still in an evolutionary stage. Workshops concretely focused on measurability of security in software architecture, software ecosystems and ecosystem architectures, domain-specific architecting, and engineering of systems of systems. In addition, ECSA organized an Architecture Tool Demos track, providing an opportunity for both practitioners and researchers to present and discuss the most recent advances and experiences in the field of software architecture by means of live tool presentations. Of 43 submissions in total, 29 papers were accepted for the events. This document provides brief summaries of the different events with pointers to further information.

The concept of variability is fundamental in software product lines and a successful implementation of a product line largely depends on how well domain requirements and their variability are specified, managed, and realized. While developing an educational software product line, we identified a lack of support to specify variability in quality concerns. To address this problem we propose an approach to model variability in quality concerns, which is an extension of quality attribute scenarios. In particular, we propose domain quality attribute scenarios, which extend standard quality attribute scenarios with additional information to support specification of variability and deriving product specific scenarios. We demonstrate the approach with scenarios for robustness and upgradability requirements in the educational software product line.

Variability is the ability of a software system or artifact to be adapted for specific contexts, in a preplanned manner. Many of today's software systems are built with variability in mind, e.g., product lines and families, self-adaptive systems, open platforms, or service-based systems that support dynamic runtime composition of web services. Variability is reflected in and facilitated through the software architecture. Also, as the software architecture is a reference point for many development activities and for achieving quality attributes, variability should be treated as a first-class and cross-cutting concern in software architecture. Therefore, the Second International Workshop on Variability in Software Architecture (VARSA 2012) aims at identifying critical challenges and progressing the state-of-the-art on variability in software architecture. VARSA 2012 is a follow-up of the First International Workshop on Variability in Software Architecture (VARSA 2011), held at WICSA 2011.

Self-adaptation has been widely recognized as an effective approach to deal with the increasing complexity and dynamicity of modern software systems. One major challenge in self-adaptive systems is to provide guarantees about the required runtime qualities, such as performance and reliability. Existing research employs formal methods either to provide guarantees about the design of a self-adaptive systems, or to perform runtime analysis supporting adaptations for particular quality goals. Yet, work products of formalization are not exploited over different phases of the software life cycle. In this position paper, we argue for an integrated formally founded approach to validate the required software qualities of self-adaptive systems. This approach integrates three activities: (1) model checking of the behavior of a self-adaptive system during design, (2) model-based testing of the concrete implementation during development, and (3) runtime diagnosis after system deployment. We illustrate the approach with excerpts of an initial study and discuss for each activity research challenges ahead.

One major challenge in self-adaptive systems is to assure the required quality properties. Formal methods provide the means to rigorously specify and reason about the behaviors of self-adaptive systems, both at design time and runtime. To the best of our knowledge, no systematic study has been performed on the use of formal methods in self-adaptive systems. As a result, there is no clear view on what methods have been used to verify self-adaptive systems, and what support these methods offer to software developers. As such insight is important for researchers and engineers, we performed a systematic literature review covering 12 main software engineering venues and 4 journals, resulting in 75 papers used for data collection. The study shows that the attention for self-adaptive software systems is gradually increasing, but the number of studies that employ formal methods remains low. The main focus of formalization is on modeling and reasoning. Model checking and theorem proving have gained limited attention. The main concerns of interest in formalization of self-adaptation are efficiency/performance and reliability. Important adaptation concerns, such as security and scalability, are hardly considered. To verify the concerns of interest, a set of new properties are defined, such as interference freedom, responsiveness, mismatch, and loss-tolerance. A relevant part of the studies use formal methods at runtime, but the use is limited to modeling and analysis. Formal methods can be applied to other runtime activities of self-adaptation, and there is a need for light-weight tools to support runtime verification.

We describe ongoing work in knowledge evolution management for autonomic software product lines. We explore how an autonomic product line may benefit from new knowledge originating from different source activities and artifacts at run time. The motivation for sharing run-time knowledge is that products may self-optimize at run time and thus improve quality faster compared to traditional software product line evolution. We propose two mechanisms that support knowledge evolution in product lines: online learning and knowledge sharing. We describe two basic scenarios for runtime knowledge evolution that involves these mechanisms. We evaluate online learning and knowledge sharing in a small product line setting that shows promising results.

A company's architecture knowledge is often personalized across specific people that share experience and knowledge in the field. However, this knowledge may be important for other stakeholders. Omitting the codification of the architecture knowledge may result in ad-hoc practices, which is particularly relevant for software evolution. In a collaboration with Egemin, an industrial manufacturer of logistic systems, we faced the problem with a lack of codified architecture knowledge in the context of the evolution of a software product line (SPL). In particular, maintainers lack the architecture knowledge that is needed to perform the evolution tasks of deployed products correctly and efficiently. Ad-hoc updates increase costs and harm the company's reputation. To address this problem, we developed an automated approach for evolving deployed systems of a SPL. Central in this approach are (1) a meta-model that codifies the architecture knowledge required to support evolution of a SPL, and (2) and algorithm that uses the architecture knowledge harvested from a deployed system based on the meta-model to generate the list of tasks maintainers have to perform to evolve the system. Evaluation of the approach demonstrates a significant improvement of the quality of system updates with respect to the correct execution of updates and the availability of services during the updates.

Control loops in self-adaptive systems are typically conceived as a sequence of four computations: Monitor-Analyze-Plan-Execute (MAPE). During the development of a traffic monitoring system with support for self-healing, we have noticed that simple MAPE loops are not sufficient to deal with the more complex failure scenarios. To manage the adaptations in these scenarios, we extend MAPE loops with support for two types of coordination. First, we introduce support for intra-loop coordination enabling MAPE computations within one loop to coordinate with one another. Intra-loop coordination allows the execution of multiple sub-loops within one control loop. Second, we introduce support for inter-loop coordination enabling MAPE computations across multiple loops to coordinate with one another. Inter-loop coordination allows the MAPE computations of different loops to coordinate the various phases of adaptations. We show how we used the extensions to support self-healing in the traffic monitoring system. We discuss an implementation framework that supports coordination of MAPE loops, and from our experiences offer recommendations for future research in this area.

Egemin, an industrial manufacturer of logistic systems is adopting a Software Product Line (SPL) approach to manage the development of their product portfolio. However, due to the intrinsic complexity of the logistic systems and lack of explicitly documented architectural knowledge evolution of the products is error-prone. Faulty updates increase maintenance costs and harm the company's reputation. Therefore, Egemin searches for a systematic solution that can improve their SPL evolution strategy.

Self-adaptive software systems are an emerging class of systems that adjust their behavior at runtime to achieve certain functional or quality of service objectives. The construction of such systems has shown to be significantly more challenging than traditional systems, partly because researchers and practitioners have been struggling with the lack of a precise method of describing, comparing, and evaluating alternative architectural choices. In this paper, we introduce a reference model, entitled FOrmal Reference Model for Self-adaptation (FORMS), which intends to alleviate this pressing issue. FORMS consists of a small number of formally specified modeling primitives that correspond to the key variation points within self-adaptive software systems, and a set of relationships that guide their composition. We present our experiences with applying FORMS to several existing systems, which not only demonstrates its ability to precisely illuminate their underlying characteristics, but also its potential as a method of rigorously specifying architectural patterns for this domain. © 2010 ACM. ispartof: pages:205-214 ispartof: Proceedings of the 7th International Conference on Autonomic Computing and Communications pages:205-214 ispartof: International Conference on Autonomic Computing and Communications location:Washington, DC, USA date:7 Jun - 11 Jun 2010 status: published

Self-management is considered as one of the crucial means for software systems to deal with changing demands at runtime. Self-management endows a software systems with the ability to adapt its structure or behavior without human intervention. Two different approaches are put forward for self-management: (1) the system components adapt their structure or behavior to changing requirements and cooperatively realize system adaptation - this approach can be considered as endogenous self-management; (2) the system is adapted through a control loop, i.e. the system is monitored to maintain an explicit representation of the system and based on a set of high-level objectives, the system structure or its behavior is adapted - this approach can be considered as exogenous self-management.In this paper, we introduce a hybrid software architecture that combines both approaches. A multi-agent system architecture allows agents to flexibly adapt their behavior to changes in their context providing cooperative system adaptation. Then, we extend the multi-agent system architecture with a decentralized control loop adding self-healing properties to the system. We use intelligent monitoring of traffic jams as an illustrative case.

The requirements of distributed software systems become increasingly complex. Among the aspects that characterize such a complexity are the inherent distribution of resources and activity - that makes global control practically infeasible and emphasizes the need for decentralized control - and the highly dynamic and changing operating conditions in which today's distributed applications operate - that calls for open and adaptive software.

An automatic guided vehicle (AGV) transportation system is a fully automated system that provides logistic services in an industrial environment such as a warehouse or a factory. Traditionally, the AGVs that execute the transportation tasks are controlled by a central server via wireless communication. In a joint effort between Egemin, an industrial manufacturer of AGV transportation systems, and DistriNet Labs research at the Katholieke Universiteit Leuven, we developed an innovative decentralized architecture for controlling AGVs. The driving motivations behind decentralizing the control of AGVs were new and future quality requirements such as flexibility and openness. At the software architectural level, the AGV control system is structured as a multi-agent system; the detailed design and implementation is object-oriented. In this paper, we report our experiences with developing the agent-based control system for AGVs. Starting from system requirements, we give an overview of the software architecture and we zoom in on a number of concrete functionalities. We reflect on our experiences and report lessons learned from applying multi-agent systems for real-world AGV control. ispartof: pages:663-674 ispartof: Companion of the 23th ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications pages:663-674 ispartof: ACM SIGPLAN International Conference on Object-Oriented Programming, Systems, Languages, and Applications location:Nashville, USA date:19 Oct - 23 Oct 2008 status: published

Assigning tasks to agents is complex, especially in highly dynamic environments. Typical protocol-based approaches for task assignment such as Contract Net have proven their value, however, they may not be flexible enough to cope with continuously changing circumstances. In this paper we study and validate the feasibility of a field-based approach for task assignment in a complex problem domain. In particular, we apply the field-based approach for task assignment in an AGV transportation system. In this approach, transports emit fields into the environment that attract idle AGVs. To avoid multiple AGVs driving towards the same transport, AGVs emit repulsive fields. AGVs combine received fields and follow the gradient of the combined fields, that guide them towards pick locations of transports. The AGVs continuously reconsider the situation of the environment and task assignment is delayed until the load is picked, improves the flexibility of the system. Extensive experiments indicate that the field-based approach out-performs the standard Contract Net approach on various performance measures, such as the average wait time of transports and throughput. Limitations of the field-based approach are an unequal distribution of wait times across different transports and a small increase of bandwidth occupation. Copyright 2006 ACM. ispartof: pages:842-849 ispartof: Proceedings of Fifth International Joint Conference on Autonomous Agents and Multiagent Systems vol:2006 pages:842-849 ispartof: Fifth International Joint Conference on Autonomous Agents and Multiagent Systems location:Hakodate, Japan date:8 May - 12 May 2006 status: published

The trend in agent-oriented software engineering is to consider multiagent systems (MASs) as a radically new way of engineering software. This position isolates agent-oriented software engineering from mainstream software engineering and could be one important reason why MASs are not widely adopted in industry yet. In this paper, we present another perspective on software engineering with MASs. We put forward MASs as software architecture. We give an overview of a reference architecture for situated MAS. This reference architecture extracts and generalizes common functions and structures from various applications we have studied and built. The reference architecture provides a blueprint for architectural design of MAS applications that share the come base of the systems it is derived from. Considering MASs essentially as software architecture paves the way to integration with mainstream software engineering. Copyright 2006 ACM. ispartof: pages:1314-1317 ispartof: Proceedings of the Fifth International Joint Conference on Autonomous Agents and Multiagent Systems vol:2006 pages:1314-1317 ispartof: Fifth International Joint Conference on Autonomous Agents and Multiagent Systems location:Hakodate, Japan date:8 May - 12 May 2006 status: published

Egemin N.V. is a Belgian manufacturer of Automatic Guided Vehicles -named E'GVs- and control software for automating logistics services in warehouses and manufactories using E'GVs. In a joint R&D project, Egemin and the Agent Wise research group are developing an innovative version of the E'GVs control system aimed to cope with new and future system requirements such as flexibility and openness. In this project, we exploit principles and mechanisms known from situated multi-agent systems for modelling and implementing a decentralized control system. Instead of a centralistic approach, where one computer system is in charge of numerous complex and time-consuming tasks (such as routing, collision avoidance, deadlock avoidance, etc.), we aim to provide the E'GVs with a considerable amount of autonomy. This allows to obtain a system that is far more flexible than the current software - the E'GVs adapt themselves to the current situation in their direct vicinity, order assignment is dynamic, the system can cope with E'GVs leaving the system (e.g. for maintenance) or adding new E'GVs, and so on. In this paper, we describe the architecture that is employed for implementing the control of the E'GV system. The implementation of the control software seamlessly integrates with E'nsor, the low-level vehicle control system. We illustrate a concrete control scenario in which two E'GVs coordinate their behavior to avoid collisions. Copyright 2005 ACM. ispartof: pages:67-74 ispartof: International Conference on Autonomous Agents and Multiagent Systems, Industry Track pages:67-74 ispartof: Autonomous Agents and Multiagent Systems location:Utrecht, The Netherlands date:25 Jul - 29 Jul 2005 status: published

International audience; Microservices architectures (MSAs) contribute to building complex distributed systems by decomposing monolithic systems into a set of independent microservices. This makes it possible to design, develop and deploy scalable and flexible systems. However, various unexpected changes could happen during execution, such as a service upgrade, a sudden increase of traffic, or an infrastructural failure. In this cases, how to react autonomously to these changes without outages becomes a challenge to consider. A PhD project has been launched to propose a self-healing microservices architecture, which can adapt dynamically to inside and outside changes without human intervention. In this paper, we present the first results of a systematic state of the art in the field of self-healing MSA systems. As an entry point of our research, we focus on self-healing triggered by upgrade changes. The initial contribution is a new component of a version manager in our self-healing MSA solution, in relation with service discovery elements. This approach can provide an autonomic version management on both the application level and the system level, and helps to control services upgrading changes. We plan to validate our proposition in a company project use case by deploying it in an emulated production environment, and applying a chaos engineering approach.