A key challenge when designing hybrid quantum-classical workflows is the identification of quantum candidates, that is, determining for which specific problems quantum advantages could potentially be achieved. When choosing between several candidates, it is crucial to consider the characteristics specific to the problem, as these can fundamentally determine how successful quantum or classical approaches will be. This implies that specialized expertise is needed to use hybrid quantum-classical workflows successfully. To address this challenge, we propose a domain-specific language (DSL) to express best-practices in solution strategies using a universal representation that is easy to use and share. This DSL provides a flexible approach to design hybrid quantum-classical workflows and to automate decisions for a wide range of problems, supporting decisions down to problem-specific details while remaining technically independent. Furthermore, we propose a framework that is built around our DSL that enables the execution of defined workflows using the ProvideQ toolbox as an orchestration layer. All contributions from this publication are open source.

The advancement of quantum hardware and the intricacies of quantum computing make well-designed quantum software increasingly necessary. Due to the interdisciplinarity of the field, it is crucial to understand the perspectives and specific needs of involved stakeholders, for example, to balance the desired level of abstraction with the exposition of (hardware)-specific details. In this work, we conduct a stakeholder-based analysis to identify personas of quantum software as a means of creating meaningful, user-tailored quantum software. We conducted an expert focus group at a Dagstuhl seminar in 2024 and qualitative interviews with practitioners at conference IEEE QCE in 2025, from which we derive eleven personas of potential users and stakeholders for quantum software. We discuss these personas regarding their use cases, interests, constraints and abstraction level.

Quantum simulation is a leading candidate for demonstrating practical quantum advantage over classical computation, as it is believed to provide exponentially more compute power than any classical system. It offers new means of studying the behaviour of complex physical systems, for which conventionally software-intensive simulation codes based on numerical high-performance computing are used. Instead, quantum simulations map properties and characteristics of subject systems, for instance chemical molecules, onto quantum devices that then mimic the system under study. Currently, the use of these techniques is largely limited to fundamental science, as the overall approach remains tailored for specific problems: We lack infrastructure and modelling abstractions that are provided by the software engineering community for other computational domains. In this paper, we identify critical gaps in the quantum simulation software stack-particularly the absence of general-purpose frameworks for model specification, Hamiltonian construction, and hardware-aware mappings. We advocate for a modular model-driven engineering (MDE) approach that supports different types of quantum simulation (digital and analogue), and facilitates automation, performance evaluation, and reusability. Through an example from high-energy physics, we outline a vision for a quantum simulation framework capable of supporting scalable, cross-platform simulation workflows.

Quantum software engineering is an emerging research field focusing on efficiently embedding the quantum programming paradigm into existing software ecosystems. A key aspect of this field is the realization of quantum algorithms using gate-based programming and the subsequent low-level optimization of the resulting quantum circuits, a process that is commonly performed by so-called transpilation pipelines. One significant challenge in these pipelines is determining which optimizations to apply to a given circuit. This decision is usually based on fixed default configurations that are uniformly applied to all circuits, frequently resulting in missed opportunities for more aggressive circuit optimization. In this work, we tackle this challenge by applying autotuning with supervised machine learning to develop an automated method for selection of transpiler passes. To train our machine-learning models, we employ feature-model based sampling to generate a representative dataset that examines how different combinations of Qiskit transpiler passes perform across thousands of circuits drawn from the state-of-the-art benchmarking suite MQT Bench. Using these data, we build a predictive model extension for the Qiskit transpilation pipeline that uses a machine learning model to automatically select combinations of transpiler passes aiming to achieve a maximum reduction in two-qubit gates. Our empirical evaluation shows that the combinations selected by our model are never outperformed by Qiskit's optimization levels, achieve on average an additional 19.1% - 32.4% reduction in two-qubit gates, and for some circuits finds reductions of up to 95.8% in cases where Qiskit achieves no reduction at all.

In model-based engineering, inter-disciplinary teams collaborate through models, which change over time for purposes of system development, what makes the proper description of such changes crucial for engineers. However, any change made by the engineer of one discipline will be difficult to understand by the engineers of other disciplines. To overcome this limitation, model-independent change descriptions can be derived instead, which preserve semantics of the changes and do not require model-specific knowledge. The two opposing approaches here are to describe changes using either informal language or formal notions of change. While informal language lacks objectivity and standardisation, formal notions of change lack human interpretability, and thus offering no support for inter-disciplinary communication. In this paper, we propose functions to map formally specified changes, represented in the approach of delta modelling, to change descriptions in model-independent language. In an exhaustive mixed-methods evaluation, we bridge the gap between the theoretical and the practical representation of changes. We quantitatively assess technical feasibility, with an implementation framework, and technical applicability, along a case study; and we qualitatively assess plausibility, practical applicability, and extensibility, in a user study. Our work shows a promising starting point for automated, model-independent description of changes in model-based engineering projects.

Agile methods have shaped the development of enterprise software systems during the last two decades. However, many modern cyber-physical systems (CPS) are still developed in as yet waterfall-like processes. The consequence is that CPS development misses out on such advantages of agile methods as handling changing requirements providing fast updates, or dealing with fast feedback on product quality. This is especially problematic today, when the software in CPS systems is more networked than ever, requiring updates to keep pace in an ever evolving network-connected technical environment, as well as patching too often software-induced cyber-security vulnerabilities. In sum, modern CPS must be developed so as to meet the need for updates at intervals of rapidly accelerating frequency. In this paper, we discuss the lack of systematic cross-model consistency management as one of the reasons why established agile methods are not used in CPS development. We present a road map that leads to systematic consistency management, laying the foundations of novel agile methods in CPS development. We discuss solutions in the context of model-driven automotive systems engineering. This domain especially can serve as a litmus test of agility in CPS development, because automotive systems engineering stands to benefit substantially from agile methods to address such pressing issues as strong assurance of dependability and configurability while also offering the flexibility of software over-the-air updates.

Thanks to the rapid progress and growing complexity of quantum algorithms, correctness of quantum programs has become a major concern. Pioneering research over the past years has proposed various approaches to formally verify quantum programs using proof systems such as quantum Hoare logic. All these prior approaches are post-hoc: one first implements a program and only then verifies its correctness. Here we propose Quantum Correctness by Construction (QbC): an approach to constructing quantum programs from their specification in a way that ensures correctness. We use pre- and postconditions to specify program properties, and propose sound and complete refinement rules for constructing programs in a quantum while language from their specification. We validate QbC by constructing quantum programs for idiomatic problems and patterns. We find that the approach naturally suggests how to derive program details, highlighting key design choices along the way. As such, we believe that QbC can play a role in supporting the design and taxonomization of quantum algorithms and software.

Empirical evidence has shown that variability bugs, i.e., bugs that only manifest if certain features of a configurable software system are selected, are not only a theoretical concept. Many variability bugs involve an intricate interplay of multiple features, turning them into so-called feature-interaction bugs. The strategy of t-wise interaction sampling can be used to identify variability bugs in highly-configurable systems. In this regard, the number of findings, as well as the overall sample size, typically increase with stronger interaction sampling (i.e., higher t values). In this paper, we aim to confirm these observations for vulnerabilities. We use the static source code analysis platform Vari-Joern to analyze real-world highly-configurable software systems for the presence of vulnerability patterns using t-wise interaction sampling of varying strength and compare the number of findings and associated sample sizes. We analyze the feature configurations associated with the vulnerability warnings raised by our approach to evaluate the presence of feature-interaction vulnerabilities. Our results show that stronger interaction sampling produces a greater number of findings at a higher computational cost, also for vulnerabilities. The increase in findings can be attributed to the identification of feature-interaction vulnerabilities involving an interplay of a greater number of features.

The SOTIF-standard (ISO 21448) requires scenario-based testing to verify and validate advanced driver assistance systems and automated driving systems. Feature modeling and sampling have shown promising results for generating scenarios considered test cases for scenario-based testing. Sampling strategies commonly applied for generating scenarios pursue coverage-criteria such as t-wise feature interaction, but ignore the number of selected features in a valid configuration. In the context of scenario generation, the number of features in a configuration correlates to the complexity of a scenario; thus, considering the number of features is relevant for "sufficiently" covering the scenario space and generating SOTIF-compliant scenarios. In this paper, we propose a complexity-aware coverage criterion embedded in selective sampling as a complexity-aware sampling strategy. Selective sampling approximates and replicates the distribution of the number of selected features of valid configurations. We apply selective sampling to generate scenarios for testing two advanced driver assistance systems. Our experiments demonstrate that selective sampling has the potential to improve scenario generation.

Building systems that do not violate confidentiality of data through accidental information leakage is an increasingly important challenge. This is especially true for security-critical systems that handle sensitive information. A well-known obstacle for building secure systems is that security properties, such as confidentiality, are only addressed in late development phases. To combat this, information flow control by-construction (IFbC) was proposed. Similarly to correctness-byconstruction for functional correctness, it aims at building systems such that they have a secure information flow by-construction. This paper presents an extension of that work in which we scale IFbC to the software architectural level for component-based systems. Our approach allows software architects to create a high-level design of the system using UML component models with explicit provided and required interfaces. We provide information flow specifications for the interfaces of components, which integrates the security concerns of the system in the design phase. We then demonstrate how the individual components can be realized according to information flow control by-construction, such that they adhere to their interface specifications. We provide rules for compatibility of interfaces and implementations that ensure confidential information flow, and prove that all component-based systems that can be constructed by our approach satisfy their security properties. In this way, we allow flexible architectural modeling of component-based systems combined with strong confidentiality guarantees from information flow control by-construction. Finally, we present the tool ArchFlow which assists developers with creating secure component-based systems.

Correctness-by-Construction engineering (CbC) is a refinement-based approach to develop functionally correct programs based on a formal specification. By correctly applying refinement rules during development, CbC enables detection of bugs during program construction, unlike post-hoc verification, which proves correctness only after implementation. Support for CbC engineering for non-functional properties is summarized under the term X-by-Construction (XbC). However, current XbC approaches are limited to information flow properties, leaving other non-functional properties of software quality, such as performance or reliability, unsupported. To address this gap, we present our vision for generalizing XbC to integrate non-functional properties into by-Construction engineering. In this way, we leverage the development of high-quality software through a refinementbased approach for future software engineering. With that, it will become possible to develop software ensuring that it not only exhibits functional correctness, but also non-functional guarantees by construction. Further, we propose ideas for ensuring energy efficiency in by-Construction engineering. We assess what it needs to integrate non-functional properties into by-Construction engineering and discuss arising challenges.

Many modern software-intensive systems, like mobile/cloud apps and operating systems like the Linux kernel, are highly configurable to adapt to diverse users’ needs and platforms. These systems comprise hundreds or even thousands of configuration options, which leads us to the infamous combinatorial-explosion problem: Every further (Boolean) yes/no configuration option doubles the number of possible configurations. However, many of these possible configurations are invalid due to different kinds of constraints, including non-functional properties, security threats, and economic considerations. In many critical domains, it is crucial to reliably identify and avoid the use of invalid configurations. However, in practice, a configuration model precisely describing the entire valid and invalid configuration spaces is often missing. This binary classification problem of purely Boolean tabular datasets seems to be a rewarding task for automated machine-learning tools: Starting from small samples of known configuration vectors labeled either valid or invalid, we want to train a configuration model that correctly bi-partitions the whole configuration space. Nevertheless, some characteristics of realistic configuration spaces are quite delicate, such as the inherent sparsity of the search space and the relatively small and unbalanced training sets available. In this paper, we present an in-depth experimental evaluation of the state-of-the-art automated machine learning tool AutoGluon for reconstructing software configuration spaces. We evaluate the performance regarding characteristics like configuration space size and imbalance. We show that applicability to real-world sized configuration spaces remains challenging using a benchmark from the software product line community.

Modern software-intensive systems comprise multiple engineering domains such as mechanics, electronics, and software. Traditionally, variability modeling approaches address variability by focusing primarily on a single domain. As a consequence, the management of multi-domain variability becomes a difficult task. One frequent outcome here is inconsistency, which means that the variability models of the different domains are incorrect. To address this problem, we propose a novel approach that combines consistency preservation for multi-domain models and delta-oriented variability modeling. By applying changes in form of deltas in one domain, our approach systematically derives corresponding deltas in other domains. In this way, we are able to ensure a consistent variant derivation process across domains. Our approach paves the way for further research on multi-domain variability management.

Quantum computers have the potential to solve certain problems faster than classical computers by exploiting quantum mechanical effects such as superposition. However, building high-quality quantum software is challenging due to the fundamental differences between quantum and traditional programming and the lack of abstraction mechanisms. To mitigate this challenge, researchers have introduced quantum patterns to capture common high-level design solutions to recurring problems in quantum software engineering. In order to utilize patterns as an abstraction level for implementation, a mapping between the theoretical patterns and the source code is required, which has only been addressed to a limited extent. To close this gap, we propose a framework for the automatic detection of quantum patterns using state- and circuit-based code analysis. Furthermore, we contribute a dataset for benchmarking quantum pattern detection approaches. In an empirical evaluation, we show that our framework is able to detect quantum patterns very accurately and that it outperforms existing quantum pattern detection approaches in terms of detection accuracy.

Hybrid solvers for combinatorial optimization problems combine the advantages of classical and quantum computing to overcome difficult computational challenges. Although their theoretical performance seems promising, their practical applicability is challenging due to the lack of a technological stack that can seamlessly integrate quantum solutions with existing classical optimization frameworks. We tackle this challenge by introducing the ProvideQ toolbox, a software tool that enables users to easily adapt and configure hybrid solvers via Meta-Solver strategies. A Meta-Solver strategy implements decomposition techniques, which splits problems into classical and quantum subroutines. The ProvideQ toolbox enables the interactive creation of such decompositions via a Meta-Solver configuration tool. It combines well-established classical optimization techniques with quantum circuits that are seamlessly executable on multiple backends. This paper introduces the technical details of the ProvideQ toolbox, explains its architecture, and demonstrates possible applications for several real-world use cases. Our proof of concept shows that Meta-Solver strategies already enable the application of quantum subroutines today, however, more sophisticated hardware is required to make their performance competitive.

Many of the envisioned use-cases for quantum computers involve optimisation processes. While there are many algorithmic primitives to perform the required calculations, all eventually lead to quantum gates operating on quantum bits, with an order as determined by the structure of the objective function and the properties of target hardware. When the structure of the problem representation is not aligned with structure and boundary conditions of the executing hardware, various overheads to degrade the computation may arise, possibly negating any possible quantum advantage. Therefore, automatic transformations of problem representations play an important role in quantum computing when descriptions (semi-)targeted at humans must be cast into forms that can be executed on quantum computers. Mathematically equivalent formulations are known to result in substantially different non-functional properties depending on hardware, algorithm and detail properties of the problem. Given the current state of noisy-intermediate scale quantum hardware (NISQ), these effects are considerably more pronounced than in classical computing. Likewise, efficiency of the transformation itself is relevant because possible quantum advantage may easily be eradicated by the overhead of transforming between representations. In this paper we consider a specific class of higher-level representations (polynomial unbiased binary optimisation problems), and devise novel automatic transformation mechanisms into widely used quadratic unconstrained binary optimisation problems that substantially improve efficiency and versatility over the state of the art. We also identify what influence factors of lower-level details can be abstracted away in the transformation process, and which details must be made available to higher-level abstractions.

AbstractThe Ernst Denert Award is already existing since 1992, which does not only honor the award winners but also the software engineering field in total. Software engineering is a vivid and intensively extending field that regularly spawns new subfields such as automotive software engineering, research software engineering, or quantum software engineering, covering specific needs but also generalizing solutions, methods, and techniques when they become applicable. This is the introductory chapter of the book on the Ernst Denert Software Engineering Award 2022. It provides an overview of the five nominated PhD theses.

AbstractQuantum software is becoming a key enabler for applying quantum computing to industrial use cases. This poses challenges to quantum software engineering in providing efficient and effective means to develop such software. Eventually, this must be reliably achieved in time, on budget, and in quality, using sound and well-principled engineering approaches. Given that quantum computers are based on fundamentally different principles than classical machines, this raises the question if, how, and to what extent established techniques for systematically engineering software need to be adapted. In this chapter, we analyze three paradigmatic application scenarios for quantum software engineering from an industrial perspective. The respective use cases center around (1) optimization and quantum cloud services, (2) quantum simulation, and (3) embedded quantum computing. Our aim is to provide a concise overview of the current and future applications of quantum computing in diverse industrial settings. We derive presumed challenges for quantum software engineering and thus provide research directions for this emerging field.