# Challenges of Quantum Software Engineering for the Next Decade: The Road
Ahead

Juan M. Murillo, Jose Garcia-Alonso, Enrique Moguel  University of
ExtremaduraSpain ,  Johanna Barzen, Frank Leymann  University of Stuttgart.
Institute of Architecture of Application SystemsInstitute of Architecture of
Application SystemsGermany ,  Shaukat Ali  Simula Research Laboratory and
Oslo Metropolitan UniversityNorway ,  Tao Yue  Beihang UniversityChina ,
Paolo Arcaini  National Institute of InformaticsJapan ,  Ricardo Pérez,
Ignacio García Rodríguez de Guzmán, Mario Piattini  University of Castilla-La
ManchaSpain ,  Antonio Ruiz-Cortés  I3US Institute, SCORE Lab, Universidad de
SevillaSpain ,  Antonio Brogi  University of PisaItaly ,  Jianjun Zhao  Kyushu
UniversityJapan ,  Andriy Miranskyy  Toronto Metropolitan UniversityCanada and
Manuel Wimmer  Johannes Kepler University LinzAustria

###### Abstract.

As quantum computers evolve, so does the complexity of the software that they
can run. To make this software efficient, maintainable, reusable, and cost-
effective, quality attributes that any industry-grade software should strive
for, mature software engineering approaches should be applied during its
design, development, and operation. Due to the significant differences between
classical and quantum software, applying classical software engineering
solutions to quantum software is difficult. This resulted in the birth of
Quantum Software Engineering as a discipline in the contemporary software
engineering landscape. In this work, a set of active researchers is currently
addressing the challenges of Quantum Software Engineering and analyzing the
most recent research advances in this domain. This analysis is used to
identify needed breakthroughs and future research directions for Quantum
Software Engineering.

##  1\. Introduction

In the last two decades, quantum computing has attracted increasing interest.
Researchers have been actively experimenting with algorithms that once were
purely theoretical, thanks to the advent of publicly accessible quantum
computers. Such algorithms can sometimes solve problems in a reasonable amount
of time that are beyond the reach of classical computers (Serrano et al.,
2022). Quantum algorithms can also provide significant operational advantages,
such as perfect training of Quantum Neural Networks with only a few highly
entangled training data (Mandl et al., 2024). The industry has been captivated
by this, which has led to increased investment. Commercial quantum computers
are already available from manufacturers such as D-Wave, IBM, IonQ, Rigetti,
or Quantinuum. There is a focus on developing more stable Quantum Processing
Units (QPU) to leave behind the noisy intermediate-scale quantum (NISQ) era
(Preskill, 2018). Despite the limitations of NISQ computers (Leymann and
Barzen, 2020), they have already shown their utility by solving problems using
approximations, such as Variational Quantum Algorithms (Cerezo et al., 2021).
Thus, the possibility of industrialized quantum software is on the horizon.

Nevertheless, historical lessons from the field of software engineering
underscore that, even with powerful computers available, the industry will
only adopt them if quantum software can be produced in a repeatable,
efficient, maintainable, reusable, and cost-effective way (Sametinger, 1997).
Currently, quantum software lacks established procedures similar to those in
classical computing. Striving to meet these standards hand in hand with
Quantum Software Engineering (QSE) is becoming a priority (Piattini et al.,
2021; Ali et al., 2022; Zhao, 2020).

QSE has been defined as “the use of sound engineering principles for the
development, operation, and maintenance of quantum software111In this work,
“quantum software” refers to software that runs on a quantum computer. In a
broader sense, because all computing on quantum computers involves classical
parts, software that utilizes quantum computers is naturally hybrid.” (Zhao,
2020). The main challenge of QSE is to bring the knowledge and practices of
classical software engineering into the domain of quantum software (Stepney et
al., 2004), as well as to develop the new required ones. In recent years, the
research community has taken many steps in that direction. For instance, a
growing consensus is that quantum software will adopt a hybrid model, blending
classical and quantum computing (Miranskyy and Zhang, 2019; Weigold et al.,
2021). This will demand technologies enabling seamless component interaction
across different computing environments. Leveraging Service-Oriented Computing
(SOC) principles for interoperable interfaces and Service Engineering
methodologies will be essential for effectively designing and managing these
quantum services. Also, we know that the testing of quantum systems
considerably differs from that of classical systems due to the particularities
of quantum states (Ali and Yue, 2023b). The development of specific practices
for quantum software testing is required. Other software engineering
practices, such as requirements engineering, though less concerned at the
current stage due to the lack of real-world applications, will also differ
from the classical counterpart as mentioned in (Yue et al., 2023a; Saraiva et
al., 2021).

This paper aims to provide a broad overview of the main problems associated
with each of the different areas of QSE. In each area, recent research
developments in QSE are highlighted, and future challenges for researchers in
QSE for the next decade are discussed.

The paper is outlined as follows. Section 2 discusses the growth of QSE
research in recent years. Section 3 highlights the most active areas of QSE,
presents challenges, and provides an outlook for the next decade. Section 4
concludes the paper.

##  2\. Research interest in Quantum Software Engineering

QSE has emerged as a discipline of its own within software engineering. Beyond
its initial mention in 2002, it was described as one of the grand challenges
in computer science research: “the development of a full discipline of Quantum
Software Engineering, ready to exploit the full potential of commercial
quantum computer hardware, once it arrives, projected to be around 2020”
(Clark and Stepney, 2002).

Though the initial impetus for developing QSE was a reaction to the expected
advances in quantum hardware, it was still a few years before quantum hardware
and simulators became available. In 2016, IBM released its first gate-based
quantum computer and online simulator (IBM, 2016). Other vendors followed
suit. Clearly, these facts influenced QSE’s growth.

Since then, several conference venues have started to appear that have
gathered many contributions to the emerging field of QSE. While not all venues
focus solely on QSE, many include QSE papers. In particular, some events are
noteworthy for the number of editions they have held. These include the
International Workshop on Quantum Software Engineering (Q-SE), which this year
celebrates already its fifth edition and is collocated with the ACM/IEEE
International Conference on Software Engineering (ICSE); the IEEE
International Conference on Quantum Software (QSW), which this year celebrates
its third edition and is organized under the umbrella of IEEE World Congress
on Services; or others that form part of the IEEE Quantum Week, such as the
International Workshop on Quantum Software Engineering and Technology (Q-SET),
and the IEEE International Conference on Quantum Computing and Engineering
(QCE).

Interest in QSE extends to journals, with IEEE Transactions on Quantum
Engineering and ACM Transactions on Quantum Computing addressing QSE (among
other topics). Elsevier Journal of Systems and Software and Information and
Software Technology have introduced special issues on QSE. In addition, there
is a Continuous Special Section in ACM Transactions on Software Engineering
and Methodology.

The rising interest in QSE can be indirectly measured by counting the number
of publications that include the term “Quantum Software Engineering” in their
content. Figure 1 shows the annual number of such publications indexed in
Scopus and Google Scholar222For replication purposes, the specific
publications considered are listed in (Moguel et al., 2024).. As shown in the
figure, the first QSE publications appeared in 2002–2007 (as mentioned above)
highlighting the need for QSE to be developed for the emerging quantum
computing domain. Several publications about QSE surfaced again starting in
2012, mainly focused on the needs detected by quantum computing scientists
when developing quantum software. From 2020, the number of publications
increased significantly (perhaps due to the increased availability of
simulators and platforms). A milestone of more than 200 publications was
reached in 2023.

Figure 1. Papers on QSE over time

##  3\. Quantum Software Engineering Active Research Areas

This section examines some of the research conducted in different areas of
QSE. We do not aim to provide a systematic analysis. Instead, we strive to
gather QSE works and opinions from active researchers in the field regarding
the most relevant challenges they anticipate in QSE for the upcoming decade.

###  3.1. Service-Oriented Computing

In classical software engineering, Service-Oriented Computing (SOC) is defined
as a paradigm to support the development of interoperable, distributed
applications where services are regarded as autonomous entities (Papazoglou et
al., 2007). In the last few years, research in this field has covered a range
of topics, including the provisioning and aggregation of basic services, the
composition of complex systems through the coordination of services, and the
management and monitoring of services deployed in the cloud or on-premise.

Quantum hardware and software offered in the cloud allow researchers to access
quantum computing resources over the internet without the need to own quantum
computing hardware. Several companies and institutions provide cloud-based
quantum computing services like IBM already mentioned above, or others like
Amazon Braket or Microsoft through Azure Quantum. This makes it easier for a
broader audience to explore and develop quantum software. These platforms
offer access to a variety of quantum processors and simulators, along with
tools and environments to create, run, and test quantum algorithms.

In this scenario, it might appear that using classical SOC principles is
straightforward. Nevertheless, given the incipient state of quantum hardware
technology, classical SOC approaches are not directly transferable to quantum
software development.

The distinct and complex interaction model required for quantum computing
challenges the straightforward application of conventional SOC frameworks, so
it is necessary to re-evaluate how these principles can be adapted or
redefined for the field of quantum computing. To address these difficulties,
several research groups have recently focused on Quantum Service-Oriented
Computing with the aim of bringing its benefits to Quantum Software
Engineering.

One of the first approaches in this sense was presented in (Wild et al.,
2020). In this work, the authors presented TOSCA4QC, introducing two
deployment modeling styles based on the Topology and Orchestration
Specification for Cloud Applications (TOSCA) standard for automating the
deployment and orchestration of quantum applications. From there, this
research group has provided several contributions in the Quantum SOC domain.
In (Weder et al., 2021), the authors focus on the need for additional
mechanisms for orchestration in hybrid quantum applications over classical
applications. In (Beisel et al., 2022), they provide a service ecosystem for
the execution, based on workflows, of Variational Quantum Algorithms. In
(Weder et al., 2023), they introduce a method to detect parts of a hybrid
workflow that can be optimized at runtime. These works, as a whole, provide a
formalized and complete toolkit to bring the benefits of working with
workflows for the deployment and execution of hybrid quantum applications.

From a different perspective, in (Rojo et al., 2021), the authors analyze the
problems and difficulties of developing hybrid quantum applications using a
service-oriented approach. From there, this research group has also provided
several contributions in this domain. In (Garcia-Alonso et al., 2021), the
authors proposed adapting the API Gateway pattern to be combined with quantum
software. In (Romero-Álvarez et al., 2022), they extend the Open API standard
to develop quantum services. In (Romero-Álvarez et al., [n. d.]), they focus
on using DevOps techniques to enable the continuous deployment of quantum
software. Finally, on (Bisicchia et al., 2023), they propose a technique for
distributing quantum computations between different computers by splitting the
shots required for a given quantum task among different QPUs. All these works
provide an approach that brings the development of hybrid quantum applications
closer to the tools and techniques usually employed in SOC.

These examples show the potential benefits of applying the principles of
Service-Oriented Computing to Quantum Software Engineering. However, to
exploit the full potential of service-orientation, several challenges must be
addressed first. Specifically:

Interoperability. As different technologies and platforms for Quantum
Computing keep emerging, the need for industry standards or proposals of such
made by researchers becomes clear. Some examples exist, like OpenQASM
standardized by several companies, that showcase the advantages of such
standardization. But there are still various assembly-level languages, thus
efforts for creating some kind of intermediate format (like QIR) are needed in
order to progress with this challenge. Similarly, the creation of standard
APIs to interact with QPUs will significantly improve interoperability and
pave the way for researchers to create a new generation of quantum service-
oriented computing tools and solutions.

Platform independence. The capabilities of current QPUs vary significantly, as
well as the environments on which those QPUs are offered through the cloud,
including the availability of hybrid runtimes or other different software-
related performance enhancements. This generates great variability in the
features available for quantum software developers. However, it also creates
significant dependence on the software on the platform in which it will be
run, as well as vendor lock-in between the hardware company and the
developers. Classical service-oriented computing has shown the benefits of
platform independence, and therefore, additional efforts are needed in the
quantum domain to obtain similar advantages.

Demand and Capacity Management. Managing demand and capacity to support hybrid
workflows necessitates the coordination between classical and quantum
resources, as well as the optimization of data transfer and communication
across diverse computing environments. Furthermore, quantum hardware is
subject to inherent limitations, including coherence times, gate fidelities,
and qubit connectivity. Capacity management for quantum services must take
these hardware constraints into account, factoring in the limitations on the
number of available qubits and the complexity of the quantum circuits that can
be executed. A particular problem that should be revisited is the analysis of
capacity in microservices architectures that make use of third-party services
(Fresno-Aranda et al., 2022), expanding them to scenarios where some of these
remote services are quantum. The role that pricing plans play in general, and
capacity limitations in particular, within the API industry (Gamez-Diaz et
al., 2019), will be reinforced once they are extended to include the
peculiarities of quantum services.

Workforce training. As one key component of modern software engineering, the
principles of service-oriented computing are understood and used by great
numbers of developers. However, these developers will need to be retrained if
they are expected to develop or maintain quantum or hybrid software. This
challenge should be addressed in two ways. First, by defining clear training
strategies to simplify the transition from classical Service-Oriented
Computing to Quantum Service-Oriented Computing. And second, by developing QSE
methodologies and tools that close the gap between the classical and quantum
variants of Service-Oriented Computing.

###  3.2. Model-Driven Engineering

Model-Driven Engineering (MDE) aims to address the complexity of developing
software systems via modeling languages, transformation engines, and
generators to raise the abstraction level of software development (Schmidt et
al., 2006). In recent years, research in this domain has covered a range of
topics, including the definition of modeling languages, the creation of model
management processes and model analysis techniques, and the use of models at
runtime.

One of the most relevant challenges of current QSE is that existing languages
and methodologies in quantum software development operate at a notably lower
level of abstraction compared to the typical scope addressed by MDE techniques
for classical software. The fundamental differences between classical and
quantum software complicate modeling techniques in this kind of applications
(e.g., boolean algebra vs. quantum mechanics principles, well-known
architectures and patterns vs. algorithm complexity, deterministic vs.
stochastic, low dependency and high compatibility with hardware vs. the
opposite, high scalability vs. NISQ limitations). Furthermore, the design of
hybrid software is rarely modeled at a higher abstraction level, ignoring
irrelevant low-level technical details and focusing on architectural details
(see Section 3.5). To address these challenges, several research groups have
started working on Model-Driven Quantum Software Engineering and have already
produced relevant contributions in the area.

In (Ali and Yue, 2020), the authors preliminary explore how MDE can be used
for supporting quantum code generation or quantum verification and validation.
Similarly, in (Gemeinhardt et al., 2021), the authors propose an initial
roadmap of research questions that should be addressed to bring the benefits
of MDE to quantum software. From this starting point, the authors have
developed several additional contributions. In (Gemeinhardt et al., 2023),
they analyze how model-driven optimization techniques can be applied in the
context of quantum software. Additionally, in (Gemeinhardt et al., 2024), they
propose a modeling language and a design framework for quantum circuits that
support the definition of composite operators. This allows developers to raise
the abstraction level of quantum algorithm design alongside the provided code
generator.

With a different goal, but using similar model-driven principles, software
modernization efforts have been tailored to tackle the issues associated with
migrations of these hybrid software systems (Pérez-Castillo et al., 2021b).
The software modernization process, which integrates traditional reengineering
with MDE principles, has been progressively developed by the authors over the
last few years. Thus, reverse engineering techniques to abstract different
quantum programming languages have been proposed (Pérez-Castillo et al.,
2022); the restructuring and transformation of different high-level
representations have been addressed (Jiménez-Navajas et al., 2021); or code
generation techniques from high-level designs of hybrid software have been
preliminary proposed (Pérez-Castillo et al., 2023).

One of the most recurrent challenges covered is how to model quantum/hybrid
software in an abstract way. In this sense, in (Pérez-Delgado and Perez-
Gonzalez, 2020), certain principles are outlined for designing modeling
languages for quantum software. Similarly, a UML profile is proposed in
(Pérez-Castillo et al., 2021a), which covers the analysis and design of hybrid
software. Also, the authors in (Ali and Yue, 2020) discuss some ideas for
deriving new metamodels for modeling quantum programs as extensions of UML.
Apart from UML, other authors have focused on other existing standards. In
(Weder et al., 2020), authors introduce a BPMN-based modeling approach to
facilitate the integration of quantum computations with classical applications
and quantum circuits, aiming to simplify orchestration tasks and ensure
portability. In addition, some mentioned works (Pérez-Castillo et al., 2022;
Jiménez-Navajas et al., 2021) use the extension of the Knowledge Discovery
Metamodel (KDM) to support the maintainability of quantum software.

In contrast to extensions for existing modeling standards, some authors have
explored using Domain Specific Modeling Languages (DSML), as discussed in
(Gemeinhardt et al., 2021). DSMLs, such as SimuQ (Peng et al., 2024) and
Quingo (Fu et al., 2021), cater to specific needs within quantum computing.
QIR (Quantum Intermediate Representation), developed by Microsoft (Geller,
2020), serves as a DSML built on the LLVM intermediate language, with the aim
of providing a unified interface across quantum programming languages and
platforms. There exist other similar libraries and frameworks that make the
code hardware-independent. For example, Xanadu Pennylane software and, to some
extent, AWS Braket software can convert their code to multiple hardware
vendors. Finally, other examples of DSMLs have been proposed for Quantum
Machine Learning (Moin et al., 2021) and for modeling quantum circuits derived
from satisfiability problems (Alonso et al., 2022).

Those are only some examples of the work in the intersection between MDE and
Quantum Software Engineering. However, additional research efforts are still
needed to address the remaining challenges in this domain. Specifically:

The development of high-level design methodologies for hybrid software systems
is crucial for bridging the gap between classical and quantum computing
paradigms. This involves creating abstract modeling frameworks that
encapsulate the complexity of hybrid quantum-classical interactions, providing
a unified view that enhances comprehensibility and facilitates design
decisions. Future research could focus on developing DSMLs that offer
intuitive abstractions for quantum-classical integration, enabling software
engineers to design hybrid applications without delving into the low-level
technical aspects of quantum computing.

Scalable quantum software maintenance and evolution. As quantum software
becomes more complex and widespread, maintaining and evolving these systems
will pose significant challenges. Future research could explore MDE approaches
to predict the impact of changes in quantum software components, ensuring
compatibility and optimizing performance across versions. Techniques such as
model-based regression testing and automated refactoring tools tailored to
quantum software could be developed to support scalable maintenance processes.

Intelligent code generation and orchestration are crucial to improving the
productivity and efficiency of QSE. By automating the generation of quantum
code from high-level models, developers can focus more on problem-solving
rather than the intricacies of quantum programming languages. Future work in
this domain could look at developing sophisticated code generation engines,
e.g., based on model-driven optimization, that translates models into
executable quantum code and optimizes this code for specific quantum hardware,
considering factors such as qubit connectivity and gate fidelity.
Orchestration, on the other hand, involves managing the execution of quantum
and classical components in hybrid systems, ensuring they operate seamlessly
together to achieve desired outcomes. Furthermore, the research could aim to
create intelligent orchestration tools that dynamically manage the execution
of hybrid applications, optimizing resource allocation and execution in order
to improve performance and reliability.

###  3.3. Testing and Debugging

Quantum software testing is about assessing the correctness of quantum
software in delivering their intended functionalities, while debugging is
about observing failures in quantum software that need to be diagnosed and
fixed, especially when facing challenges such as quantum noise, limited
quantum hardware and simulator resources, and limited observability (Ali et
al., 2022).

Several groups have made notable contributions to test quantum software in
different ways (Miranskyy and Zhang, 2019; Miranskyy et al., 2020, 2021; Long
and Zhao, 2024b; Ye et al., 2023). Various coverage criteria for assessing the
quality of test cases have been proposed, including covering inputs and
outputs of quantum programs (Ali et al., 2021; Wang et al., 2022a), and
coverage criteria based on equivalence class partitioning (Long and Zhao,
2024b). In addition, several advanced techniques have been applied to test
quantum programs including search-based testing (Wang et al., 2021b, 2022b),
combinatorial testing (Wang et al., 2021a, 2023b), metamorphic testing (Abreu
et al., 2023), fuzzing (Wang et al., 2018), property-based testing (Honarvar
et al., 2020), and also techniques based on the reversibility property of
quantum circuits (de la Barrera et al., 2023). Moreover, testing techniques
for testing quantum computing platforms have also emerged, such as those based
on metamorphic testing and differential testing (Paltenghi and Pradel, 2023b;
Wang et al., 2021c). Various assertion types have been suggested to check
program output correctness, such as statistical assertions (Huang and
Martonosi, 2019), projection-based assertions (Li et al., 2020), and dynamic
assertions (Li and Ying, 2014; Zhou and Byrd, 2019; Liu et al., 2020).
Moreover, as quantum computer noise makes it difficult to distinguish actual
bugs from program failures caused by noise, efforts have recently been made to
mitigate noise in quantum computing to enhance testing reliability (e.g., see
(Muqeet et al., 2024)). A testing framework (Long and Zhao, 2024b) has also
been developed to support both unit and integration testing of quantum
programs.

Mutation testing is an efficient approach to assess the quality of a test
suite. Different works have proposed mutation operators for quantum programs,
like Muskit (Mendiluze et al., 2022) and QmutPy (Fortunato et al., 2022c, b,
a). Moreover, an empirical evaluation was conducted on over 700 000 mutants
generated from more than 350 real quantum circuits (Usandizaga et al., 2023),
and the generation approach MutTG was proposed for creating minimal-sized test
suites capable of killing a set of mutants (Wang et al., 2022c).

An empirical analysis of software repositories containing quantum programs is
underway, which leads to the identification of bug patterns (some of which are
quantum-specific) affecting quantum software (Paltenghi and Pradel, 2022; Zhao
et al., 2023a, c; Jose Campos and Souto, 2021). These patterns can be used by
newly-created static analyzers for quantum code, such as (Paltenghi and
Pradel, 2023a; Kher et al., 2023; Nayak et al., 2023; Zhao et al., 2023b), to
detect defects early in the development process. Additionally, they can be
used to create benchmarks for testing and debugging (Zhao et al., 2023a).
Quantum software bug trackers reveal flaky tests (which is intuitive given
quantum mechanics’ probabilistic nature), but the root causes of flakiness
differ from classical software (Zhang et al., 2023). Quantum-specific
technical debt (Openja et al., 2022) and code smells (Chen et al., 2023) are
being analyzed and detected, and software repositories are used to empirically
validate the findings. Lastly, software repositories can be used to identify a
list of developers to be interviewed, e.g., to assess their background
(Shaydulin et al., 2020) or to elicit code smells (Chen et al., 2023).
Moreover, an investigation into automatic quantum program repair has begun,
demonstrating the effectiveness of large language models, namely ChatGPT, in
repairing some quantum programs (Guo et al., 2024).

Debugging involves analyzing programs to identify and correct errors through
causal analysis between bugs and detected errors, crucial for both classical
and quantum programming (Bentley, 1985; Chong et al., 2017). Miranskyy et al.
(Miranskyy et al., 2020, 2021) examined quantum program debugging tactics,
exploring the adaptation of classical strategies—brute force, backtracking,
and cause elimination—to quantum contexts. Metwalli and Meter (Metwalli and
Van Meter, 2024) proposed a debugging framework for quantum circuits,
concentrating on amplitude permutation, phase modulation, and amplitude
redistribution circuit blocks, addressing the need for specialized approaches
for each quantum circuit type, contributing towards robust quantum computing
systems. Sato and Katsube (Sato and Katsube, 2023) introduced four
considerations for locating bugs in quantum programs and an efficient bug-
locating method integrating cost-based binary search, early determination,
finalization, and retrospection, validated by experimental results.

In quantum program debugging, implementing quantum assertions often involves
duplicating quantum variables and repeated measurements. Huang et al. (Huang
and Martonosi, 2019) used hypothesis testing to partially reconstruct quantum
register information from measurements for assertions, noting a lack of
runtime assertion support. To overcome this, Liu et al. (Liu et al., 2020)
proposed using additional qubits to capture assertion-target qubits’
information with minimal execution interruption. Furthermore, Li et al. (Li et
al., 2020) introduced Proq, a projection-based runtime assertion tool for
quantum program debugging and testing, utilizing projection measurements to
enable assertions without destroying quantum variables. Additionally, Jin and
Zhao proposed ScaffML (Jin and Zhao, 2023), a behavioral interface
specification language for the quantum programming language Scaffold (Abhari
et al., 2012), which specifies pre- and post-conditions for Scaffold modules.
This language integration facilitates debugging and verification by allowing
the seamless incorporation of assertions within Scaffold code.

Though all the above work is contributing to good results in software testing,
we can identify open challenges that will need to be addressed in the next
decade, some of which are given below:

Efficient test oracles. Though some test oracles exist to assess the pass and
fail of test cases, most of them are expensive to compute (Ali et al., 2021;
Wang et al., 2022a; Huang and Martonosi, 2019; Li et al., 2020). In addition,
sometimes the test oracle must be generated for each given input-output, which
increases the execution cost of the testing process (de la Barrera Amo et al.,
2022). Given the scarce and expensive quantum computing resources, such test
oracles do not scale. Thus, more efficient test oracles are needed.
Theoretically, one could use state vectors instead of multiple executions, but
one cannot easily obtain such state vectors from real quantum computers.
Quantum state tomography and partial tomography can give us an approximation
of the state vectors, but they are computationally expensive (Smolin et al.,
2012; Bonet-Monroig et al., 2020). In addition, there is also no efficient
support (adding dynamic assertions is cumbersome) for checking quantum program
states at various points during execution. Such checks, like in classical
computing, are important, also for debugging and repair. Projection-based
oracle (Li et al., 2020) is one approach, but it still requires reading
quantum programs, albeit it aims at reducing the times reading is required.
Near future research directions include conducting empirical studies to devise
guidelines for conducting experiments and selecting suitable statistical
techniques to keep the balance of required runs and the reliability of
results. Another research direction aligns with classical test optimization:
prioritizing testing on critical test cases. In this sense, the use of metrics
and the development of quality models may be of great use in improving various
aspects of the quantum software testing process (Cruz-Lemus et al., 2021;
Zhao, 2021).

Test scalability. Most existing test data generation approaches are based on
initial classical states of quantum programs (e.g., (Wang et al., 2022a, b)).
QuraTest (Ye et al., 2023) and the work presented in (Long and Zhao, 2024b)
goes beyond classical test input generation. However, the current works do not
scale to complex quantum software and have challenges in efficiently covering
the high-dimensional test input space determined by the number of qubits,
entangled and superposition states, etc. Thus, we foresee advanced test data
generation methods that lead to the efficient detection of faults in non-
trivial quantum programs (e.g., faulty superpositioned states, wrong gates
applied), considering practical constraints such as limited quantum computing
resources, and the diversity and representatives of the test data as we
typically do in classical software testing.

From simulators to real quantum computers. Currently, quantum computers are
noisy; hence, test results are unreliable. Most current works test on ideal
simulators (e.g., (Wang et al., 2021b, 2022b, 2023b; Abreu et al., 2023; Wang
et al., 2018; Honarvar et al., 2020; Long and Zhao, 2024a, b; Ye et al.,
2023)). Thus, we foresee the need for noise reduction techniques to be
integrated as part of quantum software testing to increase the reliability of
test results.

Moreover, due to limited access to real quantum computers, existing testing
solutions mainly rely on simulators. However, in the future, when real quantum
computers become more accessible, it is crucial to test quantum programs on
real quantum computers. Thus, to be cost-effective, test optimization would be
needed. Depending on the scale of testing, either classical test optimization
or quantum test optimization approaches could be developed to minimize or
prioritize tests. To this end, several preliminary works apply quantum
annealing and quantum approximate optimization algorithms to optimize test
cases for classical software (Wang et al., 2023c, a), which, we believe, is
equally applicable for test optimization of quantum software.

Further development of testing. Concerning mutation testing, different
problems remain open. First, it is necessary to understand if artificial
faults represent real faults. Empirical studies are also needed to discover
existing subsumption relations among mutation operators due to the large
number of mutants that can be produced.

Further research is also needed to identify similarities and differences
between classical and quantum software artifacts, guide the development of new
tools or reuse existing ones, identify common pain points, and devise best
practices through mining software repositories, etc.

Moreover, for quantum software, mapping testing techniques and activities to
specific test phases is challenging (Miranskyy et al., 2021). Formalizing this
mapping for unit testing and integration testing has been performed (Long and
Zhao, 2024b), but other phases require more work.

###  3.4. Programming Paradigms

Programming involves coding algorithms (strategies) to achieve an objective
(produce a result) using programming languages 333By programming language here
we mean any special or dedicated language (including graphical or natural
languages) with enough precision to express algorithms that finally can
instruct computers.. The typical approach to formulating strategies involves
breaking them down into increasingly simpler steps until the level of
instruction provided by programming languages is reached. The process of
breaking down occurs at different levels of abstraction. Thus, the way
strategies are approached is conditioned by the final set of operations
available for the computation model, be it classical or quantum.

Since 1996 to date, when the metalanguage lambda-q calculus was proposed
(Maymin, 1997), many quantum programming languages have been created. Most of
them are languages that follow the imperative programming paradigm. Some
examples of them are QASM (Pakin, 2016) based on Assembly, Ket (Da Rosa and De
Santiago, 2021) based on Python or Q# (Svore et al., 2018) based on C#. A few
of them are functional, like QML (Grattage, 2011) and Quipper (Green et al.,
2013) based on Haskell, or even declarative languages, like Forest (Smith et
al., 2017) based on Python.

All of the above languages are designed to compose quantum circuits that will
compute on a QPU. Programming circuit-based quantum computers presents a
significant challenge to classical programmers approaching it (Ali and Yue,
2023a). While many factors contribute to it, we focus here on two of them.

On the one hand, the conception of strategies for classical and quantum
programs is very different. A classical program encodes a strategy for
composing a result444Strategies to produce results are not only for imperative
languages. Logic or declarative languages also express strategies to produce
results with instructions conceived for their different paradigms.. Each step
in a classical program transforms the machine’s state. Eventually, the result
is produced, and the program is deemed correct because it successfully
constructs the result. On the contrary, a quantum program encodes a strategy
for discovering the result. In a quantum program, computations typically begin
by generating a superposition state in which the solution(s) already exist in
one or several configurations of the state. The strategy consists of a
sequence of steps to amplify the amplitude of those configurations.

On the other hand, quantum programming languages provide a low level of
abstraction. Although there are many languages for quantum programming, such
as QASM, Quil, qibo, and Qiskit, all of them constrain the abstraction level
to that provided by the primitives of the language (quantum gates). Those
primitives operate directly over the phase and amplitude of qubits
representing the quantum state. So, quantum program strategies must be
considered in terms of phase and amplitude manipulation. Compared to classical
programming, it is like composing strategies in terms of rotation, shifting,
addition, or carrying operations over binary registers. This stage has long
since been superseded in classical software engineering, and history has shown
its benefits.

In recent years, some initiatives have been developed that seek to make
quantum programming more affordable by raising the level of abstraction and
providing abstractions that facilitate the design of discovery strategies. One
of the major advances in achieving comprehensibility, reliability, and
simplicity of classical software, was the introduction of basic data types
like Integer, Float, or Character, along with simple operations on them. Now,
inspired by that (Sanchez-Rivero et al., 2023b), (Sanchez-Rivero et al.,
2023c) and (Sanchez-Rivero et al., 2023a) propose a kind of Oracle Based
Quantum Programming. The idea is to treat quantum registers as data-type
encodings. Such types are complemented with oracles (Gilyén et al., 2019),
(Leymann, 2019) that implement basic operations on them. The feasibility of
this approach has been explored considering quantum registers encoding
integers. Then, a set of reusable and composable oracles implementing simple
operations (Sanchez-Rivero et al., 2023a) have been developed.

With the aim of providing quantum programmers with a higher abstraction level
other authors also exploit the idea of providing Quantum Types (Varga et al.,
2024). Programmers are allowed to define their own types and thus create new
abstractions on which build their algorithms. Some other works are also
focused on providing different means to encode specific types and operations
in quantum states (Wiebe and Kliuchnikov, 2013; Cuccaro et al., 2004; Häner et
al., 2018; Seidel et al., 2021)

The concern to raise the level of abstraction in order to make the programming
of quantum systems more accessible is not unique to circuit-based systems.
Also, researchers in the field of annealing quantum computing aim for this
objective. Programming a QUBO is not an easy task. Thus, some researchers
(Richoux et al., 2023) try to approach that problem by enabling programmers to
formulate their algorithms in the scope of Constraints Programming (Mayoh et
al., 2013) and then translating constraints to a QUBO.

The above work reveals some of the challenges that will have to be addressed
over the next decade:

Complexity of circuits. Oracles have demonstrated their potential to be used
as a pattern supporting the encapsulation of complex operations as black
boxes. The same idea can be applied to encapsulate other pieces of circuits
encoding interesting strategies, for example, Grover’s amplitude amplification
(Grover, 1998). However, implementing quantum circuits usually produces wide
and deep circuits that are a challenge to available quantum resources. Thus,
designing techniques and procedures to optimize the number of qubits and the
depth of circuits implementing oracles still remains an open research field.

Composable and reusable quantum software. Designing oracles or any other piece
of quantum circuits is often a very complex task that requires a deep
understanding of quantum states. To make more affordable the effort invested
in designing algorithms and circuits, they must be as reusable as possible.
Reusing circuits means that they must be composed of other circuits into which
they are to be inserted. The tools available to perform this task of reuse and
composition are still very limited. Furthermore, the initial work done to
provide tools to support reuse and composition (Sanchez-Rivero et al., 2023d)
suggests that this process is significantly different from similar processes
in the classical software domain. Developing techniques for the documentation,
reuse, and composition of quantum software is, therefore, another challenge to
be addressed in the next decade.

Abstractions for quantum software. Encoding data types in quantum states and
designing operations on these states is a good strategy to start raising the
level of abstraction of quantum programming languages. With this, new sets of
operations can be developed to enrich the primitives and blocks provided by
the languages. However, the types and operations that can be found in the
literature so far are very close to those commonly used in classical
computing. For example, in (García-Martín et al., 2020), the author defines a
quantum state coding prime numbers. However, these are possibly not the most
suitable abstractions to handle in quantum states. The research community has
yet to develop abstractions suitable for what quantum computers are supposed
to be good at. Thus, if we understand that a quantum computer is suitable to
simulate a physical process as pointed out by Richard Feynman (Feynman, 2018),
let us say a chemical reaction, possibly a good type of data to encode in a
quantum state is a molecule, which through operations on the quantum state can
react with other molecules. To the best of our knowledge, there are still no
proposals that deal with this kind of abstraction.

###  3.5. Software Architecture

Software architecture involves creating structures essential for understanding
and creating a software system. These structures consist of software elements,
their relationships, and their properties. We can use quantum computers to
make our classical software tackle problems that were previously out of reach.
Consequently, quantum systems should not operate independently but should co-
exist and collaborate with classical systems (Carleton et al., 2021; Pérez-
Castillo et al., 2021b; Weder et al., 2021).

Tools and methodologies are needed to integrate quantum layers and
stakeholders with those in classical information systems. The motivation for
such integration of different systems should not just be the fact that they
reside in different computational paradigms. Instead, information systems
should be able to be designed as a whole and integrated based on the
functionalities they provide independently of the hardware architectures in
which they reside.

Software architects play a crucial role in achieving seamless integration
while designing systems that effectively meet businesses’ requirements. Thus,
a systematic review in (Khan et al., 2023) investigates software architecture
for quantum computing systems. Further challenges and opportunities are
discussed in detail in (Yue et al., 2023b). In a similar study, aspects
involved in various software architectures are analyzed, since “the software
architecture of quantum computing systems plays a pivotal role in determining
their ultimate success and usability” (Zhao et al., 2024). In (Aktar et al.,
2023), the author conducts empirical research to examine and analyze
architectural decisions while creating quantum software systems.

Some particular design patterns have also been proposed (Leymann, 2019; Bühler
et al., 2023), which mainly focused on the design of quantum circuits. In
(Pérez-Castillo et al., 2024a), authors preliminary explore the usage in
practice of some of those design patterns. Preliminary work in Extending the
definition of patterns for hybrid software systems is proposed in (Weigold et
al., 2021).

In summary, the research prospects on quantum software architecture might be
the following:

Investigate all the factors influencing architectural decisions, encompassing
both implementation and technical choices. This exploration should delve into
the multifaceted dimensions that guide these decisions, including but not
limited to performance considerations, compatibility and interoperability,
cost implications, scalability, flexibility, etc.

Define the design patterns for the built hybrid software systems. Both at low-
level software components, such as compilation units and functions, in order
to ensure modularity and reusing, and at high-level to manage service
orchestration and workflow management (cf. Section 3.1).

Research aimed at acquiring more substantial empirical evidence on applying
patterns in industrial scenarios, covering both current and future design
patterns and architectural decisions.

Investigate the evolution of hybrid software architecture over time and
provide maintenance solutions to manage technical debt and keep clean and
effective architectures.

###  3.6. Software Development Processes

Akbar et al. (Akbar et al., 2023) categorize various QSE challenges.
Specifically, two challenges suggest that specific quantum/hybrid software
development processes are needed: the 14th challenge: “Integration with
classical computing,” and the 22nd challenge: “Project management issues.”
Regarding classical-quantum software integration, quantum software cannot be
developed and operated in isolation. “A key challenge is to fully integrate
these types of systems into a unified classical and quantum software
development lifecycle” (Carleton et al., 2021). Thus, there are some issues,
for example, the interpretation of results by the classical counterpart, since
quantum computations are stochastic (Haghparast et al., 2023). Also, new
architectural paradigms and design patterns will be necessary to develop
quantum software effectively (Khan et al., 2023). Regarding project
management, some issues, like risk management, are specifically framed in
developing hybrid software systems. For example, the limited availability of
real quantum hardware, which leads to testing quantum software in simulators,
sometimes leads to different results when the quantum software is executed in
the production environment. Other risks with a high impact on the success of
quantum software development projects are standardized tools and frameworks,
or scalability (Akbar et al., 2024).

There is some preliminary research on the holistic quantum software
development lifecycle. Thus, Zhao (Zhao, 2020) proposed a slight adaptation of
the waterfall model. In a similar approach (Dey et al., 2020), also based on
the waterfall model, alternative stages are proposed.

Since those models can inherit all the weaknesses of the classical waterfall
life cycle, other proposals are based on iterative models. Weder et al. (Weder
et al., 2022) proposed an iterative model based on “quantum data provenance”,
which serves in different phases of the life cycle. Also, in (Pérez-Castillo
et al., 2024b), authors propose an adaptation of the Incremental Commitment
Spiral Model, which is also an iterative model that suggests risk management
during software development.

Other proposals inspect how agile good practices can be integrated into
quantum software development. In this context, proposals have emerged that
address integrating the DevOps paradigm within the domain of quantum software
development (Stirbu et al., 2023; Gheorghe-Pop et al., 2020; Romero-Álvarez et
al., [n. d.]). In a more analytical way, an interview-based study (Khan et
al., 2022) shows the most important challenges in agile-quantum software
development, such as sustainable scaling and the need for mature tool
ecosystems and standard agile specifications. The significance of these
challenges is likely to be paramount in the coming years.

The open research topics for the next years in this domain might be the
following:

Managing iterative development of hybrid software systems through the whole
lifecycle. Iterative development models, which have proven effective in
managing complexity and enhancing flexibility in classical software projects,
must be adapted to hybrid software systems development. This includes models
that can accommodate rapid changes in quantum technology and provide
frameworks for the co-development of classical and quantum components. This,
in turn, will introduce unique challenges, such as the need for quantum-
specific design patterns, integration testing frameworks, and development
tools that can handle quantum-classical software systems.

Risk management within the specialized realm of quantum software, coupled with
sustainable scalability strategies, is essential for developing progressively
larger and more intricate hybrid software systems. Thus, adaptive risk
management strategies will be necessary, which can evolve with the quantum
computing landscape. This might involve dynamic resource allocation models,
contingency planning for quantum hardware failures, and methodologies for
evaluating the reliability of quantum algorithms.

Project management, particularly in its focus on the operational aspects of
quantum software, requires the integration of DevOps or similar agile
paradigms into the software development lifecycle. Hence, some future research
lines could focus on developing or adapting agile toolchains, including
version control systems, continuous integration/ continuous deployment (CI/CD)
pipelines, and agile project management tools that are quantum-aware. This
research line could investigate how quantum computing as a service can be
integrated into software development projects, enabling agile teams to
leverage quantum computing resources efficiently.

##  4\. Conclusion

In this work, a group of active researchers currently addressing the
challenges of Quantum Software Engineering analyze the most recent advances in
this field. This analysis reveals some certainties, which can be summarized as
follows. First, no matter the discipline one focuses on, quantum software
development requires new techniques compared to classical software
development. These techniques have already begun to form the body of QSE.
Second, quantum computers are reaching a development stage that is attracting
industry attention. Therefore, empirical software engineering methods and
techniques need to be revisited to meet industry expectations regarding
quantum computing, making the development of QSE a priority.

To achieve this development, QSE’s most noteworthy challenges in the next
decade have been identified. By successfully addressing these challenges, QSE
will be able to support the development of hybrid software systems beyond the
NISQ era. The roadmap does not end here: quantum technology will continue to
evolve, posing new challenges and opportunities for the QSE community.

## References

  * (1)
  * IBM (2016) 2016\.  _IBM Makes Quantum Computing Available on IBM Cloud to Accelerate Innovation_.  https://uk.newsroom.ibm.com/2016-May-04-IBM-Makes-Quantum-Computing-Available-on-IBM-Cloud-to-Accelerate-Innovation
  * Abhari et al. (2012) Ali J Abhari, Arvin Faruque, Mohammad J Dousti, Lukas Svec, Oana Catu, Amlan Chakrabati, Chen-Fu Chiang, Seth Vanderwilt, John Black, and Fred Chong. 2012.  _Scaffold: Quantum programming language_.  Technical Report. Department of Computer Science, Princeton University.
  * Abreu et al. (2023) Rui Abreu, João Paulo Fernandes, Luis Llana, and Guilherme Tavares. 2023.  Metamorphic Testing of Oracle Quantum Programs. In _Proceedings of the 3rd International Workshop on Quantum Software Engineering_ (Pittsburgh, Pennsylvania) _(Q-SE ’22)_. Association for Computing Machinery, New York, NY, USA, 16–23.  https://doi.org/10.1145/3528230.3529189
  * Akbar et al. (2023) Muhammad Azeem Akbar, Arif Ali Khan, and Saima Rafi. 2023.  A systematic decision-making framework for tackling quantum software engineering challenges.  _Automated Software Engineering_ 30, 2 (2023), 22.  https://doi.org/10.1007/s10515-023-00389-7
  * Akbar et al. (2024) Muhammad Azeem Akbar, Arif Ali Khan, Mohammad Shameem, and Mohammad Nadeem. 2024.  Genetic model-based success probability prediction of quantum software development projects.  _Information and Software Technology_ 165 (2024), 107352.  https://doi.org/10.1016/j.infsof.2023.107352
  * Aktar et al. (2023) Mst Shamima Aktar, Peng Liang, Muhammad Waseem, Amjed Tahir, Aakash Ahmad, Beiqi Zhang, and Zengyang Li. 2023.  Architecture Decisions in Quantum Software Systems: An Empirical Study on Stack Exchange and GitHub.  arXiv:2312.05421 [cs.SE]
  * Ali et al. (2021) Shaukat Ali, Paolo Arcaini, Xinyi Wang, and Tao Yue. 2021.  Assessing the effectiveness of input and output coverage criteria for testing quantum programs. In _2021 14th IEEE Conference on Software Testing, Verification and Validation (ICST)_. IEEE, 13–23.  https://doi.org/10.1109/ICST49551.2021.00014
  * Ali and Yue (2020) Shaukat Ali and Tao Yue. 2020.  Modeling Quantum programs: challenges, initial results, and research directions. In _Proceedings of the 1st ACM SIGSOFT International Workshop on Architectures and Paradigms for Engineering Quantum Software_ (Virtual, USA) _(APEQS 2020)_. Association for Computing Machinery, New York, NY, USA, 14–21.  https://doi.org/10.1145/3412451.3428499
  * Ali and Yue (2023a) Shaukat Ali and Tao Yue. 2023a.  On the Need of Quantum-Oriented Paradigm. In _Proceedings of the 2nd International Workshop on Quantum Programming for Software Engineering_ _(QP4SE 2023)_. Association for Computing Machinery, New York, NY, USA, 17–20.  https://doi.org/10.1145/3617570.3617868
  * Ali and Yue (2023b) Shaukat Ali and Tao Yue. 2023b.  Quantum Software Testing: A Brief Introduction. In _2023 IEEE/ACM 45th International Conference on Software Engineering: Companion Proceedings (ICSE-Companion)_. 332–333.  https://doi.org/10.1109/ICSE-Companion58688.2023.00093
  * Ali et al. (2022) Shaukat Ali, Tao Yue, and Rui Abreu. 2022.  When software engineering meets quantum computing.  _Commun. ACM_ 65, 4 (2022), 84–88.
  * Alonso et al. (2022) Diego Alonso, Pedro Sánchez, and Francisco Sánchez-Rubio. 2022.  Engineering the development of quantum programs: Application to the Boolean satisfiability problem.  _Advances in Engineering Software_ 173 (2022), 103216.  https://doi.org/10.1016/j.advengsoft.2022.103216
  * Beisel et al. (2022) Martin Beisel, Johanna Barzen, Simon Garhofer, Frank Leymann, Felix Truger, Benjamin Weder, and Vladimir Yussupov. 2022.  Quokka: a service ecosystem for workflow-based execution of variational quantum algorithms. In _International Conference on Service-Oriented Computing_. Springer, 369–373.
  * Bentley (1985) Jon Bentley. 1985.  Programming pearls: confessions of a coder.  _Commun. ACM_ 28, 7 (1985), 671–679.
  * Bisicchia et al. (2023) Giuseppe Bisicchia, Jose García-Alonso, Juan M Murillo, and Antonio Brogi. 2023.  Distributing Quantum Computations, by Shots. In _International Conference on Service-Oriented Computing_. Springer, 363–377.
  * Bonet-Monroig et al. (2020) Xavier Bonet-Monroig, Ryan Babbush, and Thomas E O’Brien. 2020.  Nearly optimal measurement scheduling for partial tomography of quantum states.  _Physical Review X_ 10, 3 (2020), 031064.
  * Bühler et al. (2023) Fabian Bühler, Johanna Barzen, Martin Beisel, Daniel Georg, Frank Leymann, and Karoline Wild. 2023.  „Patterns for Quantum Software Development “. In _Proceedings of the 15th International Conference on Pervasive Patterns and Applications (PATTERNS 2023)_. 30–39.
  * Carleton et al. (2021) Anita D Carleton, Erin Harper, John E Robert, Mark H Klein, Dionisio De Niz, Edward Desautels, John B Goodenough, Charles Holland, Ipek Ozkaya, and Douglas Schmidt. 2021.  _Architecting the Future of Software Engineering: A National Agenda for Software Engineering Research and Development_.  Report. Software Engineering Institute, Carnegie Mellon University.  https://resources.sei.cmu.edu/library/asset-view.cfm?assetid=741193
  * Cerezo et al. (2021) Marco Cerezo, Andrew Arrasmith, Ryan Babbush, Simon C Benjamin, Suguru Endo, Keisuke Fujii, Jarrod R McClean, Kosuke Mitarai, Xiao Yuan, Lukasz Cincio, et al. 2021\.  Variational quantum algorithms.  _Nature Reviews Physics_ 3, 9 (2021), 625–644.
  * Chen et al. (2023) Qihong Chen, Rúben Câmara, José Campos, André Souto, and Iftekhar Ahmed. 2023.  The Smelly Eight: An Empirical Study on the Prevalence of Code Smells in Quantum Computing. In _45th IEEE/ACM International Conference on Software Engineering, ICSE_. IEEE, 358–370.  https://doi.org/10.1109/ICSE48619.2023.00041
  * Chong et al. (2017) Frederic T Chong, Diana Franklin, and Margaret Martonosi. 2017.  Programming languages and compiler design for realistic quantum hardware.  _Nature_ 549, 7671 (2017), 180–187.
  * Clark and Stepney (2002) John Clark and Susan Stepney. 2002.  Proposed ”Grand Challenge for Computing Research” Quantum Software Engineering.  https://www.cs.york.ac.uk/quantum/sig/021108/qsegc.pdf
  * Cruz-Lemus et al. (2021) José A. Cruz-Lemus, Luis A. Marcelo, and Mario Piattini. 2021.  Towards a Set of Metrics for Quantum Circuits Understandability. In _Quality of Information and Communications Technology - 14th International Conference, QUATIC 2021, Algarve, Portugal, September 8-11, 2021, Proceedings_ _(Communications in Computer and Information Science, Vol. 1439)_ , Ana C. R. Paiva, Ana Rosa Cavalli, Paula Ventura Martins, and Ricardo Pérez-Castillo (Eds.). Springer, 239–249.  https://doi.org/10.1007/978-3-030-85347-1_18
  * Cuccaro et al. (2004) Steven A. Cuccaro, Thomas G. Draper, Samuel A. Kutin, and David Petrie Moulton. 2004.  A new quantum ripple-carry addition circuit.  arXiv:quant-ph/0410184 [quant-ph]
  * Da Rosa and De Santiago (2021) Evandro Chagas Ribeiro Da Rosa and Rafael De Santiago. 2021.  Ket Quantum Programming.  _J. Emerg. Technol. Comput. Syst._ 18, 1, Article 12 (oct 2021), 25 pages.  https://doi.org/10.1145/3474224
  * de la Barrera et al. (2023) Antonio García de la Barrera, Ignacio García Rodríguez de Guzmán, Macario Polo, and Mario Piattini. 2023.  Quantum software testing: State of the art.  _J. Softw. Evol. Process._ 35, 4 (2023).  https://doi.org/10.1002/SMR.2419
  * de la Barrera Amo et al. (2022) Antonio García de la Barrera Amo, Manuel A. Serrano, Ignacio García Rodríguez de Guzmán, Macario Polo, and Mario Piattini. 2022.  Automatic generation of test circuits for the verification of Quantum deterministic algorithms. In _Proceedings of the 1st International Workshop on Quantum Programming for Software Engineering, QP4SE 2022, Singapore, Singapore, 18 November 2022_ , Fabiano Pecorelli, Vita Santa Barletta, and Manuel A. Serrano (Eds.). ACM, 1–6.  https://doi.org/10.1145/3549036.3562055
  * Dey et al. (2020) Nivedita Dey, Mrityunjay Ghosh, Subhra Samir kundu, and Amlan Chakrabarti. 2020.  QDLC – The Quantum Development Life Cycle.  arXiv:2010.08053 [cs.ET]
  * Feynman (2018) Richard P Feynman. 2018.  Simulating physics with computers.  In _Feynman and computation_. CRC Press, 133–153.
  * Fortunato et al. (2022a) Daniel Fortunato, José Campos, and Rui Abreu. 2022a.  Mutation Testing of Quantum Programs: A Case Study With Qiskit.  _IEEE Transactions on Quantum Engineering_ 3 (2022), 1–17.  https://doi.org/10.1109/TQE.2022.3195061
  * Fortunato et al. (2022b) Daniel Fortunato, José Campos, and Rui Abreu. 2022b.  Mutation Testing of Quantum Programs Written in QISKit. In _Proceedings of the ACM/IEEE 44th International Conference on Software Engineering: Companion Proceedings_ (Pittsburgh, Pennsylvania) _(ICSE ’22)_. Association for Computing Machinery, New York, NY, USA, 358–359.  https://doi.org/10.1145/3510454.3528649
  * Fortunato et al. (2022c) Daniel Fortunato, José Campos, and Rui Abreu. 2022c.  QMutPy: A Mutation Testing Tool for Quantum Algorithms and Applications in Qiskit. In _Proceedings of the 31st ACM SIGSOFT International Symposium on Software Testing and Analysis_ (Virtual, South Korea) _(ISSTA 2022)_. Association for Computing Machinery, New York, NY, USA, 797–800.  https://doi.org/10.1145/3533767.3543296
  * Fresno-Aranda et al. (2022) Rafael Fresno-Aranda, Pablo Fernández, Amador Durán, and Antonio Ruiz-Cortés. 2022.  Semi-automated capacity analysis of limitation-aware microservices architectures. In _International Conference on the Economics of Grids, Clouds, Systems, and Services_. Springer, 75–88.
  * Fu et al. (2021) X. Fu, Jintao Yu, Xing Su, Hanru Jiang, Hua Wu, Fucheng Cheng, Xi Deng, Jinrong Zhang, Lei Jin, Yihang Yang, Le Xu, Chunchao Hu, Anqi Huang, Guangyao Huang, Xiaogang Qiang, Mingtang Deng, Ping Xu, Weixia Xu, Wanwei Liu, Yu Zhang, Yuxin Deng, Junjie Wu, and Yuan Feng. 2021.  Quingo: A Programming Framework for Heterogeneous Quantum-Classical Computing with NISQ Features.  _ACM Transactions on Quantum Computing_ 2, 4, Article 19 (dec 2021), 37 pages.  https://doi.org/10.1145/3483528
  * Gamez-Diaz et al. (2019) Antonio Gamez-Diaz, Pablo Fernandez, Antonio Ruiz-Cortés, Pedro J Molina, Nikhil Kolekar, Prithpal Bhogill, Madhurranjan Mohaan, and Francisco Méndez. 2019.  The role of limitations and SLAs in the API industry. In _Proceedings of the 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE)_. 1006–1014.
  * Garcia-Alonso et al. (2021) Jose Garcia-Alonso, Javier Rojo, David Valencia, Enrique Moguel, Javier Berrocal, and Juan Manuel Murillo. 2021.  Quantum software as a service through a quantum API gateway.  _IEEE Internet Computing_ 26, 1 (2021), 34–41.
  * García-Martín et al. (2020) D. García-Martín, E. Ribas, S. Carrazza, J.I. Latorre, and G. Sierra. 2020.  The Prime state and its quantum relatives.  _Quantum_ 4 (Dec. 2020), 371.  https://doi.org/10.22331/q-2020-12-11-371
  * Geller (2020) Alan Geller. 2020.  Introducing quantum intermediate representation (QIR).  _Q# Blog. Sept_ (2020).
  * Gemeinhardt et al. (2023) Felix Gemeinhardt, Martin Eisenberg, Stefan Klikovits, and Manuel Wimmer. 2023.  Model-Driven Optimization for Quantum Program Synthesis with MOMoT. In _2023 ACM/IEEE International Conference on Model Driven Engineering Languages and Systems Companion (MODELS-C)_. IEEE, 614–621.
  * Gemeinhardt et al. (2021) Felix Gemeinhardt, Antonio Garmendia, and Manuel Wimmer. 2021.  Towards model-driven quantum software engineering. In _2021 IEEE/ACM 2nd International Workshop on Quantum Software Engineering (Q-SE)_. IEEE, 13–15.
  * Gemeinhardt et al. (2024) Felix Gemeinhardt, Antonio Garmendia, Manuel Wimmer, and Robert Wille. 2024.  A Model-Driven Framework for Composition-Based Quantum Circuit Design.  (2024).
  * Gheorghe-Pop et al. (2020) Ilie-Daniel Gheorghe-Pop, Nikolay Tcholtchev, Tom Ritter, and Manfred Hauswirth. 2020.  Quantum DevOps: Towards Reliable and Applicable NISQ Quantum Computing.  _2020 IEEE Globecom Workshops (GC Wkshps_ (2020), 1–6.  https://api.semanticscholar.org/CorpusID:232150074
  * Gilyén et al. (2019) Andrá s Gilyén, Srinivasan Arunachalam, and Nathan Wiebe. 2019.  Optimizing quantum optimization algorithms via faster quantum gradient computation.  In _Proceedings of the Thirtieth Annual ACM-SIAM Symposium on Discrete Algorithms_. Society for Industrial and Applied Mathematics, 1425–1444.  https://doi.org/10.1137/1.9781611975482.87
  * Grattage (2011) Jonathan Grattage. 2011.  An overview of QML with a concrete implementation in Haskell.  _Electronic Notes in Theoretical Computer Science_ 270, 1 (2011), 165–174.
  * Green et al. (2013) Alexander S. Green, Peter LeFanu Lumsdaine, Neil J. Ross, Peter Selinger, and Benoît Valiron. 2013.  Quipper: a scalable quantum programming language. In _ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’13_ , Hans-Juergen Boehm and Cormac Flanagan (Eds.). ACM, 333–342.  https://doi.org/10.1145/2491956.2462177
  * Grover (1998) Lov K. Grover. 1998.  Quantum Computers Can Search Rapidly by Using Almost Any Transformation.  _Physical Review Letters_ 80, 19 (may 1998), 4329–4332.  https://doi.org/10.1103/physrevlett.80.4329
  * Guo et al. (2024) Xiaoyu Guo, Jianjun Zhao, and Pengzhan Zhao. 2024.  On Repairing Quantum Programs Using ChatGPT. In _2024 IEEE/ACM 4th International Workshop on Quantum Software Engineering (Q-SE)_. ACM.
  * Haghparast et al. (2023) Majid Haghparast, Tommi Mikkonen, Jukka K. Nurminen, and Vlad Stirbu. 2023.  Quantum Software Engineering Challenges from Developers’ Perspective: Mapping Research Challenges to the Proposed Workflow Model.  _2023 IEEE International Conference on Quantum Computing and Engineering (QCE)_ 02 (2023), 173–176.
  * Honarvar et al. (2020) Shahin Honarvar, Mohammad Reza Mousavi, and Rajagopal Nagarajan. 2020.  Property-Based Testing of Quantum Programs in Q#. In _Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops_ (Seoul, Republic of Korea) _(ICSEW’20)_. Association for Computing Machinery, New York, NY, USA, 430–435.  https://doi.org/10.1145/3387940.3391459
  * Huang and Martonosi (2019) Yipeng Huang and Margaret Martonosi. 2019.  Statistical Assertions for Validating Patterns and Finding Bugs in Quantum Programs. In _Proceedings of the 46th International Symposium on Computer Architecture_ (Phoenix, Arizona) _(ISCA ’19)_. Association for Computing Machinery, New York, NY, USA, 541–553.  https://doi.org/10.1145/3307650.3322213
  * Häner et al. (2018) Thomas Häner, Mathias Soeken, Martin Roetteler, and Krysta M. Svore. 2018.  Quantum circuits for floating-point arithmetic.  arXiv:1807.02023 [quant-ph]
  * Jiménez-Navajas et al. (2021) Luis Jiménez-Navajas, Ricardo Pérez-Castillo, and Mario Piattini. 2021.  KDM to UML Model transformation for quantum software modernization. In _International Conference on the Quality of Information and Communications Technology_. Springer, 211–224.
  * Jin and Zhao (2023) Tiancheng Jin and Jianjun Zhao. 2023.  ScaffML: A Quantum Behavioral Interface Specification Language for Scaffold. In _2023 IEEE International Conference on Quantum Software (QSW)_. IEEE, 128–137.
  * Jose Campos and Souto (2021) Jose Jose Campos and Andre Souto. 2021.  QBugs: A Collection of Reproducible Bugs in Quantum Algorithms and a Supporting Infrastructure to Enable Controlled Quantum Software Testing and Debugging Experiments. In _Second International Workshop on Quantum Software Engineering (Q-SE 2021)_. 28–32.
  * Khan et al. (2023) Arif Ali Khan, Aakash Ahmad, Muhammad Waseem, Peng Liang, Mahdi Fahmideh, Tommi Mikkonen, and Pekka Abrahamsson. 2023.  Software architecture for quantum computing systems — A systematic review.  _Journal of Systems and Software_ 201 (2023), 111682.  https://doi.org/10.1016/j.jss.2023.111682
  * Khan et al. (2022) Arif Ali Khan, Muhammad Azeem Akbar, Aakash Ahmad, Mahdi Fahmideh, Mohammad Shameem, Valtteri Lahtinen, Muhammad Waseem, and Tommi Mikkonen. 2022.  Agile Practices for Quantum Software Development: Practitioners Perspectives.  _ArXiv_ arXiv:.09825 (2022).  https://doi.org/10.48550/arXiv.2210.09825
  * Kher et al. (2023) Krishn Vishwas Kher, Ishan Joshi, Bharat Chandra Mukkavalli, Lei Zhang, and M. V. Panduranga Rao. 2023.  Automatic Diagnosis of Quantum Software Bug Fix Motifs. In _The 35th International Conference on Software Engineering and Knowledge Engineering, SEKE_. 97–102.  https://doi.org/10.18293/SEKE2023-196
  * Leymann (2019) Frank Leymann. 2019.  Towards a Pattern Language for Quantum Algorithms. In _Quantum Technology and Optimization Problems_ _(Lecture Notes in Computer Science (LNCS), Vol. 11413)_. Springer International Publishing, Cham, 218–230.  https://doi.org/10.1007/978-3-030-14082-3_19
  * Leymann and Barzen (2020) Frank Leymann and Johanna Barzen. 2020.  The bitter truth about gate-based quantum algorithms in the NISQ era.  _Quantum Science and Technology_ 5, 4 (sep 2020), 044007.  https://doi.org/10.1088/2058-9565/abae7d
  * Li et al. (2020) Gushu Li, Li Zhou, Nengkun Yu, Yufei Ding, Mingsheng Ying, and Yuan Xie. 2020.  Projection-Based Runtime Assertions for Testing and Debugging Quantum Programs.  _Proc. ACM Program. Lang._ 4, OOPSLA, Article 150 (Nov. 2020), 29 pages.  https://doi.org/10.1145/3428218
  * Li and Ying (2014) Yangjia Li and Mingsheng Ying. 2014.  Debugging quantum processes using monitoring measurements.  _Physical Review A_ 89, 4 (2014), 042338.
  * Liu et al. (2020) Ji Liu, Gregory T Byrd, and Huiyang Zhou. 2020.  Quantum Circuits for Dynamic Runtime Assertions in Quantum Computation. In _Proceedings of the Twenty-Fifth International Conference on Architectural Support for Programming Languages and Operating Systems_. 1017–1030.
  * Long and Zhao (2024a) Peixun Long and Jianjun Zhao. 2024a.  Equivalence, identity, and unitarity checking in black-box testing of quantum programs.  _Journal of Systems and Software_ (2024), 112000.
  * Long and Zhao (2024b) Peixun Long and Jianjun Zhao. 2024b.  Testing multi-subroutine quantum programs: From unit testing to integration testing.  _ACM Transactions on Software Engineering and Methodology_ (2024).
  * Mandl et al. (2024) Alexander Mandl, Johanna Barzen, Marvin Bechtold, Michael Keckeisen, Frank Leymann, and Patrick K. S. Vaudrevange. 2024.  Linear Structure of Training Samples in Quantum Neural Network Applications. In _Service-Oriented Computing – ICSOC 2023 Workshops_ , Flavia Monti, Pierluigi Plebani, Naouel Moha, Hye-young Paik, Johanna Barzen, Gowri Ramachandran, Devis Bianchini, Damian A. Tamburri, and Massimo Mecella (Eds.). Springer Nature Singapore, Singapore, 150–161.
  * Maymin (1997) Philip Maymin. 1997.  Extending the Lambda Calculus to Express Randomized and Quantumized Algorithms.  arXiv:quant-ph/9612052 [quant-ph]
  * Mayoh et al. (2013) B. Mayoh, E. Tyugu, and J. Penjam. 2013.  _Constraint Programming_.  Springer Berlin Heidelberg.  https://books.google.es/books?id=B0aqCAAAQBAJ
  * Mendiluze et al. (2022) Eñaut Mendiluze, Shaukat Ali, Paolo Arcaini, and Tao Yue. 2022.  Muskit: A Mutation Analysis Tool for Quantum Software Testing. In _Proceedings of the 36th IEEE/ACM International Conference on Automated Software Engineering_ (Melbourne, Australia) _(ASE ’21)_. IEEE Press, 1266–1270.  https://doi.org/10.1109/ASE51524.2021.9678563
  * Metwalli and Van Meter (2024) Sara Ayman Metwalli and Rodney Van Meter. 2024.  Testing and Debugging Quantum Circuits.  _IEEE Transactions on Quantum Engineering_ (2024).
  * Miranskyy and Zhang (2019) Andriy Miranskyy and Lei Zhang. 2019.  On Testing Quantum Programs. In _Proceedings of the 41st International Conference on Software Engineering: New Ideas and Emerging Results_ (Montreal, Quebec, Canada) _(ICSE-NIER ’19)_. IEEE Press, 57–60.  https://doi.org/10.1109/ICSE-NIER.2019.00023
  * Miranskyy et al. (2020) Andriy Miranskyy, Lei Zhang, and Javad Doliskani. 2020.  Is Your Quantum Program Bug-Free?. In _Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering: New Ideas and Emerging Results_ (Seoul, South Korea) _(ICSE-NIER ’20)_. Association for Computing Machinery, New York, NY, USA, 29–32.  https://doi.org/10.1145/3377816.3381731
  * Miranskyy et al. (2021) Andriy Miranskyy, Lei Zhang, and Javad Doliskani. 2021.  On Testing and Debugging Quantum Software.  (2021).  arXiv:2103.09172
  * Moguel et al. (2024) Enrique Moguel, Jose Garcia-Alonso, and Juan M. Murillo. 2024.  _Prospects for Quantum Software Engineering in the Next Decade — Supplementary material_.  https://doi.org/10.5281/zenodo.10877492
  * Moin et al. (2021) Armin Moin, Moharram Challenger, Atta Badii, and Stephan Günnemann. 2021.  MDE4QAI: Towards Model-Driven Engineering for Quantum Artificial Intelligence.  _CoRR_ abs/2107.06708 (2021).  arXiv:2107.06708 https://arxiv.org/abs/2107.06708
  * Muqeet et al. (2024) Asmar Muqeet, Tao Yue, Shaukat Ali, and Paolo Arcaini. 2024.  Mitigating Noise in Quantum Software Testing Using Machine Learning.  arXiv:2306.16992 [cs.SE]
  * Nayak et al. (2023) Pranav K. Nayak, Krishn V. Kher, M. Bharat Chandra, M. V. Panduranga Rao, and Lei Zhang. 2023.  Q-PAC: Automated Detection of Quantum Bug-Fix Patterns.  arXiv:2311.17705
  * Openja et al. (2022) Moses Openja, Mohammad Mehdi Morovati, Le An, Foutse Khomh, and Mouna Abidi. 2022.  Technical debts and faults in open-source quantum software systems: An empirical study.  _Journal of Systems and Software_ 193 (2022), 111458.  https://doi.org/10.1016/J.JSS.2022.111458
  * Pakin (2016) Scott Pakin. 2016.  A quantum macro assembler. In _2016 IEEE High Performance Extreme Computing Conference (HPEC)_. 1–8.  https://doi.org/10.1109/HPEC.2016.7761637
  * Paltenghi and Pradel (2022) Matteo Paltenghi and Michael Pradel. 2022.  Bugs in Quantum computing platforms: an empirical study.  _Proceedings of the ACM on Programming Languages_ 6, OOPSLA1 (2022), 1–27.  https://doi.org/10.1145/3527330
  * Paltenghi and Pradel (2023a) Matteo Paltenghi and Michael Pradel. 2023a.  LintQ: A Static Analysis Framework for Qiskit Quantum Programs.  _arXiv preprint arXiv:2310.00718_ (2023).
  * Paltenghi and Pradel (2023b) Matteo Paltenghi and Michael Pradel. 2023b.  MorphQ: Metamorphic Testing of the Qiskit Quantum Computing Platform. In _Proceedings of the 45th International Conference on Software Engineering_ (Melbourne, Victoria, Australia) _(ICSE ’23)_. IEEE Press, 2413–2424.  https://doi.org/10.1109/ICSE48619.2023.00202
  * Papazoglou et al. (2007) Michael P Papazoglou, Paolo Traverso, Schahram Dustdar, and Frank Leymann. 2007.  Service-oriented computing: State of the art and research challenges.  _Computer_ 40, 11 (2007), 38–45.
  * Peng et al. (2024) Yuxiang Peng, Jacob Young, Pengyu Liu, and Xiaodi Wu. 2024.  SimuQ: A Framework for Programming Quantum Hamiltonian Simulation with Analog Compilation.  _Proc. ACM Program. Lang._ 8, POPL, Article 81 (jan 2024), 31 pages.  https://doi.org/10.1145/3632923
  * Pérez-Castillo et al. (2022) Ricardo Pérez-Castillo, Luis Jiménez-Navajas, and Mario Piattini. 2022.  QRev: migrating quantum code towards hybrid information systems.  _Software Quality Journal_ 30, 2 (2022), 551–580.
  * Pérez-Delgado and Perez-Gonzalez (2020) Carlos A. Pérez-Delgado and Hector G. Perez-Gonzalez. 2020.  Towards a Quantum Software Modeling Language. In _Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops_ (Seoul, Republic of Korea) _(ICSEW’20)_. Association for Computing Machinery, New York, NY, USA, 442–444.  https://doi.org/10.1145/3387940.3392183
  * Piattini et al. (2021) Mario Piattini, Manuel Serrano, Ricardo Perez-Castillo, Guido Petersen, and Jose Luis Hevia. 2021.  Toward a Quantum Software Engineering.  _IT Professional_ 23, 1 (2021), 62–66.  https://doi.org/10.1109/MITP.2020.3019522
  * Preskill (2018) John Preskill. 2018.  Quantum computing in the NISQ era and beyond.  _Quantum_ 2 (2018), 79.
  * Pérez-Castillo et al. (2024a) Ricardo Pérez-Castillo, Miriam Fernández-Osuna, Jose Antonio Cruz-Lemus, and Mario Piattini. 2024a.  A Preliminary Study of the Usage of Design Patterns in Quantum Software. In _2024 IEEE/ACM 4nd International Workshop on Quantum Software Engineering (Q-SE)_. In Press.
  * Pérez-Castillo et al. (2023) Ricardo Pérez-Castillo, Luis Jiménez-Navajas, Iván Cantalejo, and Mario Piattini. 2023.  Generation of Classical-Quantum Code from UML models.  02 (2023), 165–168.  https://doi.org/10.1109/QCE57702.2023.10202
  * Pérez-Castillo et al. (2021a) Ricardo Pérez-Castillo, Luis Jiménez-Navajas, and Mario Piattini. 2021a.  Modelling Quantum Circuits with UML. In _2021 IEEE/ACM 2nd International Workshop on Quantum Software Engineering (Q-SE)_. 7–12.  https://doi.org/10.1109/Q-SE52541.2021.00009
  * Pérez-Castillo et al. (2024b) Ricardo Pérez-Castillo, Manuel A. Serrano, José A. Cruz-Lemus, and Mario Piattini. 2024b.  Guidelines to use the incremental commitment spiral model for developing quantum-classical systems.  _Quantum Information and Computation_ 24, 1&2 (2024), 71–88.  https://www.rintonpress.com/xxqic24/qic-24-12/0071-0088.pdf
  * Pérez-Castillo et al. (2021b) Ricardo Pérez-Castillo, Manuel A. Serrano, and Mario Piattini. 2021b.  Software modernization to embrace quantum technology.  _Advances in Engineering Software_ 151 (2021), 102933.  https://doi.org/10.1016/j.advengsoft.2020.102933
  * Richoux et al. (2023) Florian Richoux, Jean-François Baffier, and Philippe Codognet. 2023.  Learning qubo Models for Quantum Annealing: A Constraint-Based Approach. In _Computational Science – ICCS 2023_ , Jiří Mikyška, Clélia de Mulatier, Maciej Paszynski, Valeria V. Krzhizhanovskaya, Jack J. Dongarra, and Peter M.A. Sloot (Eds.). Springer Nature Switzerland, Cham, 153–167.
  * Rojo et al. (2021) Javier Rojo, David Valencia, Javier Berrocal, Enrique Moguel, Jose Garcia-Alonso, and Juan Manuel Murillo Rodriguez. 2021.  Trials and tribulations of developing hybrid quantum-classical microservices systems.  _arXiv preprint arXiv:2105.04421_ (2021).
  * Romero-Álvarez et al. (2022) Javier Romero-Álvarez, Jaime Alvarado-Valiente, Enrique Moguel, José García-Alonso, and Juan M Murillo. 2022.  Using Open API for the Development of Hybrid Classical-Quantum Services. In _International Conference on Service-Oriented Computing_. Springer, 364–368.
  * Romero-Álvarez et al. ([n. d.]) Javier Romero-Álvarez, Jaime Alvarado-Valiente, Enrique Moguel, Jose Garcia-Alonso, and Juan M. Murillo. [n. d.].  Enabling continuous deployment techniques for quantum services.  _Software: Practice and Experience_ n/a, n/a ([n. d.]).  https://doi.org/10.1002/spe.3326 arXiv:https://onlinelibrary.wiley.com/doi/pdf/10.1002/spe.3326
  * Sametinger (1997) Johannes Sametinger. 1997.  _Software engineering with reusable components_.  Springer.
  * Sanchez-Rivero et al. (2023a) Javier Sanchez-Rivero, Daniel Talaván, Jose Garcia-Alonso, Antonio Ruiz-Cortés, and Juan Manuel Murillo. 2023a.  Operating with Quantum Integers: An Efficient ‘Multiples of’ Oracle. In _Service-Oriented Computing_ , Marco Aiello, Johanna Barzen, Schahram Dustdar, and Frank Leymann (Eds.). Springer Nature Switzerland, Cham, 105–124.
  * Sanchez-Rivero et al. (2023b) Javier Sanchez-Rivero, Daniel Talaván, Jose Garcia-Alonso, Antonio Ruiz-Cortés, and Juan Manuel Murillo. 2023b.  Automatic Generation of an Efficient Less-Than Oracle for Quantum Amplitude Amplification. In _2023 IEEE/ACM 4th International Workshop on Quantum Software Engineering (Q-SE)_. 26–33.  https://doi.org/10.1109/Q-SE59154.2023.00011
  * Sanchez-Rivero et al. (2023c) Javier Sanchez-Rivero, Daniel Talaván, Jose Garcia-Alonso, Antonio Ruiz-Cortés, and Juan Manuel Murillo. 2023c.  Automatic Generation of Efficient Oracles: The Less-Than Case. In _SSRN_.  https://doi.org/10.2139/ssrn.4594664
  * Sanchez-Rivero et al. (2023d) Javier Sanchez-Rivero, Daniel Talaván, Jose Garcia-Alonso, Antonio Ruiz-Cortés, and Juan Manuel Murillo. 2023d.  Some Initial Guidelines for Building Reusable Quantum Oracles. In _Services and Quantum Software - 21st International Conference on Service-Oriented Computing_.
  * Saraiva et al. (2021) Lorenzo Saraiva, Edward Hermann Haeusler, Vaston G Costa, and Marcos Kalinowski. 2021.  Non-Functional Requirements for Quantum Programs.. In _Q-SET@ QCE_. 89–73.
  * Sato and Katsube (2023) Naoto Sato and Ryota Katsube. 2023.  Locating Buggy Segments in Quantum Program Debugging.  _arXiv preprint arXiv:2309.04266_ (2023).
  * Schmidt et al. (2006) Douglas C Schmidt et al. 2006\.  Model-driven engineering.  _Computer-IEEE Computer Society-_ 39, 2 (2006), 25.
  * Seidel et al. (2021) Raphael Seidel, Nikolay Tcholtchev, Sebastian Bock, Colin Kai-Uwe Becker, and Manfred Hauswirth. 2021.  Efficient Floating Point Arithmetic for Quantum Computers.  arXiv:2112.10537 [quant-ph]
  * Serrano et al. (2022) Manuel A. Serrano, José A. Cruz-Lemus, Ricardo Perez-Castillo, and Mario Piattini. 2022.  Quantum Software Components and Platforms: Overview and Quality Assessment.  55, 8, Article 164 (dec 2022), 31 pages.  https://doi.org/10.1145/3548679
  * Shaydulin et al. (2020) Ruslan Shaydulin, Caleb Thomas, and Paige Rodeghero. 2020.  Making Quantum Computing Open: Lessons from Open Source Projects. In _ICSE ’20: 42nd International Conference on Software Engineering, Workshops_. ACM, 451–455.  https://doi.org/10.1145/3387940.3391471
  * Smith et al. (2017) Robert S. Smith, Michael J. Curtis, and William J. Zeng. 2017.  A Practical Quantum Instruction Set Architecture.  arXiv:1608.03355 [quant-ph]
  * Smolin et al. (2012) John A Smolin, Jay M Gambetta, and Graeme Smith. 2012.  Efficient method for computing the maximum-likelihood quantum state from measurements with additive gaussian noise.  _Physical review letters_ 108, 7 (2012), 070502.
  * Stepney et al. (2004) Susan Stepney, John Clark, Andy Tyrell, Colin Johnson, Jonathan Timmis, Derek Partridge, Andy Adamatsky, and Robert Smith. 2004.  Journeys in non-classical computation.  _Grand Challenges in Computing Research_ (2004), 29–32.
  * Stirbu et al. (2023) V. Stirbu, M. Haghparast, M. Waseem, N. Dayama, and T. Mikkonen. 2023.  Full-Stack Quantum Software in Practice: Ecosystem, Stakeholders and Challenges.  (sep 2023), 177–180.  https://doi.org/10.1109/QCE57702.2023.10205
  * Svore et al. (2018) Krysta Svore, Alan Geller, Matthias Troyer, John Azariah, Christopher Granade, Bettina Heim, Vadym Kliuchnikov, Mariia Mykhailova, Andres Paz, and Martin Roetteler. 2018.  Q#: Enabling Scalable Quantum Computing and Development with a High-level DSL. In _Proceedings of the Real World Domain Specific Languages Workshop 2018_ (Vienna, Austria) _(RWDSL2018)_. Association for Computing Machinery, New York, NY, USA, Article 7, 10 pages.  https://doi.org/10.1145/3183895.3183901
  * Usandizaga et al. (2023) Eñaut Mendiluze Usandizaga, Tao Yue, Paolo Arcaini, and Shaukat Ali. 2023.  Which Quantum Circuit Mutants Shall Be Used? An Empirical Evaluation of Quantum Circuit Mutations.  _arXiv preprint arXiv:2311.16913_ (2023).
  * Varga et al. (2024) Tamás Varga, Yaiza Aragonés-Soria, and Manuel Oriol. 2024.  Quantum types: going beyond qubits and quantum gates.  arXiv:2401.15073 [quant-ph]
  * Wang et al. (2018) Jiyuan Wang, Ming Gao, Yu Jiang, Jian-Guang Lou, Yue Gao, Dongmei Zhang, and Jiaguang Sun. 2018.  QuanFuzz: Fuzz Testing of Quantum Program.  _CoRR_ abs/1810.10310 (2018).  arXiv:1810.10310 http://arxiv.org/abs/1810.10310
  * Wang et al. (2021c) Jiyuan Wang, Qian Zhang, Guoqing Harry Xu, and Miryung Kim. 2021c.  QDiff: Differential Testing of Quantum Software Stacks. In _2021 36th IEEE/ACM International Conference on Automated Software Engineering (ASE)_. 692–704.  https://doi.org/10.1109/ASE51524.2021.9678792
  * Wang et al. (2023a) Xinyi Wang, Shaukat Ali, Tao Yue, and Paolo Arcaini. 2023a.  Guess What Quantum Computing Can Do for Test Case Optimization.  arXiv:2312.15547 [cs.SE]
  * Wang et al. (2021a) Xinyi Wang, Paolo Arcaini, Tao Yue, and Shaukat Ali. 2021a.  Application of Combinatorial Testing to Quantum Programs. In _2021 IEEE 21st International Conference on Software Quality, Reliability and Security (QRS)_. 179–188.  https://doi.org/10.1109/QRS54544.2021.00029
  * Wang et al. (2021b) Xinyi Wang, Paolo Arcaini, Tao Yue, and Shaukat Ali. 2021b.  Generating Failing Test Suites for Quantum Programs With Search. In _Search-Based Software Engineering_ , Una-May O’Reilly and Xavier Devroey (Eds.). Springer International Publishing, Cham, 9–25.  https://doi.org/10.1007/978-3-030-88106-1_2
  * Wang et al. (2022a) Xinyi Wang, Paolo Arcaini, Tao Yue, and Shaukat Ali. 2022a.  Quito: A Coverage-Guided Test Generator for Quantum Programs. In _Proceedings of the 36th IEEE/ACM International Conference on Automated Software Engineering_ (Melbourne, Australia) _(ASE ’21)_. IEEE Press, 1237–1241.  https://doi.org/10.1109/ASE51524.2021.9678798
  * Wang et al. (2022b) Xinyi Wang, Paolo Arcaini, Tao Yue, and Shaukat Ali. 2022b.  QuSBT: Search-Based Testing of Quantum Programs. In _Proceedings of the ACM/IEEE 44th International Conference on Software Engineering: Companion Proceedings_ (Pittsburgh, Pennsylvania) _(ICSE ’22)_. Association for Computing Machinery, New York, NY, USA, 173–177.  https://doi.org/10.1145/3510454.3516839
  * Wang et al. (2023b) Xinyi Wang, Paolo Arcaini, Tao Yue, and Shaukat Ali. 2023b.  QuCAT: A Combinatorial Testing Tool for Quantum Software. In _2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE)_. IEEE Computer Society, Los Alamitos, CA, USA, 2066–2069.  https://doi.org/10.1109/ASE56229.2023.00062
  * Wang et al. (2023c) Xinyi Wang, Asmar Muqeet, Tao Yue, Shaukat Ali, and Paolo Arcaini. 2023c.  Test Case Minimization with Quantum Annealers.  arXiv:2308.05505 [cs.SE]
  * Wang et al. (2022c) Xinyi Wang, Tongxuan Yu, Paolo Arcaini, Tao Yue, and Shaukat Ali. 2022c.  Mutation-Based Test Generation for Quantum Programs with Multi-Objective Search. In _Proceedings of the Genetic and Evolutionary Computation Conference_ (Boston, Massachusetts) _(GECCO ’22)_. Association for Computing Machinery, New York, NY, USA, 1345–1353.  https://doi.org/10.1145/3512290.3528869
  * Weder et al. (2023) Benjamin Weder, Johanna Barzen, Martin Beisel, and Frank Leymann. 2023.  Provenance-Preserving Analysis and Rewrite of Quantum Workflows for Hybrid Quantum Algorithms.  _SN Computer Science_ 4, 3 (2023), 233.
  * Weder et al. (2022) Benjamin Weder, Johanna Barzen, Frank Leymann, and Daniel Vietz. 2022.  _Quantum Software Development Lifecycle_.  Springer International Publishing, Cham, 61–83.  https://doi.org/10.1007/978-3-031-05324-5_4
  * Weder et al. (2021) Benjamin Weder, Johanna Barzen, Frank Leymann, and Michael Zimmermann. 2021.  Hybrid quantum applications need two orchestrations in superposition: a software architecture perspective. In _2021 IEEE International Conference on Web Services (ICWS)_. IEEE, 1–13.
  * Weder et al. (2020) Benjamin Weder, Uwe Breitenbücher, Frank Leymann, and Karoline Wild. 2020.  Integrating quantum computing into workflow modeling and execution. In _2020 IEEE/ACM 13th International Conference on Utility and Cloud Computing (UCC)_. IEEE, 279–291.
  * Weigold et al. (2021) Manuela Weigold, Johanna Barzen, Frank Leymann, and Daniel Vietz. 2021.  Patterns for hybrid quantum algorithms. In _Symposium and Summer School on Service-Oriented Computing_. Springer, 34–51.
  * Wiebe and Kliuchnikov (2013) Nathan Wiebe and Vadym Kliuchnikov. 2013.  Floating point representations in quantum circuit synthesis.  _New Journal of Physics_ 15, 9 (Sept. 2013), 093041.  https://doi.org/10.1088/1367-2630/15/9/093041
  * Wild et al. (2020) Karoline Wild, Uwe Breitenbücher, Lukas Harzenetter, Frank Leymann, Daniel Vietz, and Michael Zimmermann. 2020.  TOSCA4QC: two modeling styles for TOSCA to automate the deployment and orchestration of quantum applications. In _2020 IEEE 24th International Enterprise Distributed Object Computing Conference (EDOC)_. IEEE, 125–134.
  * Ye et al. (2023) Jiaming Ye, Shangzhou Xia, Fuyuan Zhang, Paolo Arcaini, Lei Ma, Jianjun Zhao, and Fuyuki Ishikawa. 2023.  QuraTest: Integrating Quantum Specific Features in Quantum Program Testing. In _2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE)_. 1149–1161.  https://doi.org/10.1109/ASE56229.2023.00196
  * Yue et al. (2023a) Tao Yue, Shaukat Ali, and Paolo Arcaini. 2023a.  Towards Quantum Software Requirements Engineering. In _2023 IEEE International Conference on Quantum Computing and Engineering (QCE)_ , Vol. 02. 161–164.  https://doi.org/10.1109/QCE57702.2023.10201
  * Yue et al. (2023b) Tao Yue, Wolfgang Mauerer, Shaukat Ali, and Davide Taibi. 2023b.  _Challenges and Opportunities in Quantum Software Architecture_.  Springer Nature Switzerland, Cham, 1–23.  https://doi.org/10.1007/978-3-031-36847-9_1
  * Zhang et al. (2023) Lei Zhang, Mahsa Radnejad, and Andriy Miranskyy. 2023.  Identifying Flakiness in Quantum Programs. In _ACM/IEEE International Symposium on Empirical Software Engineering and Measurement, ESEM_. IEEE, 1–7.  https://doi.org/10.1109/ESEM56168.2023.10304850
  * Zhao (2020) Jianjun Zhao. 2020.  Quantum Software Engineering: Landscapes and Horizons.  _Arxiv._ (jul 2020).  https://doi.org/10.48550/arXiv.2007.07047 arXiv:2007.07047
  * Zhao (2021) Jianjun Zhao. 2021.  Some size and structure metrics for quantum software. In _2021 IEEE/ACM 2nd International Workshop on Quantum Software Engineering (Q-SE)_. IEEE, 22–27.
  * Zhao et al. (2023a) Pengzhan Zhao, Zhongtao Miao, Shuhan Lan, and Jianjun Zhao. 2023a.  Bugs4Q: A benchmark of existing bugs to enable controlled testing and debugging studies for quantum programs.  _J. Syst. Softw._ 205, C (nov 2023), 13 pages.  https://doi.org/10.1016/j.jss.2023.111805
  * Zhao et al. (2023b) Pengzhan Zhao, Xiongfei Wu, Zhuo Li, and Jianjun Zhao. 2023b.  Qchecker: Detecting bugs in quantum programs via static analysis. In _2023 IEEE/ACM 4th International Workshop on Quantum Software Engineering (Q-SE)_. IEEE, 50–57.
  * Zhao et al. (2023c) Pengzhan Zhao, Xiongfei Wu, Junjie Luo, Zhuo Li, and Jianjun Zhao. 2023c.  An Empirical Study of Bugs in Quantum Machine Learning Frameworks. In _2023 IEEE International Conference on Quantum Software (QSW)_. 68–75.  https://doi.org/10.1109/QSW59989.2023.00018
  * Zhao et al. (2024) Xudong Zhao, Xiaolong Xu, Lianyong Qi, Xiaoyu Xia, Muhammad Bilal, Wenwen Gong, and Huaizhen Kou. 2024.  Unraveling quantum computing system architectures: An extensive survey of cutting-edge paradigms.  _Information and Software Technology_ 167 (2024), 107380.  https://doi.org/10.1016/j.infsof.2023.107380
  * Zhou and Byrd (2019) Huiyang Zhou and Gregory T. Byrd. 2019.  Quantum Circuits for Dynamic Runtime Assertions in Quantum Computation.  _IEEE Computer Architecture Letters_ 18, 2 (2019), 111–114.  https://doi.org/10.1109/LCA.2019.2935049