# Agile Practices for Quantum Software Development: Practitioners’
Perspectives

Arif Ali Khan1∗, Muhammad Azeem Akbar2, Aakash Ahmad3
Mahdi Fahmideh4, Mohammad Shameem5, Valtteri Lahtinen6, Muhammad Waseem7,
Tommi Mikkonen7 1M3S Empirical Software Engineering Research Unit, University
of Oulu, Oulu, Finland2Department of Software Engineering, LUT University,
Lappeenranta, Finland3Lancaster University Leipzig, Germany4School of Business
at University of Southern Queensland, Queensland, Australia5Department of CSE,
Koneru Lakhmiyah Educational Foundation, Vaddeswaram, Andhra Pradesh,
India6Quanscient Oy, Tampere, Finland7University of Jyvaskyla,
<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>
<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>
(2023)

###### Abstract.

Quantum software systems are emerging software engineering (SE) genre that
exploit principles of quantum bits (Qubit) and quantum gates (Qgates) to solve
complex computing problems that today’s classic computers can not effectively
do in a reasonable time. According to its proponents, agile software
development practices have the potential to address many of the problems
endemic to the development of quantum software. However, there is a dearth of
evidence confirming if agile practices suit and can be adopted by software
teams as they are in the context of quantum software development. To address
this lack, we conducted an empirical study to investigate the needs and
challenges of using agile practices to develop quantum software. While our
semi-structured interviews with 26 practitioners across 10 countries
highlighted the applicability of agile practices in this domain, the interview
findings also revealed new challenges impeding the effective incorporation of
these practices. Our research findings provide a springboard for further
contextualization and seamless integration of agile practices with developing
the next generation of quantum software.

Agile Practices, Quantum Software Engineering, Quantum Computing

††journalyear: 2023††copyright: acmcopyright††conference: XXX; xx XX–XX, XX;
XX, XX††booktitle: XX), XX X–X, XXXX, XX, XX††price: 15.00††doi: XXXX††isbn:
XXXX††ccs: Software and its engineering Designing software††ccs: General and
reference Empirical studies

##  1\. Introduction

The field of Quantum computing (QC) has received rapidly growing industrial
and policy interest to an even greater extent. It is expected to bring
revolution in various industrial areas (Zhao, 2020). It is evidenced by the
fact that technology giants such as IBM (IBM, 2021), Google (Google, 2022),
and Microsoft (Microsoft, 2021) have heavily invested in implementing QC as a
service offering to tackle a new class of complex computational problems.
Developing QC applications, on the other hand, is a challenging endeavour. The
literature suggests that QC development is, after all, essentially a type of
system development endeavor (Zhao, 2020). Given this analogy, adopting a
systematic engineering lifecycle perspective for managing the complexity of QC
development is acclaimed (Zhao, 2020). This takes precedence over an ad-hoc
use of implementation techniques and technologies or relying on the
development skills of the individuals that may likely to deliver QC, which may
be erroneous and costly to maintain (Khan et al., 2022a)(Zhao, 2020). Hence,
to achieve an optimum effect, there must be advanced SE Methods to enable QC
to live up to its promising potential.

The key enabler for developing QC technologies is quantum software (Ali et
al., 2022). Quantum software, amongst other requirements such as full stack
support ranging from novel techniques and tools, needs processes and methods
that explicitly focus on developing software system based on quantum mechanics
(Ali et al., 2022). However, the present-day quantum software engineering
(QSE) processes are far from being mature, and are most often based on hybrid
concepts (consisting of quantum-classical tools and practices). The quantum-
classical development must be orchestrated; therefore, we previously presented
the vision of embarrassing iterative and agile practices for developing a
quantum software (Khan et al., 2022b). The QSE processes can benefit from
well-developed iterative agile practices for team collaboration, short
development iterations, and continuous delivery (Beck et al., 2001)(Fitzgerald
et al., 2006). Presently, adopting a more “agile” approach to develop a
quantum software system is reliable option rather than waiting for domain
specific QSE processes and methods (Ali et al., 2022). However, no empirical
evidence yet exists that ties agile practices and quantum software development
activities. This study aims at exploring the significance of agile practices
in the QSE domain.

We conducted semi-structured interviews with a total of 26 software
practitioners (having mutually inclusive knowledge of agile software
engineering and quantum software development) across 10 countries with diverse
roles such as quantum algorithm developer, software developer, agile coach
working in varying domains ranging from cyber security to automotive and
healthcare, allowing us to gain different perspectives on our research aim. To
analyse interview results, we adopted the Grounded Theory (GT) method (Glaser
and Strauss, 2017) in a bottom-up approach to derive a mapping of code,
concepts, and categories from raw (interview) data.

The results indicate that practitioners view agile practices as the best fit
to support quantum software development activities. However, small portion of
the interview participants find themselves underprepared due to lack of a
basic knowledge of quantum mechanics, insufficient expertise and non-
availability of tools, that hinders the progress of agile-driven quantum
software development.

We outline the primary contributions of this research as (i) empirically-
derived understanding on the adoption of agile in quantum software
development, (ii) discussing four major categories of challenges (knowledge
and awareness, sustainable scaling, quantum-aware tools and technologies and
standards and specifications) that must be addressed for adopting agile
practices in quantum software development domain. The study results in
principle aim to enlighten software researchers and practitioners by
pinpointing the understanding and challenges of using agile practices for
developing a quantum software.

The rest of the paper is organised as follows. The background of the study is
described in section 2. The research methodology process is discussed in
section 3. Section 4 detail the data analysis process and results are
presented in section 5. The discussions, study implications and threats to the
validity of study findings are reported in section 6. Section 7 reviews the
related work and section 8 draws the conclusions and outlined the future
directions.

##  2\. Background

Firstly, we contextualise the development of software-intensive systems that
can be executed or simulated on QC platforms. The concepts and terminologies
introduced in this section, illustrated in Figure 1 are used throughout the
paper to elaborate technical aspects of SE for QC.

###  2.1. Quantum Software Engineering

Quantum computers harness the phenomena of quantum mechanics, e.g., quantum
superposition and entanglement to process, store, and transmit quantum
information set represented with Qubits that manipulate Qgates, as in Figure
1. In contrast to classic binary digits represented as (0,1), Qubit as the
most fundamental unit of quantum information set attains a state that is a
superposition of 0 and 1, and represented as |0⟩ and |1⟩(Zhao, 2020)(Rieffel
and Polak, 2011), where:

(1) $|0\rangle=\left[\begin{array}[]{c}1\\\
0\end{array}\right]~{}~{}~{}~{}~{}\hskip 28.45274pt\hskip
28.45274pt~{}~{}~{}~{}~{}|1\rangle=\left[\begin{array}[]{c}0\\\
1\end{array}\right]$

From computation (i.e. QC) and software system development (i.e.QSE)
perspective, quantum computer disrupt the idea of traditional digital systems
and represent a paradigm shift (transitioning from bits to Qubits) with a
vision to next generation computing (Zhao, 2020). In a QC context,
operationalising Qubits that manipulate quantum circuits (Qgates as a
primitive unit of quantum hardware), software programmers require quantum age
algorithms and programming languages such as Microsoft Q# (Microsoft, 2021),
IBM Qiskit (IBM, 2021) and Cirq by Google (Google, 2022). Quantum programming
language and their underlying algorithms are well suited to focus on
implementation details that produce executable specifications on quantum
computer; however, they lack an engineering view for developing quantum
software including the activities such as quantum domain engineering, quantum
system co-design, quantum algorithm design and source coding and quantum
information simulation (see Figure 1) (Khan et al., 2022b)(Ahmad et al.,
2022). QSE as the most recent genre of SE aims to exploit the status-quo
(ISO/IEC/IEEE 12207:2017 standard) (ISO/IEC/IEEE, 2017) by leveraging the
engineering processes, reference architectures, patterns, tools and framework
to develop quantum-intensive software. There is no well established process or
even a notion of how QSE process might look, however; some recent research
efforts are seen as attempts to find a common denominator of engineering
activities, highlighted in Figure 1, to establish foundations for process-
centric QSE e.g. (Weder et al., 2021)(Khan et al., 2022b)(Ahmad et al., 2022).
Building on the notion of a QSE intensive process, new software development
processes and methods or customizing the existing conventional methods (hybrid
quantum-classical) are required (Weder et al., 2021)(Hernández González and
Paradela, 2020)(Khan et al., 2022a).

###  2.2. Agile for Quantum Software Development

In line with the legacy of experiences in conventional programming, which also
started from hardware-focused, hard-wired techniques in 1950s and then evolved
into today’s agile system development practices, the QSE should eventually
follow the same agile development tradition (Moguel et al., 2020)(Piattini et
al., 2021). However, tools and methods that are used to achieve agility in
conventional software engineering need to be examined in line with the
characteristics of quantum software development (Khan et al., 2022b). When
coding quantum programs, software developers face new challenges due to
switching to an entirely different programming mindset with counterintuitive
quantum principles (Khan et al., 2022b). For example, executing the quantum
instructions in the state of qubits and measuring the qubit values (De Stefano
et al., 2022).

Figure 1. Overview of quantum computing

Testing quantum programs requires at least the development of solutions to
tackle the following challenges of (1) defining test oracles as the state of a
quantum program can be in superposition and thus difficult to get precise
state; (2) running efficient quantum test data generation since quantum
variables might be exponentially higher than classical variables; and (3)
dealing with false positives/negatives due to vulnerabilities to hardware
glitch (Wang et al., 2022a)(Wang et al., 2022b). Finally, faults found in
quantum programs with testing must be located, isolated, and patched; thus,
debugging is needed. Furthermore, developing effective debugging solution is
impeded by the following challenges of: (1) examining values of quantum
variables in superposition; (2) interpreting multi-dimensional quantum states,
despite the availability of simulation techniques, and (3) lacking guidance on
where and what to check when debugging quantum programs (Huang and Martonosi,
2019).

In conventional software engineering, the above mentioned challenges are
alleviated via adopting the agile and iterative principles. In line with this,
there has been a long-standing acknowledgment that agile practices have shown
their efficacy in practice (Dybå and Dingsøyr, 2008). Proponents of the agile
practices claim, in contrast to the traditional methodologies (e.g. Waterfall
model) (Dybå and Dingsøyr, 2008), agile solves many of the problems endemic to
the field by proposing principles and practices such as active user
involvement, short iterations, small and frequent release, and refactoring
(Beck et al., 2001). This, in turn, supports their state of flow, which is an
important ingredient in modern-day software development (Mikkonen, 2016). In
present scenario, QC is still in its infancy, and the situation of developing
a quantum software could considerably be eased by adopting agile practices as
suggested by Piattini et al. (Piattini et al., 2021): "we should adopt a more
“agile” approach when proposing and developing software engineering quantum
techniques, that is, do not wait until quantum programming languages are
“stable” or “refined” in order to adapt existing techniques or create new
ones, but develop them in parallel with the evolution of the quantum
languages, starting from now". Agile software development help find bugs and
other problems as early as possible because at that point the developers can
fix them with straightforward actions. Moreover, today quantum software
development activities are mostly hybrid (classical and quantum) (Weder et
al., 2021), therefore conventional agile practices provide a set of best
practices for developing a quantum software through collaborative efforts of
self-organising and cross-functional teams. Gonzalez and Paradela (Hernández
González and Paradela, 2020) complemented it by explicitly mentioning that:
"Quantum software development projects currently have numerous features that
fit neatly into the agile paradigm, such as adding features evolutionarily or
using trialand-error algorithms".

However, to the best of our knowledge, no empirical study has yet been
conducted to explore the perception of practitioners for using agile practices
to develop a quantum software system. This study aims to fill the given
research gap by conducting interviews with practitioners to address the core
research questions (RQs) discussed in the section 3.2.

##  3\. Methodology

We now detail the research methodology, as illustrated in Figure 2, which
comprises the following steps.

###  3.1. Context (Process-centred quantum software)

To understand a structured approach for developing quantum software, we
collaborated with industrial partner (Quanscient Oy)111https://quanscient.com/
and studied the incremental quantum software development process (Khan et al.,
2022b) \- including four iterative activities (i) quantum domain engineering
(ii) quantum system co-design (iii) Quantum algorithm design and
implementation, and (iv) quantum code simulation and validation (see Figure
2). For illustrative purpose, Figure 2 demonstrates what iterative activities
needs to be done and each activity details how it is to be done.

However, this study aims to extend our previous work (Khan et al., 2022b) by
using agile practices to support the quantum software development process
activities. The findings of this study will provide in-depth understanding of
agile-driven quantum software development. Therefore, we structured the
following research questions and developed the interview instrument to achieve
the study aims.

Figure 2. Overview of the research methodology

###  3.2. Research Questions

We formulated following two research questions (RQs) that help us to present
the results of the study.

RQ1: Do agile practices best suited for developing quantum software?

Rationale: To understand the practitioners’ perceptions on the significance of
agile practices in quantum software development. It has yet to explore if
agile practices are applicable, or may need augmentations to be applicable for
developing quantum software systems (Khan et al., 2022b).

RQ2: What are the challenges of adopting agile practices for developing a
quantum software system?

Rationale: To identify the challenges that impede adopting agile practices for
developing quantum software. Identification and classification of the
challenges can help to explore potential areas which need significant academic
and industrial attention for defining guidelines and/or solutions that address
or mitigate these challenges.

###  3.3. Interview

Interview instrument: Following the guidelines by Robinson (Robinson, 2014),
we developed semi-structured questions which covered three categories,
including (i) demography and professional details, (ii) suitability of agile
practices for developing quantum software (RQ1), recorded via a 5-point Likert
scale (Strongly agree to Strongly disagree) detailed later and (iii)
challenges of agile-driven quantum software development as open-ended question
for spontaneous responses (RQ2) (analysed with GT in Figure 2). The first
three authors conducted regular meetings and developed the interview
questions; finally, a Zoom meeting was called and invited all other authors to
conclude the interview instrument222https://tinyurl.com/5y2fd56m.

Recruiting participants: We strictly sought practitioners with a mutually
inclusive knowledge of ‘agile SE’ and ‘QC’ ensured via contacting the
potential participants and informal discussion on their willingness and
required basic knowledge of the subject. We used relevant platforms such as
GitHub, professional social media networks (i.e., LinkedIn, ResearchGate,
WeChat, Facebook, mailing groups), industrial network and personalised emails
to contact the targeted population. A total of 73 practitioners were contacted
and eventually 26 participated in the interview as shown in Figure 3(a).

Pilot interviews: Three pilot interviews were conducted to seek early feedback
on the types and formulation of questions, the required time to complete the
interview, and the assessment for collecting interview data. Note that pilot
interviews data are not used for the final data analysis. It is only used to
refine the understandability, readability and structure of the interview
questions.

Based on the refinement from pilot interviews, we shared the final interview
questions with 26 agreed participants a week before the session and provided
the author’s contacts if they had any questions regarding the interview
material. The interview sessions were conducted online by the second author
using Zoom, VooV meeting and Microsoft Teams platforms.

##  4\. Analysing Interview Data

Based on the semi-structured interview questions (Section 3.3), we analysed
the data in three steps. First step analysed the demographic details of the
practitioners such as their country, years of experience, professional domain
etc., as presented in Figure 3. Demography details complement the analysis of
interview data corresponding to RQ1 and RQ2. For example to analyse if factors
like years of experience, domain of experience (cyber security or automotive
engineering etc.) and/or professional roles (agile coach or quantum algorithm
developer etc.) impacts practitioners perspective or knowledge on the
application of agile practices to quantum software development.

Second step involved recording the interview data for RQ1, using a 5-point
Likert scale (Strongly Agree, Agree, Neutral, Disagree, Strongly Disagree)
followed by an open-ended question to rationalise or describe their choice, as
shown in Figure 4.

The last step focused on RQ2 and we adopted the Grounded Theory (GT) method
(Glaser and Strauss, 2017) to derive a mapping of code, concepts, and
categories as in Figure 2. GT is a systematic method to generate a theory or
conceptual view out of raw data and to enable researchers to have amenable
interpretation and free comprehension of data in different ways (Glaser and
Strauss, 2017). We adopted the GT approach for various reasons, e.g., agile
practices are more people-oriented, and GT helps to examine teams’ behaviors
and social interactions explicitly (Hoda et al., 2010). Similarly, Hoda et al.
(Hoda et al., 2010) mentioned that GT is the best fit for novel research
fields which have not been previously well explored, and the research on agile
in quantum software development is scarce. GT has received growing attention
in software engineering research and more narrow in the agile domain e.g.
(Madampe et al., 2021)(Masood et al., 2020)(Hoda and Noble, 2017).

The GT open coding (Allan, 2003) and constant comparison approaches (Glaser
and Strauss, 2017) were followed to analyze the raw data and identify the core
categories of agile-driven quantum software development challenges. The data
coding and mapping are preliminary conducted by the first three authors
following the GT guidelines (Glaser and Strauss, 2017). However, the rest of
the authors were invited to participate and provide feedback in the final data
coding and concept development process. The following raw data example is
presented to explain the analysis process stage to coding, concept
development, and categorization (Figure 2).

Raw data: "the biggest challenge of scaling agile practices in Quantum
software development is about providing basic knowledge of quantum physics
such as quantum bits and quantum gates etc. to the entire team" [P17], Quantum
sofwtare engineer.

Code: Basic knowledge of quantum mechanics

The codes evolved from each interview response were constantly compared with
the codes of the same interview and the entire data set, including the
interviews of other participants. The mentioned code "basic knowledge of
quantum mechanics” (P17, Quantum software engineer) was found similar to two
other codes, namely "understanding agile in the quantum software domain” (P10,
Scrum master) and "scholarly material” (P14, Agile trainer). The similar codes
were grouped and defined the common concept, which is the higher level of
abstraction.

Concept: Knowledge gap

The other relevant concepts that emerged during the constant comparison of
codes are the "team dynamics" and  "quantum software development education".
The final constant comparison was conducted for a similar group of concepts to
create the final, and high level of abstraction called categories.

Category: Knowledge and awareness

Knowledge and awareness is a high-level concept that encapsulates the insights
and perceptions of participants, who were more concerned about the guidance,
support and awareness of quantum computing concepts and their integration with
agile principles.

In this study, the level of abstraction (coding, concept creating, category
development) was based on real-world data; therefore, the subsequent
discussion is grounded in the context of the collected data. Note that the
other categories of challenges were derived following the same open coding and
constant comparison methods. However, we provided a sample analysis process
only for the knowledge and awareness category but omitted it for all the other
categories because of space restrictions. The emerged categories represent the
challenging of agile-driven quantum software development. We are not claiming
the universal generalizability of the study results grounded on the collected
data; however, it perfectly described the investigated context (Adolph et al.,
2008).

The categories constituting knowledge and awareness, sustainable scaling,
quantum-aware tools and technologies and standards and specifications along
with the important quotes from practitioners are delineated in the following
sections. We further considered the developed concepts to support the
findings; however, the space restrictions limited us from describing them in
detail.

##  5\. Results

This section presents the study results, addressing the two RQs outlined in
Section 3.2. Moreover, the demographic analysis was conducted to examine the
dimensions and dynamics of the targeted population and contextualize the
responses that complement agile-driven quantum software development for a
specific group of practitioners (see Figure 3). We noticed that 26 respondents
from 10 countries across 4 continents with 16 roles and 15 different work
domains participated in this study (see Figure 3(a,d,e)). Note that each
interview participant is tagged with a unique id [P#], as shown in Figure
3(d). The experience of interview participants in the quantum software
development domain mostly ranges from 0 to 3, which is (n=19) of the total
responses (see Figure 3(c)). Of all the responses, the majority (n=16) have
6-10 years of professional working experience as practitioners (see Figure
3(b)). The results illustrate that most (n=13) of the interview participants
work as quantum system engineers, which is further classified across 6
different sub-roles (see Figure 3(d)). Therefore, the given demographic
findings reveal that the interview participants are diverse with respect to
geographical locations, experiences, roles, and industrial domains. It gives
us the confidence to generalize the study findings to some extent. The
detailed results to address both RQ1 and RQ2 are presented in the following
sections.

Figure 3. Overview of interview participants demographics

###  5.1. Agile for Quantum Software Development (RQ1)

To understand practitioners’ perspectives on the applicability of agile
practices to develop quantum software, we sought their feedback using a five-
point Likert scale as shown in Figure 4. The selection of a five-point pre-
defined response was complemented by an open-ended optional question that
allowed practitioners to express the description of their choice
spontaneously. Figure 4 shows that a total of 12 practitioners agreed
strongly, and 5 agreed (i.e., n=17) that agile practices can be used to
develop quantum software. The open-ended descriptions suggest that
practitioners perceive QSE as another genre of software engineering, domain
modeling, incremental mapping of Qgates and Qubits, and quantum system co-
design that can fit well in agile software development. For example, a
participant suggested that s/he strongly agrees on the application of agile
practices to quantum software development as quantum system co-design, i.e.,
translating the quantum software requirements into quantum design and source
code can benefit from the incremental approach of agile. On the other hand,
three participants remained neutral, rationalizing their view on knowledge of
quantum mechanics (operationalizing Qubits) can be challenging for traditional
software engineers (see Figure 4). Furthermore, 2 participants strongly
disagreed, while 4 disagreed (i.e., n=6) on application of agile for quantum
software development. They justified the counterproductivity of applying agile
practices in quantum software development by reasons such as immature tools
and technologies, lack of professional expertise, and a well-curated
architecture. We conclude that while answering RQ1, approximately 2/3 majority
recommended the application of agile practices to develop quantum software, an
incremental mapping of quantum domain concepts can help to operationalize
quantum software. Approximately 1/4 of practitioners cited as non-availability
of tools, and professional expertise can be a reason for their disagreement.

Figure 4. Agile practices for quantum software development

###  5.2. Challenges of Agile-driven Quantum Software Development (RQ2)

The identified five key categories (knowledge and awareness, sustainable
scaling, quantum-aware tools and technologies and standards and
specifications) present the challenging aspects that need to consider for
scaling agile practices in the quantum software development domain (see
section 4). The following sections describe each category in detail with the
quote support selected from the interview data.

####  5.2.1. Knowledge and awareness

The awareness and knowledge of agile practices in the quantum software
development domain have emerged as an important category, consisting of three
concepts: knowledge gap, team dynamics, and quantum software development
education.

  * •

Knowledge gap

Agile practitioners most likely experience some particular areas of quantum
software development more challenging because of the knowledge gap
(classical->quantum), such as quantum domain engineering, architecting quantum
software, quantum source code interpretation, and quantum algorithm complexity
(Ahmad et al., 2022)(Li et al., 2021). For instance, the conventional agile
practitioner might not know how to design a quantum algorithm attuned to
operationalize Qubits rather than classical bits (Ahmad et al., 2022).

The feedback of interview participants is aligned with it and perceived that
knowledge of quantum computing helps practitioners in the better adoption of
agile practices as endorsed by one of the interviewee:

"But as this wave of innovation continues, a necessary element lags behind: a
quantum-skilled workforce. To develop quantum software workforce, the agile
iterations give quick feedback and chance of speed learning and experiences"
[P10], Scrum master.

Generally, agility refers to delivering customer value faster, incremental,
and with less headaches (Beck et al., 2001)(Dybå and Dingsøyr, 2008). Despite
this, managing agile activities in the quantum software domain considered with
worries (Khan et al., 2022b). Participants recommended the need for the
alignment among skills, quantum awareness, resources, and technologies for
developing agile-based quantum software, as mentioned by an interview
respondent.

“Agile teams can get bogged down by failure in the novel quantum paradigm.
However, starting with the end goal is imperative when building an agile team
to work on a quantum software engineering project. How will you reach your
goal, and what skills, technology, and hours will you need? Only then you can
build the team” [P13], Agile coach.

  * •

Team dynamics

Agile practices have inherent focus on team structure (e.g., common goals,
roles, responsibilities, collaboration), and organized team dynamics is a key
to high functional agile productivity (Inc, 2014) (Beck et al., 2001)(Dybå and
Dingsøyr, 2008). A happy agile team will essentially be more productive;
conversely, the team can be extremely ineffective (Inc, 2014). Agile team
dynamics is challenging to manage in the quantum software domain because of
the different quantum rules set. The agile team’s mindset will likely change
due to quantum physics characteristics such as superposition, entanglement,
and quantum interference, which significantly influence the way software
development team works (Khan et al., 2022b). This rationale was captured quite
well by a respondent:

“Because of flaky characteristics of QC, agile teams face significant
challenges due to switching to an entirely different programming paradigm. The
bits and qubits interpretations and manipulation bring high-level confusion
for agile team forming, storming, norming, and performing” [P16], Quantum
software engineer.

  * •

Quantum software development education

Quantum software development as a computer science subject is still at an
early stage (Peterssen, 2020)\- in contrast to QC education, which is already
taught in various universities (Carberry et al., 2021). The increasing boom of
QC technologies calls for educational approaches that structure core ideas and
terms for quantum software development as a subject (Peterssen, 2020). The
respective applications of core ideas constitute the foundation for defining
quantum software development curricula. The above literature findings were
supported by the respondents more narrow in an agile-quantum context, for
example:

“Academic treatment require to offer agile-enabled quantum software
development as a subject area, at least at the university level. It will give
learning opportunities to realize the capabilities of agile practices for
developing quantum software and allow students to exercise their cognitive
muscles as well as joined-up thinking. I understand that incorporating agile-
based quantum software engineering as a subject in degree programs will help
in preparing a skilled workforce to fulfill the future needs of the quantum
software industry” [P20], Software quality engineer.

####  5.2.2. Sustainable scaling

Emerging quantum software engineering is a paradigm shift that demands
enhancing the conventional processes and practices to support requirements of
quantum reality (Zhao, 2020) (Khan et al., 2022a). Piattini et al. (Piattini
et al., 2021) recommended scaling the conventional agile practices to develop
quantum software; however, it is essential to set sustainable strategies to
avoid potential risks and scaling pitfalls (Hunter et al., 2022). For
instance, one of the interview participants mentioned that:

“Organizational and team structure is a huge part of the hybrid agile-quantum
process, and top management should be prepared for it. Remember, be fast, and
sustainable in integrating agile with quantum software lifecycle by
identifying the process aspects that need improvement else immediately find
alternatives” [P2], Project manager.

The sustainable scaling category is based on the two concepts: ethically
aligned quantum software and agile-quantum ecosystem.

  * •

Ethically aligned quantum software

Quantum software engineering is a new genre of software development, and the
boom of QC from research to the business raises various ethical concerns
(Saurabh and Rustagi, 2022). The QC transition threatens the existing ethical
protections, e.g., security, and transparency (Hunter et al., 2022). For
instance, one of the interview participants justify it more in agile-driven
quantum software scenario:

“ I have never come across a framework used to determine the ethical concerns
raised in agile-quantum software development. I argue that regulatory bodies
shall step forward to consider the ethical risks of quantum theory
applications and invest in a coordinated approach to govern the potential
risks effectively" [P18], Business intelligence engineer.

The interviewee’s statement is supported by Buchholz and Ammanath (Buchholz
and Ammanath, 2022) broadly in the quantum computing domain by mentioning that
the ethical concerns raised by QC are still on the horizon, and not possible
to tackle them immediately. However, it’s time that industrial and government
stakeholders realize the trigger events and start thinking to develop the
strategies (Buchholz and Ammanath, 2022). The existing classical frameworks
could be the best fit to start building ethical guidelines and models in the
QC domain.

  * •

Agile-quantum ecosystem

QC ecosystem is growing beyond advancements in hardware, and people have
started focusing on producing quantum software and business partnerships
(Combs, 2022). Reaping the business interests of quantum software enables
teams to connect and collaborate from anywhere. However, developing
sustainable collaboration between teams and businesses is challenging as
collaboration sits at the intersection of computer science, quantum physics
and applied mathematics (Branczyk, 2021). The collaboration could be
complemented by presenting an ecosystem as highlighted by an interview
participant more specific in agile based quantum software development:

“ Agile activities more focus on collaboration and communication across teams,
customers and other stakeholders. On the other hand, quantum software
development is a paradigm shift and the agile teams must need an ecosystem
that help them to seamlessly collaborator with customers and stakeholders from
other domains (e.g. quantum physics)” [P11], Agile coach.

####  5.2.3. Quantum-aware tools and technologies

A wide range of tools are available to support quantum software development
activities. For example, Qiskit (IBM, 2021) is a known open-source tool
available as a service on IBM cloud for developing quantum software at module,
circuit and algorithm levels. Similarly, Microsoft Azure Q# and the Quantum
Development Kit offers tools as a service for quantum software development
i.e., designing the quantum algorithm, optimizing the solutions, and applying
the optimized solutions across the Azure platform to see the real-world
impacts (Microsoft, 2021). Moreover, Khan et al. (Khan et al., 2022a)
thoroughly discussed the existing toolchain support for architecting a quantum
software system. However, the interview participants highlighted its lack for
customizing agile practices to develop quantum software.

“Presently, it’s exceedingly difficult to develop quantum software that offers
commercial-level benefits which lift economies. We need to present novel tools
and techniques that support hybrid quantum-classical development, for
instance, using the traditional (classical) agile practices to support quantum
software development activities” [P6], Quantum network engineer.

The quantum-aware tools and technologies category emerged from two underlying
concepts: classic-quantum tailoring and continuous SE infrastructure.

  * •

Classic-quantum tailoring

It is commonly acknowledged that one-size-fits-all application of methods and
processes is fallacious (Fitzgerald et al., 2006). In line with it, classical
techniques must be tailored to achieve the optimum effect in the quantum
software domain (Weder et al., 2021)(Zhao, 2020). The tailoring could be
actualized using domain-specific tools and technologies (Fitzgerald et al.,
2006). The need for such tools and technologies continue as a persistent theme
in quantum software development (Khan et al., 2022a)(Weder et al., 2021).

In this study, classical-quantum tailoring is particularly related to
customizing the traditional agile practices for quantum software. However, the
interview participants highlighted the lack of tools and techniques to support
the tailoring process, for example:

“The conventional agile practices must be used to develop the quantum software
system. However, designing a compatible, customizable, and tailorable agile
approach that defines the best practices for quantum software required a set
of tools and technologies, and presently, the lack of such tools seems a major
challenge” [P8], Team lead.

  * •

Continuous SE infrastructure

Agile-driven quantum software development infrastructure is required for
implementing a deployment pipeline and monitoring dashboard to support the
development experience (Khan et al., 2022b), similar to modern-day continuous
software engineering (Fitzgerald et al., 2006). This pipeline will collect
data from the development activities and visualize the practitioner’s
experiences and customer feedback (Khan et al., 2022b). However, such
infrastructure is not yet implemented on a large scale, as mentioned by the
interview participant:

“Agile-based quantum software development includes various phases which
consist of multiple components and are often difficult to implement manually.
It require infrastructure support complemented by open source tools to
automate and enables continuous software engineering practices, e.g.,
continuous integration” [P12], Software designer.

####  5.2.4. Standards and Specifications

Standards and specifications establish a common agreement for engineering
criteria, terms, principles, items, practices, and processes (AcqNotes, 2021).
In this study, standardization and specifications emerged as the core category
of challenging factors based on two elementary concepts: process
standardization and optimum documentation.

  * •

Process standardization

Standardization plays an important role in portraying and strengthening the QC
technologies (Nikitin, 2021). In line with it, the interview respondents
perceived standardization as a roadmap for considering agile practices to
develop a quantum software system. For instance, one of the interview
participants described it as:

"Using agile practices to develop a quantum software could be crucial to
encapsulate the agile manifesto and develop a quality product. It is important
to provide a roadmap (standards) that define rules, guidelines or
characteristics for activities used to bring agile practices in quantum
software development domain" [P8], Team lead.

  * •

Optimum documentation

In agile software development, optimum documentation provides the best
possible process and the adaptability of changes across the development life
cycle (Linders, 2014)(Anwar, 2016). Simple and lightweight documentation in
agile is “living,” and it needs to be collaboratively maintained by the whole
team (Nuclino, 2016). Similar understanding (optimum documentation) is
supported by the interview participants for agile-driven quantum software
development. For instance, one of the interviewees mentioned:

"Agile focus on minimizing waste; logically considering it, the project
documentation is unnecessary and exhaustive activity. However, it doesn’t mean
documentation should be neglected and thrown away (particularly for hybrid
agile-quantum activities). The new agile quantum software development genre
must require documentation and guidelines at some extent to ensure the success
of the process, product and project" [P10], Scrum master.

##  6\. Discussion

We now summarise the study’s core findings (RQ1, RQ2), implications for
research and practice and threats to the validity.

###  6.1. Agile for Quantum Software Development (RQ1)

Applying agile practices enables QSE teams to tackle quantum software
development endeavours by relying on iterative and incremental development to
deliver quantum software. For instance, an increment of transforming the
quantum domain knowledge (e.g., secure transmission of key in a quantum
network) to a quantum algorithm (implementing Shor’s algorithm for decryption)
emphasizes a piecemeal development and quantum-specific knowledge being
translated into implementation details (Zhao, 2020)(Khan et al., 2022a).

The overwhelming majority of the interviewed practitioners (i.e., 17/26)
endorsed that the application of agile practices enables development teams to
undertake quantum software development tasks more effectively and efficiently.
Specifically, the practitioners rationalized their endorsement based on the
view that QSE is yet another genre of SE based on quantum mechanics,
therefore; the principle and practices of conventional agile practices can be
applied in a quantum software development lifecycle (Hernández González and
Paradela, 2020)(Piattini et al., 2021)(Khan et al., 2022b). Moreover, the
advocacy of agile for quantum software highlighted a multitude of reasons by
practitioners such as model-driven QSE, increments to map various quantum-
centric models (e.g., domain, architecture, code, simulation model), and
quantum system co-design as shown in Figure 5. On the contrary, approximately
1/4 (6/21) of the surveyed practitioners disagreed with agile-driven quantum
software development sharing their skepticism as immature tools and
technologies (Zhao, 2020), lack of professional expertise such as quantum
software modeling (Gemeinhardt et al., 2021), and the needs of a well-curated
architecture (Ahmad et al., 2022), among the reasons for the rejection (see
Figure 5). Three participants remained neutral, rationalising the reasons that
the knowledge of quantum mechanics or lack of it may be determinantal factors
for developing a team to opt for agile practices or not while undertaking
quantum software projects (see Figure 5).

We noticed that the disagreement or neutral factors raised by the interview
participants were later identified as the core categories of challenges. For
example, the participants rejected using agile practices for developing
quantum software because of immature tools and technologies, which is directly
related to the Quantum-aware tools and technologies category of challenges as
shown in Figure 5. It reveal that most of the disagreement and natural factors
are emerged as the core challenging categories (see Figure 5).

Figure 5. Discussion

###  6.2. Agile Practices Challenges in Quantum Software Development (RQ2)

Agile SE to develop quantum software involves a multitude of challenges that
vary from lack of knowledge and skills (people-centric), quantum-centric tools
and development platforms (technology-centric), sustainable scaling (societal-
centric ) along with models and documentation (process-centric) (see Figure
5).

Quantum-centric awareness and knowledge: The practitioners’ responses reveal
that lack of quantum-awareness in agile teams, i.e., limited or non-existent
knowledge, skills, teamwork and education, are among the prime challenges for
seamless and at-a-scale adoption of agile practices in the quantum software
development context (Hernández González and Paradela, 2020)(Peterssen, 2020).
The study analysis suggested that practitioners explicitly referred to
knowledge as quantum mechanics know-how, such as quantum entanglement, quantum
superposition etc. while manipulating quantum bits. In quantum software
development, agile teams are perceived to work better when built-around
practitioners who could be quantum-aware (team dynamics); this means that
instead of a traditional project manager or scrum master a quantum domain
engineer is perceived as the right professional to lead the software
development tasks in a bottom-up approach from domain knowledge to quantum
modelling, implementation, and execution/simulation (Ahmad et al., 2022). Lack
of education and knowledge are obvious challenges, however, it may be seen as
an opportunity to design a course curriculum (degree level) that can help
preparing the skilled workforce with extensive knowledge and understanding of
agile-driven quantum software development. Such courses may help software
engineers and developers to leverage their existing skill set to work on
quantum software development (Peterssen, 2020)(Li et al., 2021).

Ethically aligned agile-quantum ecosystem: In addition to the technical,
socio-technical aspects faced by the quantum software team is perceived as a
challenge with far-reaching consequences of what is referred to as the
ignorance of ethics and the lack of agile-quantum ecosystem (section 5.2.2).
With the increased adoption of QC technologies, ongoing debates both in the
academic and industry advocate for framework and guidelines for ethically-
aligned quantum computing technologies (Saurabh and Rustagi, 2022). From an
agile perspective, practitioners did emphasize that quantum-age software needs
an ecosystem that provides services and processes for seamlessly bridging the
gap between agile teams and stakeholders from other domains e.g., quantum
physics and applied mathematics. Similarly, the computational supremacy of QC
technologies in areas like security (e.g., data en-/decryption) and bio-
inspired computing (e.g., gene editing) should adhere to development
practices, audits, and metrics that ensure quantum software potential does not
undermine social norms and values.

Lack of maturity and openness in tools: Software tools such as model-to-code
translators and test case generators are used to automate and customize
developmental lifecycle tasks that may be time-consuming and error-prone
(Zhao, 2020)(Weder et al., 2021). One of such tasks is the conventional agile
and Quantum tailoring (Hernández González and Paradela, 2020) that lacks the
tool support, for example source code execution via classical (binary gates)
and integration through quantum (Qgates). Another hindrance relates to the
lack of infrastructure to visualize and automate the agile-driven continuous
QSE activities. The availability of open-source tools can ensure community-
wide initiatives to develop such infrastructure that can be customized,
readily evolved, and widely adopted rather than individual solutions that may
apply to a limited set of problems (Khan et al., 2022a).

Standards and optimal documentation: Agile based SE is seen as a light and
adaptive mechanism to develop and deliver software-intensive systems and
products (Beck et al., 2001). In line with the agile manifestation for minimal
documentation (Beck et al., 2001), quantum software standards can be treated
as necessary instruments to define agile-aligned quantum software roles and
essential documentation to guide the team. For example, a readiness model
which provide a set of best practices and guidelines for classic-quantum
transformation or hybridization (classic-quantum co-design) (Akbar et al.,
2022). In line with (Akbar et al., 2022), standards can act as sufficient
documentation and specifications that assist in moving from ad hoc agile-
driven quantum software development practices to more mature processes.

###  6.3. Implications for Research and Practice

Some implications arise from this research as listed in the following.

Implications for research: The results of the study complement the recently
emerging streams of research on quantum software engineering, particularly add
practitioner-centric view via empirically-based findings to agile-driven
quantum software development. Researchers can utilize the results to quickly
lookup the streamlined challenges (i.e., new hypotheses to be tested)
regarding the knowledge, skills, tools, technologies, ethics, sustainability,
and process aspects of quantum software engineering. The study’s findings, on
the other hand, give quick access to the body of knowledge based on the
practitioner’s understanding of agile-driven quantum software development.

Implications for practice: The study delivers inferential empirical findings
to industrial practitioners and/or stakeholders interested in the fine-grained
analysis of agile practices for quantum software development. The overview and
interpretations of adaptability and potential challenges of agile-driven
quantum software development provided a roadmap enlightening software
practitioners interested in using agile practices for developing quantum
software. In particular, the practitioners perspectives could help developers
to engineer the next generation of quantum software.

###  6.4. Threats to validity

Various potential threats could affect the validity of the study findings. The
relevant threats are broadly categorized across internal, construct, external
and conclusion validity (Zhou et al., 2016).

Internal validity: Internal validity is the extent to which particular factors
affect the methodological rigor. In this study, the first threat to internal
validity is the interview participant’s understanding of the interview
questions. This threat has been mitigated by conducting pilot interviews to
ensure the understandability and readability of the interview questions (see
section 3.3). The limited or no relevant expertise of participants to answer
the interview questions is also a potential internal validity threat. We
approached agile SE and QC practitioners using the personal network,
industrial collaboration, code hosting platforms (e.g., GitHub) and
professional social media networks (e.g. LinkedIn). Only participants having
mutually inclusive knowledge of conventional agile and QC practices were
selected. The interpersonal bias in the data collection process may threaten
the internal validity of study findings. We mitigated this threat by
organizing regular consent meetings between all the authors for interview
instrument development, feedback and GT data analysis (i.e. coding, concept
development, categorization). GT findings are limited and applicable to the
studied contexts and domains (Glaser and Strauss, 2017),which in succession
are dictated by access to the study participants. Therefore, we strongly
ensured that all the details of interview participants- individual to
organizational- will be strictly confidential. The study findings would be
enormously used for research purposes only and not be shared with third-party
under any circumstances.

Construct validity: Construct validity is the extent to which the study
constructs are well defended and interpreted. In this study, the perceptions
of the interview participants on agile adaptability and relevant challenges
are the core constructs. The verifiability of constructs is a known limitation
of GT studies. It could be inferred from the research method efficacy and from
the evidence that the study findings are presented based on the data collected
using the selected research method (Hoda et al., 2012). Therefore, we
explicitly discussed the step-by-step process of the research method (see
section 4), the defined categories supported with quotes from the interview
participants and our observations in section 5.2. It exhibits how the
systematically defined research protocol and reported findings (RQ1, RQ2)
support the verifiability of the study constructs.

External validity: External validity refers to broadly generalizing the study
findings in other contexts. In this study, the sample size and sampling
approach may not provide a strong foundation to generalize the findings.
However, it is know fact that QSE, and particularly using agile practices for
developing quantum software, are new research areas and not in practice at a
high level. We tried to mitigate this threat by using all possible sources
(see section 3.3) to approach the potential population. We collected data from
10 countries across 4 continents, with participants having 16 different
professional roles and a diverse range of experience in various industrial
domains (see Figure 3). Moreover, we plan to extend this study in the future
with a large data sample from multiple data sources (i.e. mining the Q&A
platforms, conducting industrial surveys and interviews) (see section 8).

Conclusion validity: Conclusion validity refers to the factors that affect the
credibility of the study conclusions. To address this threat, the first three
authors were continuously involved in the interview instrument development and
data analysis process. The second author mainly collected the data by
conducting live Zoom sessions with the participants. However, all other
authors occasionally (consent meetings) reviewed the data and provided their
feedback to tackle the conflicts that appeared during the data collection and
analysis process. Finally, brainstorming sessions were conducted, and all the
authors participated in discussing the study findings and drawing conclusions.

##  7\. Related Work

We discuss the most relevant existing work, reviewing state-of-the-art on
processes and development lifecycle(s), for quantum software systems (Zhao,
2020). A conclusive summary at the end reiterates the scope and contributions
of the proposed research.

###  7.1. Process-centred Engineering of Quantum Software

Quantum software engineering – most recent genre of software engineering –
aims to apply existing processes, practices, methods, tools, and techniques to
design and develop quantum age software systems and applications effectively
and efficiently (Ali et al., 2022)(Piattini et al., 2021). The existing body
of SE knowledge provides foundations for quantum software development (Zhao,
2020), however; unique characteristics of quantum software (e.g., quantum
system co-design, quantum source coding) and quantum specific professional
expertise (e.g., quantum domain engineer, quantum source coder) requires
traditional SE methods to be tailored to address QSE challenges (Ahmad et al.,
2022)(Khan et al., 2022a). To investigate quantum specific software
architecting and development, recently conducted systematic reviews aim to
establish empirical foundations to design (Khan et al., 2022a) and develop
(Heim et al., 2020) quantum software by streamlining the required process,
existing patterns, and ideal tool chain(s) that can empower the roles of
traditional software developers as quantum software architect and developers.
QSE as a discipline is still in its infancy, however; community wide
initiatives are gaining momentum, for example with dedicated
conference333https://conferences.computer.org/qsw/2022/, workshop
(Q-SE)444https://conf.researchr.org/home/q-se-2022, literature reviews (Heim
et al., 2020)(Zhao, 2020)(Gill et al., 2022)(Khan et al., 2022a), and
repositories mining (De Stefano et al., 2022) efforts with a common
denominator of using best practices and reusable knowledge (processes,
patterns, reference architectures, etc.) to effectively and efficiently
develop quantum software (Ali et al., 2022)

###  7.2. Iterative Development of Quantum Software

To synergise an iterative development with quantum software engineering
process, Khan et al. (Khan et al., 2022b) present the vision for continuous
iterative development and delivery of quantum software. However, iterative
enabled quantum software development is still in its infancy and demands novel
domain specific techniques and processes as suggested in (Khan et al.,
2022b)(Hernández González and Paradela, 2020)(Weder et al., 2021). Considering
the existing QSE methods and techniques(Weder et al., 2021)(Gemeinhardt et
al., 2021)(Wang et al., 2022a)(Ali and Yue, 2020) there is still no or even
consensus on agility in quantum software. The adoption of agile for quantum
software development can help practitioners to iteratively experiment new
ideas, and improve performance- all in parallel (Khan et al., 2022b)(Hernández
González and Paradela, 2020). In line with this, Gonzalez and Paradela
(Hernández González and Paradela, 2020) conceptualised a hybrid project
management framework (unifying classical and quantum SE) for agile and
incremental management of software that can be adapted to the needs of
quantum-age computing. However, the study do not presented any empirical
evidence to actualise the proposed framework. Similarly, using the
contemporary SE practices, Weder et al. (Weder et al., 2021) introduces a
quantum-based software development process that comprises of eight classical
phases with induction of a new phase called quantum-classical splitting. The
quantum-classical splitting phase is tailored for quantum software systems and
it distinguishes between parts of the quantum software that need to be
executed on a quantum computer and that ones that can be executed on classical
computers.

###  7.3. Conclusive Summary

In this research, we argue that prior to adopting any specific processes
and/or reference models (Weder et al., 2021) (Hernández González and Paradela,
2020) for agile-driven QSE, there is a need to analyse practitioners
perceptions, professional practices, and empirically grounded findings on the
potential and challenges of adopting agile SE in the context of quantum
software. Our research aims to complement the existing efforts, such as
establishing models (Gemeinhardt et al., 2021), architectures (Khan et al.,
2022a), and processes (Moguel et al., 2020) with an overall aim to systemize
the development of quantum software. This research follows-up on our previous
works (i.e., the cases of architecting (Ahmad et al., 2022)(Khan et al.,
2022a) and iterating (Khan et al., 2022b) quantum software development) with a
practitioner’s interview on the potential of adopting agile practices for
quantum software development.

##  8\. Conclusions and Future Work

Quantum software engineering leverages the principle and practices of
classical SE- empowering the role of architects and developers to deliver
quantum age software applications- providing impetus to QC. We conducted this
study, rooted in empirical analysis and grounded theory, to understand
practitioners’ perspectives on the potentials and pitfalls of agile practices
in quantum software development endeavours. We engaged a total of 26
practitioners from 10 countries generally classified as software engineers,
agile experts, and quantum software developers ( see Figure 3) with an
overwhelming majority agreeing (n=17), approximately one fourth disagreeing
(n=6) and relative minority (n=3) not sure on applying agile practices to
quantum software development, answering RQ1.

To gain better understanding and fine-granular analysis of the disagreements,
we presented open-ended questions on challenges, i.e., hindrances perceived by
practitioners on agile-oriented quantum software development, answering RQ2.
After collecting and synthesizing the responses, we identified 4 categories
organized into 9 sub-categories (concepts) perceived as challenges by
practitioners (see Figure 5). These four categories include: 1) Knowledge and
awareness, which provide practitioners insights and understanding of
challenges that could hinder the adaptability of agile practices for
developing quantum software. For instance, the existing knowledge gap between
classical and quantum software development, different mindsets
(classical->quantum), and lack of agile-quantum specific education and
guidelines.2) Sustainable scaling, encapsulates the challenges related to
harming software sustainability practices. QSE is a paradigm shift, and using
agile to develop quantum software is more likely to threaten the existing
ethical protections (e.g., transparency, accountability) and the agile-quantum
ecosystem. 3) Quantum-aware tools and technologies, category consist of the
challenges related to the immature tool support and lack of infrastructure to
tailor, customize, automate, and configure the agile practices for developing
quantum software. 4) Standards and specifications, category highlights the
lack of common rules and principles for agile-quantum software scenario. From
the perspective of participants, to adopt agile for quantum software the
necessary standards, models, and documentation should be provided.

Our future work is to extend this study by identifying the challenges from
social coding platforms in open-source quantum projects. To achieve this, we
plan to 1) mine publicly available developers’ discussions and code
repositories (i.e., Stack Overflow, GitHub) to explore solutions that the QC
community employs for the effective adoption of agile methods, 2) map these
solutions to the identified challenges with respect to causes, and 3) validate
this mapping via a large sample quantitative survey and interviews of QSE
practitioners.

## Acknowledgments

The research team would like to thank the interview participants and
industrial partner who generously participated and helped us in this research
and shared their time and experience.

## References

  * (1)
  * AcqNotes (2021) AcqNotes. 2021.  Standardization.  https://acqnotes.com/acqnote/tasks/standardization-requirements.
  * Adolph et al. (2008) Steve Adolph, Wendy Hall, and Philippe Kruchten. 2008.  A methodological leg to stand on: lessons learned using grounded theory to study software development. In _Proceedings of the 2008 conference of the center for advanced studies on collaborative research: meeting of minds_. 166–178.
  * Ahmad et al. (2022) Aakash Ahmad, Arif Ali Khan, Muhammad Waseem, Mahdi Fahmideh, and Tommi Mikkonen. 2022.  Towards Process Centered Architecting for Quantum Software Systems. In _2022 IEEE International Conference on Quantum Software (QSW)_. IEEE, 26–31.
  * Akbar et al. (2022) Muhammad Azeem Akbar, Saima Rafi, and Arif Ali Khan. 2022\.  Classical to Quantum Software Migration Journey Begins: A Conceptual Readiness Model.  _arXiv preprint arXiv:2209.05105_ (2022).
  * 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_. 14–21.
  * 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.
  * Allan (2003) George Allan. 2003\.  A critique of using grounded theory as a research method.  _Electronic journal of business research methods_ 2, 1 (2003), pp1–10.
  * Anwar (2016) Rami Anwar. 2016\.  Agile Documentation: Best Practices.  https://delft-circuits.com/standards-for-quantum-technology/.
  * Beck et al. (2001) Kent Beck, Mike Beedle, Arie Van Bennekum, Alistair Cockburn, Ward Cunningham, Martin Fowler, James Grenning, Jim Highsmith, Andrew Hunt, Ron Jeffries, et al. 2001\.  Manifesto for agile software development.  (2001).
  * Branczyk (2021) Aggie Branczyk. 2021\.  What skills do I need to work at a quantum tech start-up?  https://www.linkedin.com/pulse/what-skills-do-i-need-work-quantum-tech-start-up-aggie-branczyk-/.
  * Buchholz and Ammanath (2022) Scott Buchholz and Beena Ammanath. 2022.  Quantum computing may create ethical risks for businesses. It’s time to prepare.  https://www2.deloitte.com/uk/en/insights/topics/cyber-risk/quantum-computing-ethics-risks.html.
  * Carberry et al. (2021) Deborah Carberry, Amirhossein Nourbakhsh, Jay Karon, Mark N Jones, Mojgan Jadidi, Kyarash Shahriari, Christian Beenfeldt, Martin Peter Andersson, and Seyed Soheil Mansouri. 2021.  Building Knowledge Capacity for Quantum Computing in Engineering Education.  In _Computer Aided Chemical Engineering_. Vol. 50. Elsevier, 2065–2070.
  * Combs (2022) Veronica Combs. 2022\.  Quantum computing ecosystem expands in all directions.  https://www.techrepublic.com/article/quantum-computing-ecosystem-expands-in-all-directions/.
  * De Stefano et al. (2022) Manuel De Stefano, Fabiano Pecorelli, Dario Di Nucci, Fabio Palomba, and Andrea De Lucia. 2022\.  Software engineering for quantum programming: How far are we?  _Journal of Systems and Software_ 190 (2022), 111326.
  * Dybå and Dingsøyr (2008) Tore Dybå and Torgeir Dingsøyr. 2008.  Empirical studies of agile software development: A systematic review.  _Information and software technology_ 50, 9-10 (2008), 833–859.
  * Fitzgerald et al. (2006) Brian Fitzgerald, Gerard Hartnett, and Kieran Conboy. 2006\.  Customising agile methods to software practices at Intel Shannon.  _European Journal of Information Systems_ 15, 2 (2006), 200–213.
  * 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.
  * Gill et al. (2022) Sukhpal Singh Gill, Adarsh Kumar, Harvinder Singh, Manmeet Singh, Kamalpreet Kaur, Muhammad Usman, and Rajkumar Buyya. 2022.  Quantum computing: A taxonomy, systematic review and future directions.  _Software: Practice and Experience_ 52, 1 (2022), 66–114.
  * Glaser and Strauss (2017) Barney G Glaser and Anselm L Strauss. 2017.  _The discovery of grounded theory: Strategies for qualitative research_.  Routledge.
  * Google (2022) Google. 2022.  Cirq.  https://quantumai.google/cirq/google/concepts.
  * Heim et al. (2020) Bettina Heim, Mathias Soeken, Sarah Marshall, Chris Granade, Martin Roetteler, Alan Geller, Matthias Troyer, and Krysta Svore. 2020\.  Quantum programming languages.  _Nature Reviews Physics_ 2, 12 (2020), 709–722.
  * Hernández González and Paradela (2020) Guillermo José Hernández González and Claudio Andrés Paradela. 2020.  Quantum Agile Development Framework. In _International Conference on the Quality of Information and Communications Technology_. Springer, 284–291.
  * Hoda and Noble (2017) Rashina Hoda and James Noble. 2017.  Becoming agile: a grounded theory of agile transitions in practice. In _2017 IEEE/ACM 39th International Conference on Software Engineering (ICSE)_. IEEE, 141–151.
  * Hoda et al. (2010) Rashina Hoda, James Noble, and Stuart Marshall. 2010\.  Organizing self-organizing teams. In _2010 ACM/IEEE 32nd international conference on software engineering_ , Vol. 1. IEEE, 285–294.
  * Hoda et al. (2012) Rashina Hoda, James Noble, and Stuart Marshall. 2012\.  Developing a grounded theory to explain the practices of self-organizing Agile teams.  _Empirical Software Engineering_ 17, 6 (2012), 609–639.
  * 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_. 541–553.
  * Hunter et al. (2022) Sophia Hunter, Mira Pijselman, Piers Clinton-Tarestad, Harvey Lewis, and Matthew Bell. 2022\.  Before a quantum transition, what sustainability risks and opportunities should organisations recognise, and prepare for?  https://www.ey.com/en_uk/emerging-technologies/how-can-your-quantum-vision-be-transformed-into-a-sustainable-reality.
  * IBM (2021) IBM. 2021.  Qiskit.  https://qiskit.org/.
  * Inc (2014) Intelliware Development Inc. 2014\.  Agile Team Dynamics.  https://www.intelliware.com/agile-team-dynamics/.
  * ISO/IEC/IEEE (2017) ISO/IEC/IEEE. 2017\.  ISO/IEC/IEEE 12207:2017 - Systems and software engineering - Software life cycle processes.  https://www.iso.org/standard/63712.html.
  * Khan et al. (2022a) Arif Ali Khan, Aakash Ahmad, Muhammad Waseem, Peng Liang, Mahdi Fahmideh, Tommi Mikkonen, and Pekka Abrahamsson. 2022a.  Software Architecture for Quantum Computing Systems-A Systematic Review.  _arXiv preprint arXiv:2202.05505_ (2022).
  * Khan et al. (2022b) Arif Ali Khan, Mahdi Fahmideh, Aakash Ahmad, Muhammad Waseem, Mahmood Niazi, Valtteri Lahtinen, and Tommi Mikkonen. 2022b.  Embracing Iterations in Quantum Software: A Vision.  (2022).  https://doi.org/10.1145/3549036.3562057
  * Li et al. (2021) Heng Li, Foutse Khomh, Moses Openja, et al. 2021\.  Understanding Quantum Software Engineering Challenges An Empirical Study on Stack Exchange Forums and GitHub Issues. In _2021 IEEE International Conference on Software Maintenance and Evolution (ICSME)_. IEEE, 343–354.
  * Linders (2014) Ben Linders. 2014\.  Documentation in Agile: How Much and When to Write It?  https://www.infoq.com/news/2014/01/documentation-agile-how-much/.
  * Madampe et al. (2021) Kashumi Madampe, Rashina Hoda, and John Grundy. 2021.  A Faceted Taxonomy of Requirements Changes in Agile Contexts.  _IEEE Transactions on Software Engineering_ (2021).
  * Masood et al. (2020) Zainab Masood, Rashina Hoda, and Kelly Blincoe. 2020\.  Real world scrum a grounded theory of variations in practice.  _IEEE Transactions on Software Engineering_ (2020).
  * Microsoft (2021) Microsoft. 2021\.  Q# and the Quantum Development Kit.  https://azure.microsoft.com/en-us/resources/development-kit/quantum-computing/#overview.
  * Mikkonen (2016) Tommi Mikkonen. 2016\.  Flow, intrinsic motivation, and developer experience in software engineering.  _Agile Processes in Software Engineering and Extreme Programming_ (2016), 104.
  * Moguel et al. (2020) Enrique Moguel, Javier Berrocal, José García-Alonso, and Juan Manuel Murillo. 2020.  A Roadmap for Quantum Software Engineering: Applying the Lessons Learned from the Classics.. In _Q-SET@ QCE_. 5–13.
  * Nikitin (2021) Artem Nikitin. 2021\.  Standards for quantum technology.  https://delft-circuits.com/standards-for-quantum-technology/.
  * Nuclino (2016) Nuclino. 2016.  Agile Development Methodology and Documentation To document or not to document?  https://www.nuclino.com/articles/agile-documentation.
  * Peterssen (2020) Guido Peterssen. 2020\.  Quantum Technology Impact: The Necessary Workforce for Developing Quantum Software.. In _QANSWER_. 6–22.
  * 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.
  * Rieffel and Polak (2011) Eleanor G Rieffel and Wolfgang H Polak. 2011.  _Quantum computing: A gentle introduction_.  MIT Press.
  * Robinson (2014) Oliver C Robinson. 2014\.  Sampling in interview-based qualitative research: A theoretical and practical guide.  _Qualitative research in psychology_ 11, 1 (2014), 25–41.
  * Saurabh and Rustagi (2022) Kumar Saurabh and Varsha Rustagi. 2022.  Ethical and Sustainable Quantum Computing: Conceptual Model and Implications.  _Journal of Contemporary Issues in Business and Government Vol_ 28, 01 (2022).
  * Wang et al. (2022a) Xinyi Wang, Paolo Arcaini, Tao Yue, and Shaukat Ali. 2022a.  Generating failing test suites for quantum programs with search (hot off the press track at GECCO 2022). In _Proceedings of the Genetic and Evolutionary Computation Conference Companion_. 47–48.
  * Wang et al. (2022b) Xinyi Wang, Tongxuan Yu, Paolo Arcaini, Tao Yue, and Shaukat Ali. 2022b.  Mutation-based test generation for quantum programs with multi-objective search. In _Proceedings of the Genetic and Evolutionary Computation Conference_. 1345–1353.
  * Weder et al. (2021) Benjamin Weder, Johanna Barzen, Frank Leymann, and Daniel Vietz. 2021.  Quantum software development lifecycle.  _arXiv preprint arXiv:2106.09323_ (2021).
  * Zhao (2020) Jianjun Zhao. 2020\.  Quantum software engineering: Landscapes and horizons.  _arXiv preprint arXiv:2007.07047_ (2020).
  * Zhou et al. (2016) Xin Zhou, Yuqin Jin, He Zhang, Shanshan Li, and Xin Huang. 2016.  A map of threats to validity of systematic literature reviews in software engineering. In _2016 23rd Asia-Pacific Software Engineering Conference (APSEC)_. IEEE, 153–160.