Abstract Self-adaptive systems can be realised as layered systems with a feedback loop: a managing system monitors a managed system, updates an internal model, and adjusts the managed system by means of controllers to maintain given requirements. For example, a digital twin coupled with its physical twin constitute such a self-adaptive system. As the managed system shifts between different stages in its lifecycle, these requirements, as well as the associated analysers and controllers, may need to change. The exact triggers for such shifts in a managed system are often hard to predict: they may be difficult to describe or even unknown. However, the shifts can generally be observed once they have occurred, in terms of changes in the system behaviour. This paper proposes an automated method for self-adaptation in self-adaptive systems to address shifts between lifecycle stages in a managed system. Our method is based on declarative descriptions of lifecycle stages for assets in a managed system and their associated counterparts in the managing system. Declarative lifecycle management provides a high-level, flexible method of self-adaptation for self-adaptive systems to reflect disruptive shifts between stages in a managed system.

Non-Functional Requirements (NFRs) play a critical role in driving self-adaptation in software systems. In Self-Adaptive Systems (SAS), satisfying multiple NFRs simultaneously introduces significant complexity, as these requirements often conflict—improving one NFR can negatively impact others. Addressing such tradeoffs becomes even more challenging due to the varying degrees of observability of NFRs, with some being fully observable and others only partially observable. Traditional approaches to SAS decision-making, such as those based on Markov Decision Processes (MDPs), often assume homogeneous observability, which limits their ability to address these challenges effectively. We argue that treating NFRs as having mixed observability—where some are fully observable and others are partially observable—enables more effective decision-making. How can SAS model and resolve tradeoffs among NFRs with mixed observability to achieve better outcomes? This article introduces SPECTRA, a multi-objective decision framework based on MDPs. SPECTRA addresses tradeoffs among NFRs by leveraging a multi-objective Mixed Observability Markov Decision Process (MOMDP), which models and handles the varying observability of NFRs effectively. The approach is evaluated using scenarios from MirrorNet, a realistic Remote Data Mirroring (RDM) system utilizing Software-Defined Networking (SDN). Results show that SPECTRA achieves higher utility values, faster policy planning, and more effective tradeoffs compared to existing approaches.

Self-Adaptive systems (SAS) must make runtime decisions to balance trade-offs among competing quality-of-service (QoS) requirements — such as cost, performance, and reliability — under uncertain and dynamic conditions. Current approaches to support this, such as Pareto-Based or utility-driven methods, often lack a quantifiable notion of what constitutes an acceptable loss in one requirement in favor of another. Inspired by practices in clinical trials, we propose a novel, requirements-centric application of Non-Inferiority (NI) Trials to decision-making in SAS. We reinterpret the NI margin, traditionally used to determine the acceptability of new treatments, as a stakeholder-specified tolerance threshold for QoS trade-offs. This offers a statistically grounded method to assess whether a new decision-making technique achieves ‘good enough’ performance according to stakeholder-defined thresholds, relative to established alternatives. We apply this approach to compare two reinforcement learning techniques in an SAS context and demonstrate how it captures nuanced trade-off decisions in QoS satisfaction. We argue that NI Trials can complement existing RE methods by introducing a principled mechanism for reasoning about acceptable degradation, supporting negotiation, monitoring, and prioritization of requirements in uncertain environments.

Large language models (LLMs) have recently seen huge growth in capability and usage. Within software engineering, LLMs are increasingly being used by developers to generate code. Code generated by an LLM can be seen essentially a continuous mapping from requirements to code. This represents a great opportunity within requirements engineering to use this mapping to provide traceability from requirements to LLM-generated code. The challenge is that the black-box nature of LLMs makes it difficult to trace requirements, while traditional approaches require extensive post-hoc testing or expert analysis. In this research preview, we explore the use of LLM explainability techniques to trace LLM-generated code back to requirements. By inspecting the gradients of LLM output, we develop a first attempt at tracing LLM inputs through to its generated code. We use this to estimate which low-level requirements have been met. Furthermore, through an automated iterative process, we re-query the LLM, instructing it to rewrite its code to meet the missing requirements. Our results suggest that the gradients of LLM outputs can be used to trace requirements through LLM code generation and that this traceability could potentially be used to improve generated code to better meet requirements. Future work is required to fully validate this result, but this represents a first step towards automatic traceability and verification of AI generated code.

Approaches that support the decision-making of self-adaptive and autonomous systems (SAS) often consider an idealized situation where (i) the system’s state is treated as fully observable by the monitoring infrastructure, and (ii) adaptation actions are assumed to have known, deterministic effects over the system. However, in practice, the system’s state may not be fully observable, and the adaptation actions may produce unexpected effects due to uncertain factors. This article presents a novel probabilistic approach to quantify the uncertainty associated with the effects of adaptation actions on the state of a SAS. Supported by Bayesian inference and POMDPs (Partially-Observable Markov Decision Processes), these effects are translated into the satisfaction levels of the non-functional requirements (NFRs) to, therefore, drive the decision-making. The approach has been applied to two substantial case studies from the networking and Internet of Things (IoT) domains, using two different POMDP solvers. The results show that the approach delivers statistically significant improvements in supporting decision-making for SAS.

to investigate the role of values in technology acceptance in general and in the context of the UK Covid Track and Trace App. A survey and interview study was conducted to elicit users’ perceptions of values in general, values in relation to choice of IT products and values which were influenced the decision to download (or not) the NHS Covid-19 Track and Trace App. Other non-value issues such as utility, price and recommendations were considered. Users’ value in life differ slightly from those considered important for selecting IT products. For general IT product decisions, functionality, trust and price with values equality, security and sustainability were important. For the Covid-19 App decision two values, helpfulness and equality, with recommendations/trust and operating system compatibility, were the main influences. Interview data indicated that downloader users were motivated by social responsibility and utility – being able to access workplaces and leisure venues – while non-downloaders had little perceived need for the App, combined with mistrust of the App's provenance (NHS and the Government) linked to security and privacy concerns. The implications for values in technology acceptance decisions are discussed.

A new focus for RE is investigated as ‘soft’ requirements which extends non-functional requirements/soft goals with a collection of people-oriented phenomena: values, motivations, emotions, and other socio-political issues that may influence the requirements specification. The convergence of RE with user experience (HCI) and technology acceptance from the information systems literature is reviewed from a temporal perspective: pre-use, through initial to longer-term use. A taxonomy of soft requirements is proposed that extends non-functional requirements and soft-goal concepts to direct attention towards user characteristics and beliefs that may have implications for functional as well as system support requirements, such as training, help, explanation and trust in software. A timeline model of soft and hard (functional) requirements is presented with a focus on customization, adaptation and other soft requirements to, improve product acceptance and persuade users to take appropriate action. The paper concludes with a research agenda for soft requirements to improve the probability of system acceptance and the effectiveness of applications that aim to influence people’s decisions and behaviour in internet apps and other discretionary-use applications.

Abstract Self-adaptive systems (SASs) are increasingly leveraging autonomy in their decision-making to manage uncertainty in their operating environments. A key problem with SASs is ensuring their requirements remain satisfied as they adapt. The trade-off analysis of the non-functional requirements (NFRs) is key to establish balance among them. Further, when performing the trade-offs it is necessary to know the importance of each NFR to be able to resolve conflicts among them. Such trade-off analyses are often built upon optimisation methods, including decision analysis and utility theory. A problem with these techniques is that they use a single-scalar utility value to represent the overall combined priority for all the NFRs. However, this combined scalar priority value may hide information about the impacts of the environmental contexts on the individual NFRs’ priorities, which may change over time. Hence, there is a need for support for runtime, autonomous reasoning about the separate priority values for each NFR, while using the knowledge acquired based on evidence collected. In this paper, we propose Pri-AwaRE, a self-adaptive architecture that makes use of Multi-Reward Partially Observable Markov Decision Process (MR-POMDP) to perform decision-making for SASs while offering awareness of NFRs’ priorities. MR-POMDP is used as a priority-aware runtime specification model to support runtime reasoning and autonomous tuning of the distinct priority values of NFRs using a vector-valued reward function. We also evaluate the usefulness of our Pri-AwaRE approach by applying it to two substantial example applications from the networking and IoT domains.

Abstract Modern software systems are increasingly expected to show higher degrees of autonomy and self-management to cope with uncertain and diverse situations. As a consequence, autonomous systems can exhibit unexpected and surprising behaviours. This is exacerbated due to the ubiquity and complexity of Artificial Intelligence (AI)-based systems. This is the case of Reinforcement Learning (RL), where autonomous agents learn through trial-and-error how to find good solutions to a problem. Thus, the underlying decision-making criteria may become opaque to users that interact with the system and who may require explanations about the system’s reasoning. Available work for eXplainable Reinforcement Learning (XRL) offers different trade-offs: e.g. for runtime explanations, the approaches are model-specific or can only analyse results after-the-fact. Different from these approaches, this paper aims to provide an online model-agnostic approach for XRL towards trustworthy and understandable AI. We present ETeMoX, an architecture based on temporal models to keep track of the decision-making processes of RL systems. In cases where the resources are limited (e.g. storage capacity or time to response), the architecture also integrates complex event processing, an event-driven approach, for detecting matches to event patterns that need to be stored, instead of keeping the entire history. The approach is applied to a mobile communications case study that uses RL for its decision-making. In order to test the generalisability of our approach, three variants of the underlying RL algorithms are used: Q-Learning, SARSA and DQN. The encouraging results show that using the proposed configurable architecture, RL developers are able to obtain explanations about the evolution of a metric, relationships between metrics, and were able to track situations of interest happening over time windows.

The main objective of decision-making in a self-adaptive system (SAS) is to continuously satisfy its requirements under environmental uncertainty. As the run-time context changes, the system may need to re-configure itself by making trade-offs between the non-functional requirements (NFRs) based on their individual priorities for satisfaction. We demonstrate Pri-AwaRE as an approach to support priority-aware decision-making in SASs by providing explicit runtime modelling and reasoning of individual priorities of NFRs. The approach also supports autonomous tuning of the priorities under dynamic situations to maintain the required satisfaction levels of NFRs. In this paper, we showcase how Pri-AwaRE is used in a substantial industrial case of Remote Mirroring using a simulation tool called RDMSim. Our results show that Pri-AwaRE offers the required satisfaction levels of NFRs by autonomously tuning of NFRs’ priorities according to new runtime environmental contexts.

The mobility of people is at the center of transportation planning and decision-making of the cities of the future. In order to accelerate the transition to zero-emissions and to maximize air quality benefits, smart cities are prioritizing walking, cycling, shared mobility services and public transport over the use of private cars. Extensive progress has been made in autonomous and electric cars. Autonomous Vehicles (AV) are increasingly capable of moving without full control of humans, automating some aspects of driving, such as steering or braking. For these reasons, cities are investing in the infrastructure and technology needed to support connected, multi-modal transit networks that include shared electric Autonomous Vehicles (AV). The relationship between traditional public transport and new mobility services is in the spotlight and need to be rethought. This article proposes an agent-based simulation framework that allows for the creation and simulation of mobility scenarios to investigate the impact of new mobility modes on a city daily life. It lets traffic planners explore the cooperative integration of AV using a decentralized control approach. A prototype has been implemented and validated with data of the city of Trento.

[Context/Motivation] A model at runtime can be defined as an abstract representation of a system, including its structure and behaviour, which exist alongside with the running system. Runtime models provide support for decision-making and reasoning based on design-time knowledge but, also based on information that may emerge at runtime and which was not foreseen before execution. [Questions/Problems] A challenge that persists is the update of runtime models during the execution to support up-to-date information for reasoning and decision-making. New techniques based on machine learning (ML) and Bayesian Learning offer great potential to support the update of runtime models during execution. Runtime models can be updated using these new techniques to, therefore, offer better-informed decision-making based on evidence collected at runtime. The techniques we use in this paper are based on a novel implementation of Partially Observable Markov Decision Processes (POMDPs). [Contribution] In this paper, we demonstrate how given the requirements specification, a Requirements-aware runtime model based on POMDPs (RaM-POMDP) is defined. We study in detail the nature of such runtime models coupled with consideration of the Bayesian inference algorithms and tools that provide evidence of unexpected/surprising changes in the environment. We show how the RaM-POMDPs and the MAPE-K loop offer the basis of the software architecture presented and how the required casual connection of runtime models is realized. Specifically, we demonstrate how according to evidence of changes in the systems, collected by the monitoring infrastructure and using Bayesian inference, the runtime models are updated and inferred (i.e. the first aspect of the causal connection). We also demonstrate how the running system changes its runtime model, producing therefore the corresponding self-adaptations. These self-adaptations are reflected on the managed system (i.e. the second aspect of the causal connection) to better satisfice the requirements specifications and improve conformance to its service level agreements (SLAs). The experiments have been applied to a real case study for the networking application domain.

Models are not static entities: they evolve over time due to changes. Changes may inadvertently and surprisingly violate constraints imposed. Therefore, the models need to be monitored for compliance. On the one hand, in traditional design-time applications, new and evolving requirements impose changes on a model over time. These changes may accidentally break design rules. Further, the growing complexity of the models may need to be tracked for manageability. On the other hand, newer applications use models at runtime; building runtime abstractions that are used to control a system. Adopters of these approaches will need to query the history of the system to check if the models evolved as expected, or to find out the reasons for a particular behavior. Changes over models at runtime are more frequent than changes over design models. To cover these demands, we argue that a flexible and scalable approach for querying the history of the models is needed to study the evolution and for compliance sake. This paper presents a set of extensions to a model query language inspired in the Object Constraint Language (the Epsilon Object Language) for traversing the history of a model, and for making temporal assertions that will allow the elicitation of historic information. As querying long histories may be costly, the paper presents an approach that annotates versions of interest as they are observed, in order to provide efficient recalls in possible future queries. The approach has been implemented in a model indexing tool, and is demonstrated through a case study from the autonomous and self-adaptive systems domain.

More than a decade ago, the research topic [email protected] was coined. Since then, the research area has received increasing attention. Given the prolific results during these years, the current outcomes need to be sorted and classified. Furthermore, many gaps need to be categorized in order to further develop the research topic by experts of the research area but also newcomers. Accordingly, the paper discusses the principles and requirements of [email protected] and the state of the art of the research line. To make the discussion more concrete, a taxonomy is defined and used to compare the main approaches and research outcomes in the area during the last decade and including ancestor research initiatives. We identified and classified 275 papers on [email protected], which allowed us to identify the underlying research gaps and to elaborate on the corresponding research challenges. Finally, we also facilitate sustainability of the survey over time by offering tool support to add, correct and visualize data.

Prioritization of non-functional requirements (NFRs) is a research field that needs more attention. We demonstrate ARRoW, a novel approach for automatic runtime reappraisal and update of the weights of NFRs given new evidence collected from the environment during the execution of the system. In this paper, we showcase how ARRoW is used in an substantial industrial case study. Our results shows how the approach offers a better-informed decision-making process by allowing the reappraisal and update of the weights of the NFRs in accordance to the newly detected environmental contexts.

[Context/Motivation] Decision-making for self-adaptive systems (SAS) requires the runtime trade-off of multiple non-functional requirements (NFRs) and the costs-benefits analysis of the alternative solutions. Usually, it requires the specification of weights for NFRs and decision-making strategies. Generally, these weights are defined at design-time with the support of previous experiences and domain experts. [Questions/Problems] Under some specific conditions detected at runtime, it can be the case that the weights assigned to the NFR at design time may not be suitable anymore at runtime. As a result, the system may not behave in the expected way and it may either execute unnecessary adaptations or miss crucial adaptations with a detrimental effect on the behaviour of the system. [New ideas/ early results] In this RE@Next! paper, we introduce a novel approach for automatic runtime reappraisal of the weights of NFRs given new evidence collected from the environment during the execution of the system. Our early results suggest, as expected, that the approach improves the decision-making process by allowing the reappraisal and update of the weights of the NFRs in accordance to the newly detected environmental context.

Modelling and reasoning with prioritization of non-functional requirements (NFRs) is a research field that needs more attention. We demonstrate RE-PREF, an approach that supports the modelling of NFRs and their preferences, and discovery of possible scenarios where badly chosen preferences can either make the runtime system miss or suggest unnecessary adaptations that may degrade the behavior of a self-adaptive system (SAS). Specifically, we showcase how RE-PREF is used in a remote data mirroring (RDM) system. The model of NFRs and the analysis of their preferences are enabled by using dynamic decision network (DDNs) and Bayesian Surprise.

No abstract available.

To benefit from the advantages that Cloud Computing brings to the IT industry, management policies must be implemented as a part of the operation of the Cloud. Among others, for example, the specification of policies can be used for the management of energy to reduce the cost of running the IT system or also for security policies while handling privacy issues of users. As cloud platforms are large, manual enforcement of policies is not scalable. Hence, autonomic approaches for management policies have recently received a considerable attention. These approaches allow specification of rules that are executed via rule-engines. The process of rules creation starts by the interpretation of the policies drafted by high-rank managers. Then, technical IT staff translate such policies to operational activities to implement them. Such process can start from a textual declarative description and after numerous steps terminates in a set of rules to be executed on a rule engine. To simplify the steps and to bridge the considerable gap between the declarative policies and executable rules, we propose a domain-specific language called CloudMPL. We also design a method of automated transformation of the rules captured in CloudMPL to the popular rule-engine Drools. As the policies are changed over time, code generation will reduce the time required for the implementation of the policies. In addition, using a declarative language for writing the specifications is expected to make the authoring of rules easier. We demonstrate the use of the CloudMPL language into a running example extracted from a management energy consumption case study.

Self-adaptive systems (SASs) should be able to adapt to new environmental contexts dynamically. The uncertainty that demands this runtime self-adaptive capability makes it hard to formulate, validate and manage their requirements. QuantUn is part of our longer-term vision of requirements reflection, that is, the ability of a system to dynamically observe and reason about its own requirements. QuantUn's contribution to the achievement of this vision is the development of novel techniques to explicitly quantify uncertainty to support dynamic re-assessment of requirements and therefore improve decision-making for self-adaption. This short paper discusses the research gap we want to fill, present partial results and also the plan we propose to fill the gap.

A self-adaptive system adjusts its configuration to tolerate changes in its operating environment. To date, requirements modeling methodologies for self-adaptive systems have necessitated analysis of all potential system configurations, and the circumstances under which each is to be adopted. We argue that, by explicitly capturing and modelling uncertainty in the operating environment, and by verifying and analysing this model at runtime, it is possible for a system to adapt to tolerate some conditions that were not fully considered at design time. We showcase in this paper our tools and research results.

In earlier work we proposed the idea of requirements-aware systems that could introspect about the extent to which their goals were being satisfied at runtime. When combined with requirements monitoring and self adaptive capabilities, requirements awareness should help optimize goal satisfaction even in the presence of changing run-time context. In this paper we describe initial progress towards the realization of requirements-aware systems with REAssuRE. REAssuRE focuses on explicit representation of assumptions made at design time. When such assumptions are shown not to hold, REAssuRE can trigger system adaptations to alternative goal realization strategies.

Requirements awareness should help optimize requirements satisfaction when factors that were uncertain at design time are resolved at runtime. We use the notion of claims to model assumptions that cannot be verified with confidence at design time. By monitoring claims at runtime, their veracity can be tested. If falsified, the effect of claim negation can be propagated to the system's goal model and an alternative means of goal realization selected automatically, allowing the dynamic adaptation of the system to the prevailing environmental context.

Computational reflection is a well-established technique that gives a program the ability to dynamically observe and possibly modify its behaviour. To date, however, reflection is mainly applied either to the software architecture or its implementation. We know of no approach that fully supports requirements reflection- that is, making requirements available as runtime objects. Although there is a body of literature on requirements monitoring, such work typically generates runtime artefacts from requirements and so the requirements themselves are not directly accessible at runtime. In this paper, we define requirements reflection and a set of research challenges. Requirements reflection is important because software systems of the future will be self-managing and will need to adapt continuously to changing environmental conditions. We argue requirements reflection can support such self-adaptive systems by making requirements first-class runtime entities, thus endowing software systems with the ability to reason about, understand, explain and modify requirements at runtime.

Requirements are sensitive to the context in which the system-to-be must operate. Where such context is well understood and is static or evolves slowly, existing RE techniques can be made to work well. Increasingly, however, development projects are being challenged to build systems to operate in contexts that are volatile over short periods in ways that are imperfectly understood. Such systems need to be able to adapt to new environmental contexts dynamically, but the contextual uncertainty that demands this self-adaptive ability makes it hard to formulate, validate and manage their requirements. Different contexts may demand different requirements trade-offs. Unanticipated contexts may even lead to entirely new requirements. To help counter this uncertainty, we argue that requirements for self-adaptive systems should be run-time entities that can be reasoned over in order to understand the extent to which they are being satisfied and to support adaptation decisions that can take advantage of the systems' self-adaptive machinery. We take our inspiration from the fact that explicit, abstract representations of software architectures used to be considered design-time-only entities but computational reflection showed that architectural concerns could be represented at run-time too, helping systems to dynamically reconfigure themselves according to changing context. We propose to use analogous mechanisms to achieve requirements reflection. In this paper we discuss the ideas that support requirements reflection as a means to articulate some of the outstanding research challenges.

Increasingly software systems are required to survive variations in their execution environment without or with only little human intervention. Such systems are called ldquoeternal software systemsrdquo. In contrast to the traditional view of development and execution as separate cycles, these modern software systems should not present such a separation. Research in MDE has been primarily concerned with the use of models during the first cycle or development (i.e. during the design, implementation, and deployment) and has shown excellent results. In this paper the author argues that an eternal software system must have a first-class representation of itself available to enable change. These runtime representations (or runtime models) will depend on the kind of dynamic changes that we want to make available during execution or on the kind of analysis we want the system to support. Hence, different models can be conceived. Self-representation inevitably implies the use of reflection. In this paper the author briefly summarizes research that supports the use of runtime models, and points out different issues and research questions.

Self-adaptive systems have the capability to autonomously modify their behaviour at run-time in response to changes in their environment. Self-adaptation is particularly necessary for applications that must run continuously, even under adverse conditions and changing requirements; sample domains include automotive systems, telecommunications, and environmental monitoring systems. While a few techniques have been developed to support the monitoring and analysis of requirements for adaptive systems, limited attention has been paid to the actual creation and specification of requirements of self-adaptive systems. As a result, self-adaptivity is often constructed in an ad-hoc manner. In this paper, we argue that a more rigorous treatment of requirements explicitly relating to self-adaptivity is needed and that, in particular, requirements languages for self-adaptive systems should include explicit constructs for specifying and dealing with the uncertainty inherent in self-adaptive systems. We present RELAX, a new requirements language for self-adaptive systems and illustrate it using examples from the smart home domain.

Engineering adaptive software is an increasingly complex task. Here, we demonstrate Genie, a tool that supports the modelling, generation, and operation of highly reconfigurable, component-based systems. We showcase how Genie is used in two case-studies: i) the development and operation of an adaptive flood warning system, and ii) a service discovery application. In this context, adaptation is enabled by the Gridkit reflective middleware platform.