Self-adaptive (software) systems (SASs) dynamically adjust themselves to environmental changes during runtime (RT) to uphold Quality of Service (QoS) objectives. Designing and optimizing the adaptation strategies for SASs, particularly in relation to their impact on quality attributes, presents a significant challenge. The extensive design space of adaptation strategies typically requires automated exploration, as manual exploration is usually infeasible. While most existing approaches focus on RT optimization, which requires the implementation of the system, we examine the optimization of runtime adaptation strategies during design-time (DT) which we consider more effective in achieving QoS goals compared to purely RT-optimized strategies. Furthermore, DT analysis offers heuristically optimized strategies prior to implementation, enhancing quality properties such as performability. We aim to complement RT optimization by proposing a Model-based quality analysis (MBQA) approach at design-time that optimizes MAPE-K based adaptation strategies across all phases. In contrast, current approaches typically focus on optimizing specific phases, such as the analysis or planning phase, rather than the strategy as a whole. In this paper, we present a comprehensive DT approach for the optimization of adaptation strategies using evolutionary algorithms.

The emergence of Software-Defined Vehicles (SDVs) marks a paradigm shift in the automotive industry, where software plays a central role. However, despite the growing importance of SDVs, there is no uniform or generally accepted definition, leading to inconsistencies in research and industry perspectives. This paper aims to formulate a unified definition of SDV by conducting a Systematic Literature Review (SLR) of scientific papers and analyzing definitions provided by major car manufacturers and leading suppliers. By reviewing definitions and views from academia and industry, we identified central features that make up an SDV. Furthermore, based on the key findings of our SLR and research of industry views, we derived an industry-oriented definition of SDV. With our definition, we contribute to a uniform understanding of SDVs, fostering clearer communication, research alignment, and possibly the identification of further research directions.

Quantum computers, especially in the NISQ-Era, exhibit gate and measurement errors resulting in faulty executions. This leads to inaccurate and unreliable results, which are propagated to the remaining components of the software system in which the quantum component is embedded. In this paper, we adopt established and well-known architectural patterns from software engineering for fault-tolerant systems to deal with NISQ-induced uncertainties and to gain more accurate results. We adopt three existing patterns, namely the Voter, Comparison and Sparing pattern. We show how these patterns can be applied in the quantum computing setting and what modifications are necessary in this context. We evaluated our approach on an established benchmark for quantum circuits. The main focus of the evaluation was on whether (redundancy-based) fault-tolerant patterns outperform single instances of quantum components and whether the extra effort patterns entail is justified. Our results showed that each pattern provides an improvement over the average single component.

Deep Neural Networks (DNNs) continue to permeate various domains, including mission-critical systems. Their unverifiable nature, however, makes them inherently unreliable such that reliability quantification becomes essential to determine whether a DNN is suitable for operation. In this paper, we approach this problem by quantifying lower reliability bounds of DNNs. Our approach builds upon the widely known Conformal Predicition framework for determining reliability and discusses a sampling procedure for approximating the lower bound of reliability, leveraging properties of the data manifold. In our evaluation, we demonstrate the plausibility of the approximated reliability bounds and also show that incorrect predictions correlate with low reliability. The main benefits of our approach are that it enables the evaluation and comparison of DNNs in terms of their reliability on the one hand, and provides a way to incorporate them in model-based reliability analyses at the system level on the other.

With the ever-growing size and complexity of software used in vehicles, one differentiating factor perceivable for the user is the advanced functionality offered by AI-enabled software, e.g., emergency braking or lane keeping assistants. As always in the development of vehicles, safety is a paramount requirement for such software components. Analyses of the safety of such software components often rely on assumptions about the performance of the components and the usage of AI induces uncertainty, and the high resource demand of neural networks requires new forms of hardware components and system architectures. In addition, the development process of the software becomes more agile, requiring over-the-air updates and frequent analysis of compatibility and requirement fulfillment. To overcome the challenges arising from these developments regarding the analysis of AI-enabled systems, this paper proposes a new multi-level prediction system, that applies the concepts of model-based system engineering by employing architectural analysis and multi-level simulation. To gather the challenges stemming from these developments we reviewed the state of the art in the architectural analysis of AI-enabled systems in regard to safety and performance and how such systems can be assured and derived eight different challenges from them.

The field of Quantum Computing (QC) is increasingly becoming applicable for a wide range of computationally intensive problems. Especially Variational Quantum Algorithms (VQA) are promising as they allow dealing with the practical challenges of current quantum devices (also referred to as Noisy Intermediate-Scale Quantum devices). However, developing VQA-based solutions is not a straightforward process but involves several development phases, each with different design decisions and implications. In this paper, we share experiences made in developing VQA-based solutions for two different industrial case studies. Based on the solutions, we extracted five generic development phases quantum engineers must take into consideration when engineering quantum solutions. We have embedded the phases in a model (i.e. a phase model) to show their natural order and to illustrate the phases that require more development iterations. The main objective of this paper is not only to share and discuss our findings and experiences but also to provide the phase model as a starting point or guideline to structure the development process.

Performability is the classic metric for performance evaluation of static systems in case of failures. Compared to static systems, Self-Adaptive Systems (SASs) are inherently more complex due to their constantly changing nature. Thus software architects are facing more complex design decisions which are preferably evaluated at design-time. Model-Based Quality Analysis (MBQA) provides valuable support by putting software architects in a position to take well-founded design decisions about software system quality attributes over the whole development phase of a system. We claim that combining methods from MBQA and established performability concepts support software architects in this decision making process to design effective fault-tolerant adaptation strategies. Our contribution is a model-based approach to evaluate performability-oriented adaptation strategies of SAS at design-time. We demonstrate the applicability of our approach by a proof-of-concept.

Quantum computers open up new fields of application for hard-to-compute problems due to potential super-polynomial speedup. The design of quantum algorithms is complex and thus error-prone, which makes them a prime target for formal methods. We present our tool QIn to translate quantum circuits into a classical host language (Java). As a result, we can use any tool developed for the host language – and thereby leverage the full power of available formal methods for that language to reason about quantum circuits and create a verification/validation toolchain. Furthermore, QIn enables us to reason about hybrid programs, consisting of classical code and quantum circuits. This is crucial as, for the time being, only single subroutines of a program will be implemented on quantum computers. To show the possibilities of our approach, we present an example of a toolchain based on QIn. This toolchain relies on a software bounded-model checker and can prove the correctness of hybrid programs combining the host language Java with quantum circuits. We use the Java Modeling Language (JML) as the specification language and show the feasibility of our approach on several examples including a bounded version of Shor’s algorithm.

Although enormous progress has been made in Artificial Intelligence (AI), it entails new challenges. The growing complexity of learning tasks requires more complex AI models, which increasingly exhibit unreliable behaviour. This is of particular concern in safety-critical systems where AI is commonly used. Therefore, well-known architectural approaches have been adopted such as N-Version Programming or Simplex Architectures (denoted as Architectural Safeguards) to deal with the unreliable nature of AI. At design-time, however, it is difficult to identify an architectural safeguard that satisfies the reliability (or other quality) requirements of the system. In this paper, we present a model-based reliability analysis of AI-enabled systems to assess architectural safeguards at design-time taking into account the predictive uncertainty of AI components. We have validated our approach in a case study from the field of autonomous driving. Our results show that our approach not only enables the analysis of the impact of architectural safeguards on the overall reliability of an AI system but supports software engineers in decision-making.

Self-Adaptive Systems (SASs) adapt themselves to environmental changes during runtime to maintain Quality of Service (QoS) goals. Designing and optimizing the adaptation strategy of an SAS regarding its impact on quality properties is a challenging problem. Usually the design space of adaptation strategies is too large to be explored manually and, hence, requires automated support to find optimal strategies. Most approaches address this problem with optimization at runtime requiring the system is already implemented. However, one expects design-time optimized adaptation strategies to more effectively maintain QoS goals than purely runtime optimized strategies. Also formal guarantees benefit from designed and analysed strategies. We claim that design-time analysis and optimization of adaptation strategies improve in particular quality properties such as performability. To address the research gap between runtime optimization and the ability to make statements on the achieved quality, we envision an approach that builds upon the concept of Model-Based Quality Analysis (MBQA). Many approaches in MBQA address single aspects such as formal languages for adaptation strategies, architectural description languages or QoS prediction. However, they lack integration, which leads, for example to prediction approaches assuming rather static systems. In this paper, we envision an unified approach by considering several sub-approaches as building blocks for performability-based optimization of adaptation strategies at design-time.

We are currently experiencing the Noise Intermediate-Scale Quantum (NISQ) era where quantum algorithms are forced to be small in terms of qubits and gates used. This limitation makes it infeasible to apply quantum error correction. Consequently, running quantum algorithms on NISQ devices leads to gate and measurement errors and thus unreliable calculations. In this work, we approach this problem at the software architecture level. More precisely, we instantiate well-known and established architectural patterns for fault-tolerant systems in the context of quantum computing. Our preliminary results indicate that this approach is very promising as the patterns are applicable to the context of quantum programming and allow to gain more reliable results.

Engineering quantum software typically involves the implementation of well-known quantum algorithms as quantum software components and their embedding into a hybrid software architecture – executed on quantum hardware as well as classical hardware. While error models of modern microprocessors are quite similar and error mitigation is handled by compilers, this is not true for current quantum processors. The reliability of quantum software depends heavily on the quantum hardware used for execution. Quantum software engineers have to consider deployment decisions to estimate the reliability impact of quantum software components to the overall software architecture. We propose a model-based approach for the automated analysis of hybrid quantum software at design-time, taking into account the aforementioned reliability challenges. By extending the Palladio framework for modeling and simulating software architectures, we built upon well-established tooling. We support quantum software engineers making design decisions, by automatically exploring the design space including the impact of quantum hardware.

Advances in Artificial Intelligence (AI) are associated with a growing complexity of AI models, at the expense of transparency and comprehensibility. The black-box nature of AI components is of particular concern in safety-critical applications, as it can not be guaranteed whether a prediction is correct or not. Incorrect predictions, however, can have serious consequences, e.g., fatal collisions in autonomous driving. Therefore, we propose a novel method for safeguarding AI black-box components based on monitoring input data by using Self-Adaptive Systems (SAS). The presented concepts serve not only as a starting point for runtime approaches (e.g., models at runtime), but also for design-time approaches. As second contribution, we propose an approach for the validation of reconfiguration strategies of SAS's managing uncertain AI black-box components w.r.t. reliability objectives at design-time. We demonstrate the applicability of our approach by a proof-of-concept.

Advances in Machine Learning (ML) have brought previously hard to handle problems within arm's reach. However, this power comes at the cost of unassured reliability and lacking transparency. Overcoming this drawback is very hard due to the probabilistic nature of ML. Current approaches mainly tackle this problem by developing more robust learning procedures. Such algorithmic approaches, however, are limited to certain types of uncertainties and cannot deal with all of them, e.g., hardware failure. This paper discusses how this problem can be addressed at architectural rather than algorithmic level to assess systems dependability properties in early development stages. Moreover, we argue that Self-Adaptive Systems (SAS) are more suited to safeguard ML w.r.t. various uncertainties. As a step towards this we propose classes of dependability in which ML-based systems may be categorized and discuss which and how assurances can be made for each class.

Validating the effectiveness of reconfiguration strategies of Self-Adaptive Systems (SAS) regarding their impact on runtime quality properties is a challenging problem at design time. Since quality properties, such as performance or reliability, are effectively observable at runtime, it is inherently difficult to validate reconfiguration strategies at design-time during their design (e.g., during the definition of the software architecture). Furthermore, engineering and validating SAS at design-time involves uncertainties that are difficult to manage due to a dynamic operating environment. Therefore, we propose a novel model-based analysis approach that is driven by a temporal probabilistic model which captures the stochastic nature of the operating environment. The sampled trajectories through the state space serve as a basis for validation. Software engineers benefit from the framework by validating their reconfiguration strategy regarding quality objectives before implementation. The validated strategy serves as starting point for further model-based analyses such as correctness verification of adaptation logic or scenario-based analysis for local optimization.

The quality of modern industrial plants depends on the quality of the hardware used, as well as software. While the impact on quality is comparably well understood by making decisions about the choice of hardware components, this is less true for the decisions on software components. The quality of the resulting software system is strongly influenced by its software architecture. Especially in early project phases a software architect has to make many design decisions. Each design decision highly influences the software architecture and thus, the resulting software quality. However, the impact on the resulting quality of architecture design decisions is hard to estimate in advance. For instance, a software architect could decide to deploy software components on a dedicated server in order to improve the system performance. However, such a decision may increase the network overhead as side-effect. Model-driven approaches have been shown as promising techniques enabling design-time quality prediction for different quality attributes such as performance or reliability. However, such approaches are limited in their automated decision support to simple design decisions like the exchange of one single component. In this paper, we present an approach that automatically evaluates complex design decisions in software architecture models. Such design decisions require the reuse of subsystems with many involved components coming with inhomogeneous architectures. We evaluate our approach using a real-world example system demonstrating the benefits of our approach.