PreprintPDF Available

Quantum Computing Platforms: Assessing Impact on Quality Attributes and SDLC Activities (Accepted in ICSA 2021)

Authors:
Preprints and early-stage research may not have been peer reviewed yet.

Abstract and Figures

Practical quantum computing is rapidly becoming a reality. To harness the true potential of quantum computers in software applications, one needs to have an in-depth understanding of all such characteristics of quantum computing platforms (QCPs) that are relevant from the Software Engineering (SE) perspective. Restrictions on copying, deletion, transmission of qubit states, a hard dependency on quantum algorithms, the lower level of programming abstractions are few, out of many, examples of QCP characteristics which have significant implications for building quantum software. Thus, developing quantum software requires a paradigm shift in thinking by software engineers. This paper presents the key findings, that are relevant from the SE perspective, resulting from an in-depth examination of state-of-the-art QCPs available today. Main contributions that we present include: i) Proposing a general architecture of the QCPs, ii) Proposing a programming model for developing quantum software, iii) Determining architecturally significant characteristics of QCPs and iv) Determining the impact of these characteristics on various Quality Attributes (QAs) and Software Development Life Cycle (SDLC) activities. We show that the nature of QCPs makes it useful mainly in specialized application areas such as scientific computing. Except for performance and scalability, most of the other QAs (e.g., maintainability, testability, reliability, etc.) are adversely affected by different characteristics of a QCP.
Content may be subject to copyright.
Quantum Computing Platforms: Assessing the
Impact on Quality Attributes and SDLC Activities
Balwinder Sodhi
Department of Computer Science and Engineering
Indian Institute of Technology
Ropar, Punjab, India.
sodhi@iitrpr.ac.in
Ritu Kapur
Department of Computer Science and Engineering
Indian Institute of Technology
Ropar, Punjab, India.
dev.ritu.kapur@gmail.com
Abstract—Practical quantum computing is rapidly becoming a
reality. To harness quantum computers’ real potential in software
applications, one needs to have an in-depth understanding of all
such characteristics of quantum computing platforms (QCPs),
relevant from the Software Engineering (SE) perspective. Re-
strictions on copying, deletion, the transmission of qubit states,
a hard dependency on quantum algorithms are few, out of
many, examples of QCP characteristics that have significant
implications for building quantum software.
Thus, developing quantum software requires a paradigm shift
in thinking by software engineers. This paper presents the key
findings from the SE perspective, resulting from an in-depth
examination of state-of-the-art QCPs available today. The main
contributions that we present include i) Proposing a general
architecture of the QCPs, ii) Proposing a programming model
for developing quantum software, iii) Determining architecturally
significant characteristics of QCPs, and iv) Determining the
impact of these characteristics on various Quality Attributes
(QAs) and Software Development Life Cycle (SDLC) activities.
We show that the nature of QCPs makes them useful mainly in
specialized application areas such as scientific computing. Except
for performance and scalability, most of the other QAs (e.g.,
maintainability, testability, and reliability) are adversely affected
by different characteristics of a QCP.
Index Terms—Quantum Computing, Quantum Software Engi-
neering, Software Development Life Cycle, Computing Platforms
I. INTRODUCTION
The origin of quantum information processing can be traced
back to the early 1970’s, however, it was only in 2011 that the
first commercially viable quantum computer was reported [1].
Few recent QCP space developments include Intel’s delivery
[2] of a 17-qubit superconducting quantum chip and the
IBMs [3] 50-qubit quantum computer. Today, it is possible
for a programmer to use a real quantum computer through
cloud-based quantum programming platforms (e.g., IBM Q
Experience [4]).
From the perspective of software development, quantum
computing is one of the most recent paradigm shifts. In
this paper, we use the term Quantum Computing Platform
(QCP) to refer to the entire apparatus (hardware and software),
which is necessary to develop and deploy quantum software
applications. A typical software application that runs on a QCP
consists of some native quantum parts and some classical,
non-quantum software parts. As of today, the native quantum
parts are of a relatively small size. Considering the pace of
development happening in the domain of QCPs, it is pertinent
to investigate how the large-scale professional development of
quantum software be different (or similar) to building software
for purely classical computing platforms. Some of the critical
questions in this context could be:
1) What are the essential characteristics of QCPs, which
are efficacious for software development?
2) In what way does a QCP affect the quality attributes
(and non-functional requirements) of quantum software
applications?
3) Which Software Development Life Cycle (SDLC) activ-
ities are affected, and how, by characteristics of a QCP?
In this paper, we address these questions via an in-depth
examination of the QCPs available today.
Fig. 1: Relationship between QAs and computing platform
characteristics.
A. Method of research
Our work’s central tenet is that a computing platform’s
characteristics affect design and software development for that
platform. In the past, the authors [5], [6] have established
from the experimental findings that a computing platform’s
characteristics affect the QAs of a software application. Such
a relationship between QAs and platform characteristics is
expected because QAs are realized [7, Part-II] using design
tactics, and the tactics leverage [8]–[10] characteristics of
the computing platform, illustrated in Fig. 1. Because the
items such as QAs and tactics always occur in the context
of software development, the above results imply that the
SDLC activities are also affected by a computing platform’s
characteristics.
To understand the above point, consider this example: build-
ing the performance QA into an application often demands to
exploit parallelism present in a task. However, if the target
computing platform does not offer multiprocessing (e.g., if it
has only one single-core CPU), the application will not truly
realize the QA of performance.
Our approach for the present work, which seeks to find
answers to questions highlighted in the preceding section, is
based on the above findings. The central idea underlying our
approach can be stated as follows:
1) Identify a set, Θ, of crucial characteristics of QCPs by
an in-depth examination of the available literature and
software artifacts on various QCPs.
2) Validate each θΘvia prototyping or reference data
as necessary.
3) Identify the cause-and-effect relationships that each θ
Θhas with the QAs [8] and SDLC activities [11]. This
step is performed by examining the definition for each
QA [7, Part-II] and SDLC activities [12].
These steps were carried out by independent professional
software engineering experts who had experience in building
complex software. The Delphi method [13] was used to
arrive at the consensus about mixed results. This approach’s
application is demonstrated in Section IV, where we deter-
mine QCP characteristics’ impact on various QAs and SDLC
activities. However, we do not develop any quantum software
applications while conducting our research. The study is purely
an experience report based on “experimental programming” by
professional software engineering experts.
The paper’s structure broadly reflects how we carried out
this work: We start by describing in Section II the quantum
computing basics relevant from the perspective of developing
quantum software. By in-depth examination of different QCPs
available from various providers, we bring out in Section
II-C the general architecture of a QCP. In Section II-D, we
present the techniques exploited by currently known quantum
algorithms and propose a programming model for quantum
software development. In Section II-E, we present the details
of experiments performed with various quantum computing
toolkits to determine the pros and cons in working at various
QCPs. In Section III, we determine the prominent QCP char-
acteristics, and identify the QAs and SDLC activities affected
by them. In Section IV-A, we present the characteristics of
QCPs and how they impact various QAs. Finally, we discuss
the effect of these characteristics on SDLC activities in Section
IV-B.
II. QUANTUM COMPUTING PLATFORMS
Determining software architectural aspects of quantum soft-
ware development requires deeper comprehension of essential
differences between the classical and the quantum computers.
Though a detailed treatment of the theoretical underpinning
of the quantum phenomenon and computing is available in
standard quantum computing texts such as [14], we present
quantum computing concepts necessary for our discussion.
The description of these concepts is necessary to set a ground
for the identification of the necessary quantum computing
characteristics and study their impact on various SDLC ac-
tivities and QAs.
A. What makes quantum computing different?
A classical computer stores and processes information in the
form of binary bits using 1 and 0. A bit is realized at a physical
level using suitable properties (e.g., voltage or current) of
some physical device. An nbit memory cell in a classical
computer can potentially represent 2ndifferent symbols, but at
any moment, it can represent only one of these 2npossibilities.
Information on a quantum computer is represented or stored
using quantum bits (or qubits). These qubits are physically
realized via suitable physical phenomena that obey the laws
of quantum mechanics. Examples of such phenomena can
be “The spin of a single electron or an individual ion’s
configuration.” A qubit can be observed in one of the two
basis states, labeled as |1ior a |0i. Generally, the qubit state
|1icorresponds to classical bit 1, and |0ito classical bit 0. One
of the remarkable properties of qubits, which allows quantum
computers to compute much faster than classical computers,
is the number of possible states in which a qubit can exist
(different from its observable state, which can be only one of
the basis states). At any instant, one qubit can be in a |1i,
a|0istate, or any quantum superposition [14] of the two.
In other words, the basis states |1iand |0i, and their linear
combinations x|1i+y|0idescribe all the possible states of a
single qubit that can exist at any given time. In contrast, one
classical bit at one time can be only in one of the two possible
states: a 0 or 1.
The relevance of this property for computing:
A quantum computer can represent a much larger
state space with the same number of qubits as the
classical computer’s bits, which is because a qubit
ψ=x|1i+y|0ican be thought of as a vector in
a complex plane. The “phase difference” between |1i
and |0ibasis states of the qubit represents a significant
quantity. Certain types of probabilistic algorithms can
exploit this property to perform faster computations.
Another quantum property that is exploited by quantum
computing is the entanglement of qubits. Two or more indi-
vidually independent quantum objects are said to be entangled
when a) their behavior is random individually, but at the same
time, b) it is strongly correlated despite each object being
independent of the other. A multi-qubit state that cannot be
expressed as a list of the individual constituent qubits is en-
tangled. Consider the Bell State [15] q1q2:= (|00i+|11i)/2.
It is an example of an entangled two-qubit state. There is no
way of expressing it as a list of one-qubit states. Suppose
we measure (at some axis) one of the qubits, say q1, that
comprise this entangled state. It will behave randomly: in this
case, q1can be |0ior |1iwith equal probability. Suppose we
measured q1to be |0i, then the value of q2will certainly be |0i.
That is, we can predict exactly how the other qubit, q2, would
behave if measured along the same axis. No unentangled state
exhibits this type of perfect correlation with perfect individual
randomness.
The relevance of this property for computing: A set
of independent random variables or phenomena can be
modeled using a set of qubits. If some of these qubits
are chosen to be entangled, it is possible to develop
algorithms that need to operate only on a subset of
these entangled qubits, thus making the computation
faster. There could be many other scenarios in which
the property of entanglement can be useful.
The above two properties – quantum superposition and
quantum entanglement – are useful resources in quantum
computing. The following no-go theorems put additional con-
straints on how computation may be carried on a QCP:
The no-cloning theorem [16] states that it is impossible to
create an identical copy (or clone) a quantum state, which is
because it is impossible to find the actual qubit state at any
point in time. Therefore, it is not possible to clone an unknown
quantum state.
The no-communication theorem [17] states that during
measurement of an entangled quantum state, it is not possible
to make a measurement of a subsystem of the total state, and
to communicate the same. The theorem disallows all kinds of
communication through shared quantum states.
The no-teleportation theorem [18] states that an arbitrary
quantum state cannot be converted into a sequence of classical
bits. It also states the reverse to be false.
The no-deleting theorem [19] states that, given two copies
of an arbitrary quantum state, it is impossible to delete one
of them.
B. Related Work
Authors in [20] present a study of 24 Open Source Quantum
computing tools covering various details of quantum toolchain
and different quantum computing paradigms. The authors
study the characteristics such as the documentation, licence,
the choice of programming language, compliance with norms
of software engineering used in these tools. Authors report
that it is a challenge to select a suitable paradigm and the
corresponding quantum algorithm to solve a specific problem,
which supports one of our claims too. The study provides a
good insight of the features present in various toolkits. Based
on their study the authors conclude that it is hard for the
newcomers to become handy with the quantum computing
toolkits, and is difficult for experienced quantum developers
to switch-to the open-source toolkits.
Authors in [21] provide a comparison of four cloud-based
Quantum computing platforms: Rigetti’s Forest (pyQuil),
IBM’s Qiskit, ProjectQ, and Microsoft’s Quantum Developer
Fig. 2: Architecture of quantum computing platform.
Kit (Q#). We also experimented with three of these toolkits
with the objective of gaining an experience of their inherent
features and the support offered for a developer. The authors
provide the details related to various aspects of these toolkits,
such as their requirements and installation, language syntax,
library support, and quantum simulator capabilities. The intent
of the authors lies in providing a feature comparison of
various quantum toolkits, a quick installation guide, and some
examples to guide a beginner for a quick start with the toolkits.
Authors in [22] introduce |Lib>or LibKet project (designed
as a C++ header file), which provides a cross-platform pro-
gramming framework for the rapid prototyping of quantum
algorithms and their efficient testing on different quantum
computer simulators and hardware platforms. LibKet allows a
developer to implement quantum algorithms as generic quan-
tum expressions that can be executed on different quantum
computer simulators and hardware plaforms, thus providing
an abstract form of working with the quantum toolkits based
on low-level gates. The framework is available as an open
source tool and can be downloaded for free from the GitLab
repository1.
Authors in [23] provide a survey of the various quantum
software engineering techniques. The authors categorize the
existing literature as per the quantum techniques present fro
various SDLC activities. The review provides the details of a
variety of quantum software engineering definitions, quantum
concepts, and how quantum computing differs from classical
1https://gitlab.com/mmoelle1/LibKet
computing. The authors point out the negligence towards
quantum software reuse as a critical issue.
Clearly, there exist many useful sources of gaining an in-
sight on quantum computing basics and quantum toolkits. But,
to the best of our knowledge, there does not exist any work
that studies the impact of quantum computing characteristics
on SDLC activities and QAs.
C. General architecture
Today’s physical quantum computing machinery (reminis-
cent of early classical computers of the 1940s) is signifi-
cant [24]. It requires a particular physical environment and
conditions for operating correctly. We examined the QCPs
available today from various providers (e.g., [1], [4], [25],
[26]). Considering the salient characteristics of such QCPs, we
propose the general architecture of a QCP, as depicted in Fig.
2. It comprises of five layers, three of which contain purely
quantum hardware and circuitry and two consists of classical
hardware and software:
1) Quantum layers [24], [25], [27] One can think of
these layers as comprising the Quantum Processing Unit
(QPU).
a) Physical building blocks – Includes quantum hard-
ware that typically uses superconducting loops for
physical realization of qubits. It also contains the
physical qubit coupler or the interconnect-circuitry,
among other elements needed for qubit addressing
and control operations.
b) Quantum logic gates – Physical circuitry [27, §5.5]
that makes up quantum logic gates [14].
c) Quantum-classical interface – Includes the hard-
ware and software that provides interfacing be-
tween classical computers and a QPU.
2) Classical layers [4], [26], [28], [29]
a) Quantum programming environment – It provides
items such as i) quantum assembly language nec-
essary for instructing a QPU, ii) the programming
abstractions needed for writing quantum programs
in a high-level programming language, and iii)
simulator support and IDEs.
b) Software applications – Quantum software applica-
tions are written to cater for business and scientific
requirements.
D. Development of quantum software
In the preceding section, we introduced the two fundamental
properties – quantum superposition and quantum entanglement
– which make a quantum computer much faster than classical
computers at solving specific problems. The nature of these
two properties inherently makes the quantum computation to
be mostly probabilistic. Thus, implying that quantum programs
are likely to be probabilistic or randomized. Expressing the
logic or algorithm that is to be executed on a quantum com-
puter requires special techniques and programming models.
TABLE I: Techniques used by quantum algorithms
Techniques Examples of the target problems
Amplitude
amplification [31]
Searching in a collection or database-
of items (Grover’s algorithm [32]).
Quantum Fourier
transform [33]
Discrete logarithm problem and the integer-
factorization problem in polynomial time (Shor’s-
algorithm), and so on. Predominant applications
are in the field of cryptography.
Phase kick-
back [30]
Estimating Gauss sums [34]. Application areas-
include: simulations of complex physical-
processes, fluid dynamics, etc.
Quantum phase
estimation [30]
Estimates the phase that a unitary transformation
adds to one of its eigen-vectors.
Application areas include: simulations of-
complex physical processes, fluid dynamics, etc.
Quantum
walks [35], [36]
Element distinctness problem, Triangle finding-
problem, Formula evaluation, Group commutativity.
Application areas include: flow analysis,
networks, natural language processing, etc.
1) Quantum algorithms – The key to harnessing power
of QCPs: The usefulness of quantum programs lies in their
ability to exploit the fundamental characteristics (superposition
and entanglement of qubits) of a quantum computer. Over
the past few decades, quantum computing researchers have
developed a handful of techniques [30] that exploit quantum
computers’ characteristics for quickly solving specific prob-
lems that take much longer to solve on a classical computer.
Some of these techniques and example algorithms that exploit
them are shown in Table I. Several algorithms are available
today which exploit these techniques to solve various com-
puting problems much faster than a classical computer. To
derive benefit from a quantum computer’s capabilities, one
must map the problem at hand to one of the problems for
which a quantum algorithm is known.
Quantum circuits [37] is one of the standard models for
representing quantum computation. Like digital logic gates
employed by classical computers, quantum gates are used to
compose a quantum circuit. In this model, a quantum algo-
rithm’s steps can be expressed as a sequence of quantum logic
gates. Each quantum logic gate transforms the input qubits
in a well-defined manner, typically expressed as operations
on matrices and vectors. IBM Q-Experience Composer [4]
takes this approach to expressing quantum computations. Fig.
3 shows the screenshot of a quantum circuit for implementing
Grover’s algorithm [32] on IBM Q-Experience [4]. The square
boxes on horizontal lines represent the quantum gates used in
this circuit. Each of the horizontal lines (except the one at the
bottom) represents a qubit’s lifeline. Different quantum gates
can be applied to a qubit along its lifeline from left to right. A
measurement operation is typically the last item on the lifeline
of a qubit.
2) Programming model in quantum paradigm: We evalu-
ated the programming abstractions, the high-level program-
ming language libraries that expose these abstractions, and
Fig. 3: An example quantum circuit developed using IBM’s quantum computing simulator.
Fig. 4: A quantum programming model.
the typical steps involved in composing quantum programs
on different QCPs such as [4], [28], [29], [38]. We observe
that a quantum program typically comprises parts that execute
on a classical CPU and some on a Quantum Processing Unit
(QPU). Creating such quantum programs mainly involved the
following tasks:
1) Mapping input/output (I/O) from classical bits represen-
tation to qubits.
2) Initializing the qubits state.
3) Compose the quantum circuit using suitable quantum
logic gates to express a quantum algorithm’s steps. The
steps are repeated a suitable number of times to get a
reliable measurement of the outcomes.
4) Measure the output qubits state (measuring a qubit
forces it to collapse into a classical bit) and transfer
it to the classical bits.
A suitable high-level programming API or instructions [29],
[39], [40] is typically used to compose the quantum programs.
Based on these observations, a quantum programming model
has been derived by us, shown in Fig. 4. We also checked the
adherence to this programming model by manually examining
the sample quantum programs supplied by different QCPs.
E. Experimenting with major QCPs
To discover the characteristics of various QCPs, we experi-
mented with the three major quantum programming platforms,
viz., IBM’s Quantum Experience platform (Composer and
QASM Editor) [41], Microsoft’s Quantum Development Kit
[42], and Rigetti’s Quantum Computing Services [43]. These
QCPs are freely accessible, have user-friendly interfaces.
1) IBM’s Quantum Experience Platform: IBM’s QCP pro-
vides a user with an easy interface of quantum logic gates to
build a quantum circuit. We experimented with a subset of the
state-of-the-art quantum computing algorithms [44] using the
IBM 5-qubit QCP named ibmqx4. For example, the circuit
diagram of Grover’s algorithm implemented using ibmqx4 is
shown in Fig. 3. The programming interface for implementing
Quantum Computing algorithms works on Quantum assembler
(Qasm) language and is called the QASM editor.
IBM provides support for Quantum Computing as a cloud
service. Being a cloud service, all benefits of a cloud based
platform are available here.
2) Microsoft’s Quantum Development Kit (QDK): Mi-
crosoft’s QDK works in the Visual Studio environment2and
can be installed on a machine having Windows, macOS, or
a Linux operating system. Code samples for some prominent
Quantum algorithms are freely available on GitHub [45]. We
implemented a subset of these algorithms (screenshots, etc. of
our setup are available at https://bit.ly/3j37PlX).
Microsoft’s QDK provides good documentation and devel-
oper support resources. However, the programming interface
is via QASM, thus imposes additional learning curve for
the developers not accustomed to low level programming
languages.
3) Rigetti’s Quantum Computing Services (QCS): Rigetti’s
QCS [46] consists of the pyQuil (Python Quantum Instruc-
tion Language)3library, the Rigetti Quil Compiler (quilc), and
the Quantum Virtual Machine (qvm). The quilc compiles the
quantum programs written in quil to be run on a Quantum Ab-
stract Machine (QAM). Rigetti’s qvm is a QAM provided for
implementing various quantum algorithms on a local machine.
To run a Quantum script file, one needs to initialize the quilc
and the qvm server (hosted locally). When a quantum file is
run, the quil instructions (which are in python) are compiled
into the native quil form by the quilc. The compiled code is
then run on the qvm server instance to produce the results.
We implemented a subset of quantum computing algorithms’
snippets from [47] by using this SDK.
Rigetti’s QCS allows implementing quantum algorithms in
a well-known programming language – python.
2https://docs.microsoft.com/en-us/quantum/?view=qsharp-preview
3https://readthedocs.org/projects/pyquil/
III. DETERMINING QCP CHARACTERISTICS AND THEIR
IM PACT
We now describe our approach for determining the salient
characteristics of QCPs and how each of these characteristics
impacts various QAs and SDLC activities.
A. Determining QCP characteristics
Most of the QCPs available today provide a set of sam-
ple software programs that demonstrate the capabilities of
respective QCPs. These QCPs also provide the detailed doc-
umentation artifacts (e.g. [29], [39], [40]) that explain the
internals of these QCPs and the high-level APIs that allow
programming on those QCPs. By carefully examining them
and prototyping with these artifacts, we have identified the
key characteristics (presented in Section IV) of the QCPs. We
have cited relevant artifacts of the QCPs when presenting the
respective characteristics in the rest of this paper.
B. Major QAs
Quality attributes (QA) may be described as the factors that
have a system-wide impact on an application’s architecture,
implementation, and operation [7]. The QAs of concern for
most of applications may be categorized depending on whether
they affect design-, runtime-, system- or user- qualities of the
application [12], [48].
The overall design and quality of many software appli-
cations can be considered acceptable when the applications
possess a reasonable level of at least the following QAs [7],
[10], [49]: Performance, Reliability, Scalability, Security, and
Usability. However, we have considered a slightly expanded
list of QAs when examining how they are affected for a
software which is built for using a QCP:
1) Availability
2) Interoperability
3) Maintainability
4) Manageability
5) Performance
6) Reliability
7) Scalability
8) Security
9) Testability
10) Usability
The current body of software design and architecture knowl-
edge contains extensive detail and discussions about:
The definitions of various QAs. E.g. [7], [12], [48], [49]
are significant references.
How to realize a QA in software using various design
tactics. E.g. [7, Part-II] [10].
What characteristics of a computing platform are lever-
aged by various tactics in order to realize a QA. E.g. [5],
[6], [8], [9].
Thus, we have not covered such details here. However,
when identifying the impact of various QCP characteristics
on different QAs, we have relied mainly on that knowledge
body. In the subsequent paragraphs, we discuss only those
aspects of a QA that are relevant for identifying how the QA
is affected by various characteristics of QCPs. We take each
of the QCP characteristics identified in Section IV in turn
and discuss how it affects various QAs under consideration.
A characteristic may have a favorable, unfavorable or, neutral
impact for building a QA into an application.
C. SDLC activities
Core activities involved in software development are [12]:
Requirements, Design Engineering, Construction, Testing, De-
bugging, Deployment, and Maintenance. We considered the
following to determine which of these core activities are likely
to be affected when developing software for QCPs:
The definitions and properties of various SDLC activities,
as defined in SWEBOK [12, §2 of Ch. 8].
Mapping of various QAs to different SDLC activities.
The mapping is done based on the relevance of an SDLC
activity for the realization of a QA. Table II shows the
mapping that has been derived using the definitions and
properties of QAs [12, §5 of Ch. 2] and SDLC activities.
Once we know whether QCP characteristics impact a QA,
we can use this mapping to cross-check whether an SDLC
activity is likely to be affected.
TABLE II: Mappingof QAs to SDLC activities
Quality
Attributes
SDLC Activity
Requirements
Design
Construction
Testing
Deployment
Maintenance
Availability L H H L H L
Interoperability L H H L L L
Maintainability L H H L L H
Manageability L H H L H L
Performance L H H L H L
Reliability L H H L H L
Scalability L H H L H L
Security L H H L H L
Testability L H H H L L
Usability L H H L L L
Cell value indicates level of relevance: (H)igh, (L)ow
IV. DISCUSSION OF QCP CHARACTERISTICS AND THEIR
IM PACT
In this section, we describe the critical characteristics of
QCPs (some discussed in Section II-E) and the impact of each
characteristic on various QAs and SDLC activities. The details
about the impact on QAs have been presented in-line with the
description of a characteristic. Further, the discussion about the
impact on SDLC activities has been presented in a dedicated
section (Section IV-B). We hope such a presentation will make
it easier to understand (and convey) those details without loss
of relevant information.
A. Major QCP characteristics and their impact on QAs
1) Lower level of the programming abstractions: The pro-
gramming abstractions offered by QCPs of today [4], [28],
[29], [39] are of a low level. That is, a programmer must work
at the level of quantum logic gates (usually via a high-level
language representation of it) when expressing computational
steps that he wants to execute via a QPU.
Effect on QAs: Working at the quantum gates level to
implement a quantum algorithm is complicated. To develop
programs using such low levels of abstraction is error-prone
[11] and increases the complexity of the code. Moreover, there
are not many (as of today at least) expert quantum program-
mers, which adversely affect QAs such as maintainability,
testability, reliability, and availability [8].
2) Platform heterogeneity: The published technical details
of different QCPs [4], [25], [28], [38] that are available today
show the heterogeneous nature of the QCPs. Furthermore,
various quantum no-go theorems (please see Section II-A)
disallow copy, deletion, and qubit states’ transmission under
certain conditions. Due to restrictions such as these, the
dependency on classical hardware or software is inevitable.
Thus, the QCPs are expected to be inherently heterogeneous.
That is, both classical and quantum hardware and software are
involved.
Effect on QAs: Heterogeneity makes it challenging to
implement high software-cohesion [7], [10, Part-II]. Therefore,
QAs such as maintainability, reliability, robustness, reusability,
and understandability get adversely affected [8], [9] due to low
cohesion. The heterogeneous environment also means more
disparate elements (software and hardware) to be managed,
thus adversely affecting the manageability and testability of
the system.
3) Physical environment: Quantum hardware requires an
entirely different type of physical environment. Most of the
existing implementations [4], [24], [25], [28] of quantum
hardware circuitry use superconducting loops requiring ultra-
low temperatures. Achieving and maintaining such physical
conditions necessitates a very specialized environment for the
reliable operation of a QCP.
Effect on QAs: A highly specialized physical environment
needed by a QCP is challenging to create, maintain, and
operate. The effect of ambient noise and interference is more
pronounced in the case of QPUs than it is on CPUs. Such
properties adversely affect the QAs such as availability (e.g.,
due to “brittle” nature of physical qubits), manageability, scal-
ability (e.g., due to difficulties in quickly launching additional
QPU instances), and testability of the system [7]–[9].
4) Large form factor: Due to the requirement of a particular
physical environment, the quantum computers of today are
massive. For instance, the main box of D-Wave™2000Q
system measures roughly 10ft 10ft 10ft in size [24].
Effect on QAs: Most of the QAs, except scalability, remain
unaffected by this property of QCPs. The large form factor
makes it difficult to augment the QCP capabilities, thus
adversely affecting the scalability [8]–[10].
5) Energy Efficiency: Energy consumption can be looked
at from two main aspects: energy consumed by the QPU, the
energy requirements for cooling, and other ancillary circuitry
make up a quantum computer. It has been observed that a
quantum computer spends [50] most of its energy on cool-
ing. A QPU by itself, however, consumes much less energy
[51]. As the computation speeds grow to exascale (i.e., 1000
petaflops), the energy consumption of a QPU is not expected
to increase as fast as that of a CPU or a GPU. Experiments
conducted with D-Wave’s 2000-qubit system showed [52]
overall energy efficiency improvements of the order of 100x
compared to state-of-the-art classical computing servers when
considering pure computation time for running specialized
algorithms.
Effect on QAs: Except for improving performance and
scalability, this property does not significantly impact most
other QAs in our list.
6) Remote software development and deployment: Pro-
gramming tools such as IDEs, debuggers, and simulators.
that a software developer can use to create quantum software
are invariably cloud-based [4], [28]. Only a minimal portion
[29], [39] of the quantum programming tools stack can be
deployed and used on a programmer’s local machine. For
the development and testing of production-ready quantum
software, a programmer typically requires access to a remote
QCP environment.
Effect on QAs: The development tools and environment
used for developing software for (or on) a QCP are usually
distributed in nature. The decentralized (typically, offered via
a cloud-based IDE) and the development environment’s het-
erogeneous nature make programming, testing, and debugging
quantum programs slower and tedious [53], which adversely
affects the maintainability and the testability [8]–[10].
7) Dependency on the Known quantum algorithms: To
exploit a quantum computer’s real potential, a programmer
must express their software logic using quantum algorithms.
A computing task where one is looking to gain speed-up by
running it on a QCP is typically mapped to or broken into
another task(s) for which a quantum algorithm(s) is known.
Effect on QAs: There are very few [54] – only about
a dozen – quantum algorithms known for different types of
problems. Software engineers have to map their problems to
one of the existing few quantum algorithms, which adversely
affects the ability to perform enhancement and corrective
maintenance.
Moreoevr, the probabilistic nature of quantum computations
and their results adversely affect testability and interoperabil-
ity (with classical software). Synthesizing realistic pairs of
hinput, expected outputifor test case scenarios and repro-
ducing the defects that one wants to debug requires particular
approaches.
8) Limited portability of software: Quantum computing
platforms are themselves in their infancy, though under rapid
growth. There is a lack of standards necessary for developing
quantum programs that can be executed transparently on
different QPUs. Each of the significant providers of QCPs
offers their proprietary programming APIs and tools [4], [28],
[29], [38]–[40].
Effect on QAs: QCPs lack standardization in several areas
ranging from high-level programming APIs to low-level hard-
ware. For example, a quantum program written using Rigetti’s
quantum ISA [40] may not be executable on Open QASM [39]
supported by IBM. The portability of software is adversely
affected by QCPs. Lack of portability adversely affects [7,
Part-2] [10] availability, interoperability, maintainability, and
scalability.
9) Limited quantum networking: Though long-distance
quantum entanglement distribution is feasible [55], realizing
practical quantum communication networks is still a work
in progress [56], [57]. Moreover, various no-go theorems
(please see Section II-A) pose further restrictions on extracting
qubit states. Practical quantum software that depends on the
availability of a reliable quantum network would be hard to
achieve.
Effect on QAs: A reliable quantum network is necessary
for building reliable and high-performance quantum software,
which make the development of a non-trivial quantum soft-
ware tedious and error-prone. Quantum networks are not yet
production-ready [56], [57]. Thus, the performance, scalability,
reliability, and availability will be adversely affected.
10) Lack of native quantum operating system: The quantum
processors are still controlled via classical computing operat-
ing systems [58]. We do not yet have mature multitasking and
multiprocessing capabilities available for quantum processors.
Most existing QCPs [4], [25], [28], [29] expose the quantum
gates and qubits for direct manipulation by programmers.
Mature protocols and APIs that implement, for example,
practical timesharing of a QPU are not available yet [58].
Similarly, quantum algorithms that may exploit multiple QPUs
in parallel are yet to be explored.
Effect on QAs: A native operating system helps harness
the full potential of hardware securely and effectively, which
is lacking [58] in the case of QCPs. It prohibits, for instance,
practical timesharing of a QPU. Thus, the performance, man-
ageability, reliability, scalability, and security will be adversely
affected [7, Part-2] [10].
11) Limited multitasking and multiprocessing: These result
due to the lack of native quantum operating systems. A pro-
grammer must rely on classical computer’s OS for achieving
any type of multitasking and multiprocessing on a given set
of QPUs.
Effect on QAs: This scenario is the same as the QA effect
described in Section IV-A10.
12) Fundamentally different programming model: As dis-
cussed in Section II-D, quantum programs are inherently
probabilistic. A programmer looking to harness the power of
a QCP must identify or design suitable quantum algorithms
that can solve the problem at hand.
Effect on QAs: Quantum programs require a fundamentally
different approach to programming (please see Section II-D2
), which affects the ease of use of the underlying technology
and, in turn, the code complexity. Both of these are essential
factors that influence [11] the development and maintenance
of dependable software. Thus, a QCP adversely affects the
maintainability, interoperability, security, and testability QAs.
13) Dependency on classical storage: Though limited time
storage of entangled qubits is feasible [59], [60], long term
persistence of qubits in passive media is still impossible. Be-
TABLE III: Impactof QCP characteristics on QAs
QAs
Characteristics
Availability
Interoperability
Maintainability
Manageability
Performance
Reliability
Scalability
Security
Testability
Usability
Platform heterogeneity U – U U – U – – U
Special physical environment U U U U U U
Large form factor – – – – – U – –
Higher energy efficiency – – – – F – F – –
Lower level of the-
programming abstractions U U U – U – U
Remote software development
and deployment – – U – – – – U
Dependency on quantum
algorithms – U U – F F – U
Limited portability
of software U U U – U
Limited quantum
networking U – – – U U U – –
Lack of native quantum-
operating system U U U U U
Fundamentally different
programming model – U U – – U – U U
Dependency on
classical storage – – – U U U U – –
Cell value indicates impact on QA: (F)avorable, (U)nfavorable, “–” Unknown, Neutral
sides, it is not feasible to store arbitrary non-entangled qubits
due to different no-go theorems such as no-teleportation [18,
Page 128], no-cloning [16], and no-deleting [61] theorems.
The quantum no-go theorems disallow copy, deletion, the
transmission of qubit states under certain conditions. Thus,
the permanent persistence of critical data in quantum programs
still requires classical storage devices.
Effect on QAs: For durably persisting critical data, the
quantum programs depend on classical storage devices due
to different no-go theorems (please see Section II-A). The
quantum no-go theorems disallow copying, deletion, or trans-
mission of qubits under certain conditions. Such restrictions
on a QCP adversely affect the manageability, performance,
and scalability.
B. Effect on the SDLC activities
Core activities involved in software development are [12]:
Requirements, Design Engineering, Construction, Testing, De-
bugging, Deployment, and Maintenance. We examine how
each of these core activities is likely to be affected when
building software for QCPs.
We considered the standard definitions of various SDLC
activities as provided in SWEBOK [12] for analyzing how
those activities may be affected by the characteristics of
quantum platforms.
1) Requirements engineering: Considering the definition
of requirements engineering tasks as outlined in SWEBOK
[12], one can safely deduce that, except for the analysis and
validation, most requirements engineering tasks in themselves
are not affected [12, Ch. 1] by the nature of a target computing
platform. An essential and commonly employed tool for
requirements validation [12, §4.3 of Ch. 1] is prototyping.
Developing a prototype demands hands-on knowledge of the
target platform [62, Ch. 7] [48].
The software architectural characteristics of QCPs will
affect the analysis and allocation of requirements and the
TABLE IV: Impactof QCP characteristics on SDLC activities
SDLC Activity
Characteristics
Requirements
Design
Construction
Testing
Deployment
Maintenance
Platform heterogeneity Y Y Y Y Y Y
Special physical environment N Y Y Y Y Y
Large form factor N Y N Y N Y
Higher energy efficiency N Y N N N N
Lower level of the
programming abstractions N Y Y Y N Y
Remote software development
and deployment N Y Y Y Y Y
Dependency on quantum
algorithms N Y Y Y N Y
Limited portability
of software N Y Y N Y N
Limited quantum
networking N Y Y N N N
Lack of native quantum-
operating system N Y Y N Y N
Fundamentally different
programming model N Y Y Y N Y
Dependency on classical-
storage N Y Y Y N N
Cell values indicate whether SDLC activity is impacted: (Y)es, (N)eutral
requirements validation via prototyping. For example, lack of
ability to store or copy the exact state of qubits to classical
bits will make it impossible to realize use cases which depend
on such copying of information from the QCP. Similarly, the
simulators that are available for QCPs will pose difficulties
for reliable prototyping because those simulators can represent
QPUs having a very small number of qubits.
2) Design engineering: Software design is a critical ac-
tivity in software development, as its primary goal is to
deliver models that define the blueprint of the solution to
be implemented. Design mainly deals with two significant
aspects of the software development a) defining the structural
(de)composition of the system, and b) addressing essential
quality attributes such as scalability, performance, reliability,
security, and usability [12, Ch. 2] [62, Ch. 7].
Almost all the QCP characteristics listed in Section IV affect
the software’s design, which is to be developed for a QCP.
For instance, centralized deployment of quantum programs
would limit the design choices a software architect has when
distributing components [7], [63] of a solution. QCP charac-
teristics such as dependency on quantum algorithms, and the
limited portability of quantum programs, affect the ability to
realize [8]–[10] various QAs such as portability, testability,
and maintainability of the quantum software. Moreover, native
quantum OS services related to multitasking and multipro-
cessing on a QCP are not yet available. This further limits
the design choices for building scalability into the quantum
software.
3) Construction: This SDLC phase deals with the working
software product as per the design arrived during the preceding
phase. The effects of having adopted a QCP for implementing
parts of the software are most prominent in this phase. There
are three prominent aspects of QCPs that affect this phase
(and also few others): i) Programming model, ii) Heteroge-
neous nature of a QCP, and iii) Decentralized development
environment.
Because quantum computing takes a fundamentally differ-
ent approach to programming (i.e., expressing the logic or
algorithm), algorithms are invariably probabilistic here. A sig-
nificant implication of QCPs concerning software construction
is the lack of a rich set of quantum software libraries. As of
today, there are about twenty quantum algorithms known for
different types of problems [44]. Software engineers have to
map their problems to one of the existing quantum algorithms.
The most critical limitation of QCPs during this phase is
that they only have about a dozen quantum algorithms, and
not every problem can be mapped easily to one of these
algorithms.
Another implication of writing software for a QCP is that
for any serious programming, one requires access to at least
a reasonably powerful machine that can simulate a QCP. A
typical PC alone does not suffice. Moreover, access to a real
quantum computer may be a hard requirement when writing
programs for certain types of application scenarios. Therefore,
developing software for a QCP is expected to follow a client-
server model where the programmers use their PCs to program
remotely (perhaps via some cloud-based IDE) on a QCP.
Programming on a remote machine or an IDE is known [53]
to limit a programmer’s productivity.
4) Testing and debugging: These activities are significantly
impacted by i) ability to detect and isolate faults in the soft-
ware, ii) ease of creating test assessment criteria for the system
and its components, and iii) the ease of executing these tests
for checking if the criteria are met. A significant implication
for these activities arises from the probabilistic nature of
quantum computations and their results. Synthesizing realistic
pairs of hinput, expected outputifor test case scenarios and
reproducing the defects that one wants to debug will require
particular approaches.
Further, as highlighted in the Construction case, the de-
centralized (typically, offered via a cloud-based IDE) and
heterogeneous nature of the development environment will
make testing and debugging of quantum programs slower and
tedious [53]. It mainly happens because a QCP introduces
additional layers (please see Fig. 2) of communication.
5) Deployment: These activities are affected by factors
such as i) The ease with which system administrators can
manage the software. Typically, one relies on the instrumenta-
tion embedded in the system for allowing system monitoring,
debugging, and performance tuning. ii) Availability of mature
tooling support for the ease of making changes to a system.
Two significant aspects of QCPs from a software deployment
perspective are a) The heterogeneous nature of the overall
system (please see Fig. 2), and b) The (un)availability of full-
capability QCPs to an organization or country.
As has been already highlighted, the quantum software
applications will have a distributed deployment model com-
prising classical, and quantum software components of that
application, which is likely to remain the case until entirely
native QCPs with native I/O and operating systems become a
reality. Such heterogeneity is inevitable because i) measuring
the state of a qubit forces it to collapse to a classical bit
state, and ii) difficulties due to no-go theorems in copying
and moving data directly between qubits and other classical
devices [16], [61].
Direct access to the full-power QCPs may be difficult, if
not impossible, for many organizations due to the potential for
misuse, the complexity, and sophistication of the QCPs. Such
a scenario implies that the access to QCPs will be controlled,
and interfacing will happen over the network. Thus, requiring
a distributed deployment model for software applications.
6) Maintenance: Maintenance of software can be classified
[64] as either a Correction or an Enhancement. The former
can be of two types, viz., corrective or preventive, while
the latter can be adaptive or perfective. Regardless of the
type of maintenance, the following are a few of the essential
factors that influence [11] maintenance of software: staff
experience, code complexity, level-programming languages or
abstractions, and the ease-of-use of the underlying technology.
Considering their characteristics, the QCPs of today score
poorly on each of these factors. For instance, programming
the QCPs requires one to work at the quantum gates level
[4], [28], [29] to compose the necessary quantum circuits to
implement a quantum algorithm. Working at such low-levels
of abstraction is not easy and increases the complexity of the
code. Moreover, there are not many (as of today at least) expert
quantum programmers. Thus, maintenance (and development
in general) of software is not easy on QCPs.
C. Applications of QA impact information
One of the critical outcomes that we have presented in this
paper is the information about how the QCPs impact various
QAs and SDLC activities. This information’s significant ap-
plications can be in the evaluation of design decisions and
computing platform selection. The information presented in
Table III and Table IV can be easily used by a design decision
support tool or method, such as the one presented by [5]. Typ-
ically, such tools make use of Multi-Criteria Decision Making
techniques (e.g., MAUT [65], and TOPSIS [66]) to evaluate a
“choice” by considering the impact of the contributing factors
on that “choice.” The “choice” here could be a design decision,
a computing platform such as QCP vs. non-QCP.
D. Threats to validity
Quantum computing is a fast-evolving area of technology.
The characteristics of QCPs that we have identified are based
on the study of currently available state-of-the-art quantum
hardware and software. We expect advances in quantum com-
puting will invalidate a few of these characteristics in the
coming years. For example, production-ready native quantum
operating systems are likely to be feasible in the years to come.
Further, the list of characteristics that we have given is not
exhaustive. It is likely that additional QCP characteristics,
taken together, may be of significance in specific software
development scenarios. We would like to highlight that our
findings are derived from: a) published information about
QCPs and b) experimental programming on the QCPs accessi-
ble to us. There are likely unpublished features or information
about those QCPs that can affect quantum software applica-
tions’ software architecture. Next, we have not covered every
QA, which is relevant for a broader set of application types.
There may be QAs such as auditability, distributability, and
extensibility, which are relevant and may be affected by the
QCPs.
V. CONCLUSIONS
Programmers’ interest in applying quantum computing has
surged in the recent past. Leveraging this technology in solving
scientific or business problems requires a deeper understanding
of essential characteristics of QCPs, particularly those relevant
for software development.
We have shown that the critical characteristics of a QCP
make it entirely different from a classical computing plat-
form. For instance, availability and know-how of quantum
algorithm(s) for solving a task at hand are a hard require-
ment for developing quantum software applications. Such
characteristics of a QCP affect various QAs of the quantum
software application. The QCP characteristics such as limited
portability of quantum programs, inability to copy, move, or
delete qubits data under certain conditions, and the dependency
on quantum algorithms, adversely affect the ability to realize
various QAs such as scalability, portability, testability, and
maintainability of the quantum application software. The QAs
that are favorably impacted by QCP characteristics include
performance and scalability. The study of QCP’s impact on
QAs can be beneficial for design decision evaluation tasks.
Further, most of the SDLC activities require special handling
when building software for a QCP.
Overall, the specialized nature of QCPs appears to have
a significant implication: it limits the use of QCPs for very
specialized application areas where the performance QA is
of chief importance. However, because quantum computing
is undergoing rapid development, we expect that this tech-
nology’s evolution will likely introduce additional factors that
with high likelihood will affect the architecture of quantum
software applications.
REFERENCES
[1] H. Johnston, “Quantum-computing firm opens the box,”
http://physicsworld.com/cws/article/news/2011/may/12/
quantum-computing- firm-opens- the-box, physicsworld.com, 2011,
retrieved: Feb 2018.
[2] I. Inc., “Intel delivers 17-qubit superconducting
chip with advanced packaging to qutech,” https:
//newsroom.intel.com/news/intel-delivers-17-qubit/......
/-superconducting- chip-advanced-packaging-qutech/, Intel Inc., 2017,
retrieved: Feb 2018.
[3] W. Knight, “Ibm raises the bar with a 50-qubit quantum
computer,” https://www.technologyreview.com/s/609451/
ibm-raises- the-bar-with-a-50-qubit-quantum-computer/, technolo-
gyreview.com, 2017, retrieved: Feb 2018.
[4] IBM, “Ibm q experience,” https://quantumexperience.ng.bluemix.net/qx/
experience, IBM Inc., 2017, retrieved: Feb 2018.
[5] B. Sodhi and T. V. Prabhakar, “Assessing platform suitability for achiev-
ing quality in guest applications,” in 2012 19th Asia-Pacific Software
Engineering Conference, vol. 1, Dec 2012, pp. 760–765.
[6] ——, “Assessing suitability of cloud oriented platforms for application
development,” in Proceedings of the 2011 Ninth Working IEEE/IFIP
Conference on Software Architecture, ser. WICSA ’11. Washington,
DC, USA: IEEE Computer Society, 2011, pp. 328–335.
[7] L. Bass, Software architecture in practice, 3rd edition. Pearson, 2012.
[8] F. Bachmann, L. Bass, and M. Klein, “Illuminating the fundamental
contributors to software architecture quality,” CARNEGIE-MELLON
UNIV PITTSBURGH PA SOFTWARE ENGINEERING INST, Tech.
Rep., 2002.
[9] ——, “Deriving architectural tactics: A step toward methodical ar-
chitectural design,” CARNEGIE-MELLON UNIV PITTSBURGH PA
SOFTWARE ENGINEERING INST, Tech. Rep., 2003.
[10] L. Bass, M. Klein, and F. Bachmann, “Quality attribute design primi-
tives,” CARNEGIE-MELLON UNIV PITTSBURGH PA SOFTWARE
ENGINEERING INST, Tech. Rep., 2000.
[11] Capers Jones, “The economics of software maintenance in the twenty
first century,” http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.
88.7697&rep=rep1&type=pdf, Software Productivity Research, Inc.,
2017, retrieved: 2018-03-01.
[12] P. Bourque and e. R.E. Fairley, Guide to the Software Engineering Body
of Knowledge, Version 3.0. IEEE Computer Society, 2014.
[13] H. A. Linstone and M. Turoff, The Delphi Method: Techniques and
Applications. Addison-Wesley, 1975.
[14] M. A. Nielsen and I. Chuang, “Quantum computation and quantum
information,” 2002.
[15] P. G. Kwiat and H. Weinfurter, “Embedded bell-state analysis,Phys.
Rev. A, vol. 58, pp. R2623–R2626, 1998.
[16] W. K. Wootters and W. H. Zurek, “A single quantum cannot be cloned,
Nature, vol. 299, no. 5886, pp. 802–803, 1982.
[17] S. Popescu and D. Rohrlich, “Causality and nonlocality as axioms for
quantum mechanics,” in Causality and Locality in Modern Physics.
Springer, 1998, pp. 383–389.
[18] A. Pathak, Elements of quantum computation and quantum communica-
tion. Taylor & Francis, 2013.
[19] A. K. Pati and S. L. Braunstein, “Impossibility of deleting an unknown
quantum state,” Nature, vol. 404, no. 6774, p. 164, 2000.
[20] M. Fingerhuth, T. Babej, and P. Wittek, “Open source software in
quantum computing,” PloS one, vol. 13, no. 12, p. e0208561, 2018.
[21] R. LaRose, “Overview and comparison of gate level quantum software
platforms,” Quantum, vol. 3, p. 130, 2019.
[22] M. M¨
oller and M. Schalkers, “: A cross-platform programming frame-
work for quantum-accelerated scientific computing,” in International
Conference on Computational Science. Springer, 2020, pp. 451–464.
[23] J. Zhao, “Quantum software engineering: Landscapes and horizons,”
arXiv preprint arXiv:2007.07047, 2020.
[24] D. S. Inc., “Introduction to the D-Wave Quantum Hardware,”
https://www.dwavesys.com/tutorials/background-reading- series/
introduction-d- wave-quantum-hardware#h2- 7, 2017, retrieved: 2018-
02-19.
[25] Microsoft, “With new microsoft breakthroughs, general purpose
quantum computing moves closer to reality,” https://news.microsoft.
com/features/new-microsoft-breakthroughs-general-purpose-/......
/quantum-computing- moves-closer-reality/, 2017, retrieved: 2018-02-
19.
[26] R. Inc., “The rigetti QPU – pyQuil 1.8.0 documentation,”
http://pyquil.readthedocs.io/en/latest/qpu.html, Rigetti Inc., 2017,
retrieved: 2018-03-05.
[27] M. F. Brandl, “A Quantum von Neumann Architecture for Large-Scale
Quantum Computing,” arXiv:1702.02583 [quant-ph], 2017, arXiv:
1702.02583. [Online]. Available: http://arxiv.org/abs/1702.02583
[28] D. S. Inc., “The D-Wave 2000q Quantum Computer Technol-
ogy Overview,” https://www.dwavesys.com/sites/default/files/D-Wave%
202000Q%20Tech%20Collateral 0117F2.pdf, 2017, retrieved: 2018-02-
19.
[29] Microsoft, “Microsoft quantum development kit,” https:
//www.microsoft.com/en-us/quantum/development-kit, 2017, retrieved:
2018-02-19.
[30] R. Cleve, A. Ekert, C. Macchiavello, and M. Mosca, “Quantum algo-
rithms revisited,” in Proceedings of the Royal Society of London A:
Mathematical, Physical and Engineering Sciences, vol. 454. The Royal
Society, 1998, pp. 339–354.
[31] G. Brassard, P. Hoyer, M. Mosca, and A. Tapp, “[quant-ph/0005055]
Quantum Amplitude Amplification and Estimation,” https://arxiv.org/
abs/quant-ph/0005055, 2000, retrieved: 2018-03-05.
[32] L. K. Grover, “A fast quantum mechanical algorithm for database
search,” in Proceedings of the twenty-eighth annual ACM symposium
on Theory of computing. ACM, 1996, pp. 212–219.
[33] L. Hales and S. Hallgren, “An improved quantum fourier transform
algorithm and applications,” in Foundations of Computer Science, 2000.
Proceedings. 41st Annual Symposium on. IEEE, 2000, pp. 515–525.
[34] W. Van Dam and G. Seroussi, “Efficient quantum algorithms for
estimating gauss sums,” arXiv preprint quant-ph/0207131, 2002.
[35] S. E. Venegas-Andraca, “Quantum walks: a comprehensive review,
Quantum Information Processing, vol. 11, no. 5, pp. 1015–1106, 2012.
[36] A. Ambainis, “Quantum walks and their algorithmic applications,”
International Journal of Quantum Information, vol. 1, no. 04, pp. 507–
518, 2003.
[37] M. M ¨
ott¨
onen, J. J. Vartiainen, V. Bergholm, and M. M. Salomaa,
“Quantum circuits for general multiqubit gates,” Phys. Rev. Lett., vol. 93,
p. 130502, 2004.
[38] R. Inc., “The rigetti QVM – pyQuil 1.8.0 documentation,”
http://pyquil.readthedocs.io/en/latest/qvm.html, Rigetti Inc., 2017, re-
trieved: 2018-03-05.
[39] A. W. Cross, L. S. Bishop, J. A. Smolin, and J. M. Gambetta, “Open
quantum assembly language,” arXiv preprint arXiv:1707.03429, 2017.
[40] R. S. Smith, M. J. Curtis, and W. J. Zeng, “A practical quantum
instruction set architecture,” arXiv:1608.03355 [quant-ph], 2016.
[Online]. Available: http://arxiv.org/abs/1608.03355
[41] IBM Corporation, “IBM Quantum Experience,” Published online at
https://quantumexperience.ng.bluemix.net, 2016.
[42] Microsoft, “Get started with quantum development,” Published online
at https://www.microsoft.com/en-us/quantum/development-kit, 2017.
[43] Rigetti Computing, “Introduction to Quantum Cloud Services,” Pub-
lished online at https://www.rigetti.com/qcs/docs/intro-to-qcs, 2018.
[44] P. J. Coles, S. Eidenbenz, S. Pakin, A. Adedoyin, J. Ambrosiano,
P. Anisimov, W. Casper, G. Chennupati, C. Coffrin, H. Djidjev et al.,
“Quantum algorithm implementations for beginners,” arXiv preprint
arXiv:1804.03719, 2018.
[45] Andrez Paz, RolfHuisman, Andrew Helwer, Lee James O’Riordan,
“Microsoft Quantum Development Kit Samples,” Published at
github at https://github.com/rigetti/grove/blob/master/examples/
GroversAlgorithm.ipynb, year = 2017,.
[46] Rigetti Computing, “Rigetti Forest SDK,” Published online at https://
www.rigetti.com/forest, 2018.
[47] Smith, Robert S and Curtis, Michael J and Zeng, William J, “Rigetti
grove,” Published at github at https://github.com/rigetti/grove, year =
2017,.
[48] Microsoft Patterns and Practices Team, Microsoft Application Architec-
ture Guide, 2nd Edition. Microsoft, 2009.
[49] ISO/IEC, “ISO/IEC25010:2011(en), systems and software engineer-
ing— systems and software quality requirements and evaluation
(SQuaRE)— system and software quality models,” https://www.iso.org/
obp/ui/#iso:std:iso-iec:25010:ed- 1:v1:en, 2011, retrieved: 11-03-2018.
[50] J. Hsu, “How much power will quantum computing
need?” https://spectrum.ieee.org/tech-talk/computing/hardware/
how-much-power-will-quantum- computing-need, IEEE Spectrum:
Technology, Engineering, and Science News, 2017, retrieved: 2018-03-
02.
[51] J. Ikonen, J. Salmilehto, and M. M¨
ott¨
onen, “Energy-efficient quantum
computing,” npj Quantum Information, vol. 3, no. 1, p. 17, 2017. [On-
line]. Available: https://www.nature.com/articles/s41534-017-0015-5
[52] D. S. Inc., “Computational power consumption and speedup,
https://www.dwavesys.com/sites/default/files/14-1005A D wp
Computational Power Consumption and Speedup.pdf, D-Wave
Systems Inc., 2017, retrieved: 2018-03-02.
[53] G. Fylaktopoulos, G. Goumas, M. Skolarikis, A. Sotiropoulos,
and I. Maglogiannis, “An overview of platforms for cloud based
development,SpringerPlus, vol. 5, 2016. [Online]. Available: https:
//www.ncbi.nlm.nih.gov/pmc/articles/PMC4715041/
[54] P. W. Shor, “Progress in Quantum Algorithms,” Quantum Information
Processing, vol. 3, no. 1-5, 2004.
[55] J. e. a. Yin, “Satellite-based entanglement distribution over 1200
kilometers,” arXiv:1707.01339 [physics, physics:quant-ph], 2017.
[Online]. Available: http://arxiv.org/abs/1707.01339
[56] C. Simon, “Towards a global quantum network,Nature Photonics,
vol. 11, no. 11, pp. 678–680, 2017. [Online]. Available: https:
//www.nature.com/articles/s41566-017-0032- 0
[57] H. J. Kimble, “The quantum internet,” Nature, vol. 453, p. 1023, 2008.
[58] H. Corrigan-Gibbs, D. J. Wu, and D. Boneh, “Quantum operating
systems,” in Proceedings of the 16th Workshop on Hot Topics in
Operating Systems, ser. HotOS ’17. ACM, 2017, pp. 76–81.
[59] C. Clausen, I. Usmani, F. Bussieres, N. Sangouard, M. Afzelius,
H. de Riedmatten, and N. Gisin, “Quantum storage of photonic en-
tanglement in a crystal,” Nature, vol. 469, no. 7331, p. 508, 2011.
[60] F. Bussi`
eres, C. Clausen, A. Tiranov, B. Korzh, V. B. Verma, S. W.
Nam, F. Marsili, A. Ferrier, P. Goldner, H. Herrmann et al., “Quantum
teleportation from a telecom-wavelength photon to a solid-state quantum
memory,Nature Photonics, vol. 8, no. 10, pp. 775–778, 2014.
[61] A. K. Pati and S. L. Braunstein, “Impossibility of deleting an unknown
quantum state,” Nature, vol. 404, no. 6774, p. 164, 2000.
[62] I. Sommerville et al.,Software engineering. Addison-wesley, 2007.
[63] M. Richards, Software architecture patterns. O’Reilly Media, Incorpo-
rated, 2015.
[64] “Iso/iec/ieee international standard for software engineering - software
life cycle processes - maintenance,” ISO/IEC 14764:2006 (E) IEEE Std
14764-2006 Revision of IEEE Std 1219-1998, pp. 1–58, 2006.
[65] J. Wallenius, J. S. Dyer, P. C. Fishburn, R. E. Steuer, S. Zionts, and
K. Deb, “Multiple criteria decision making, multiattribute utility theory:
Recent accomplishments and what lies ahead,” Manage. Sci., vol. 54,
no. 7, pp. 1336–1349, Jul. 2008.
[66] B. Sodhi and P. T V, “A simplified description of fuzzy topsis,arXiv
preprint arXiv:1205.5098, 2012.
Chapter
In this chapter, QuantumPath® (QPath® https://www.quantumpath.es/), an agnostic quantum software development platform to support the design, implementation, and execution of quantum software applications is presented, with its advantages and an example of use.
Chapter
This chapter summarizes the software engineering evolution and how quantum computing fits in it, presenting the Talavera Manifesto for Quantum Software Engineering and Programming. It also discusses quantum software engineering techniques and challenges, the lack of standardization, the presence of quantum computing and QSE in current education curricula, and the need for collaboration between industry and academy.
Chapter
The characteristic difficulty in creating pure quantum software is mainly due to the inaccessibility to intermediate states, which makes debugging practically impossible. However, the use of formal methods, which apply rigorous mathematical models to ensure error-free software, can overcome this barrier and enable the production of reliable quantum algorithms and applications right out of the box.
Article
Full-text available
Quantum computers are available to use over the cloud, but the recent explosion of quantum software platforms can be overwhelming for those deciding on which to use. In this paper, we provide a current picture of the rapidly evolving quantum computing landscape by comparing four software platforms - Forest (pyQuil), Qiskit, ProjectQ, and the Quantum Developer Kit (Q#) - that enable researchers to use real and simulated quantum devices. Our analysis covers requirements and installation, language syntax through example programs, library support, and quantum simulator capabilities for each platform. For platforms that have quantum computer support, we compare hardware, quantum assembly languages, and quantum compilers. We conclude by covering features of each and briefly mentioning other quantum computing software packages.
Book
Full-text available
In the Guide to the Software Engineering Body of Knowledge (SWEBOK® Guide), the IEEE Computer Society establishes a baseline for the body of knowledge for the field of software engineering, and the work supports the Society’s responsibility to promote the advancement of both theory and practice in this field. It should be noted that the Guide does not purport to define the body of knowledge but rather to serve as a compendium and guide to the knowledge that has been developing and evolving over the past four decades. Now in Version 3.0, the Guide’s 15 knowledge areas summarize generally accepted topics and list references for detailed information. The editors for Version 3.0 of the SWEBOK® Guide are Pierre Bourque (École de technologie supérieure (ÉTS), Université du Québec) and Richard E. (Dick) Fairley (Software and Systems Engineering Associates (S2EA)).
Article
Full-text available
Open source software is becoming crucial in the design and testing of quantum algorithms. Many of the tools are backed by major commercial vendors with the goal to make it easier to develop quantum software: this mirrors how well-funded open machine learning frameworks enabled the development of complex models and their execution on equally complex hardware. We review a wide range of open source software for quantum computing, covering all stages of the quantum toolchain from quantum hardware interfaces through quantum compilers to implementations of quantum algorithms, as well as all quantum computing paradigms, including quantum annealing, and discrete and continuous-variable gate-model quantum computing. The evaluation of each project covers characteristics such as documentation, licence, the choice of programming language, compliance with norms of software engineering, and the culture of the project. We find that while the diversity of projects is mesmerizing, only a few attract external developers and even many commercially backed frameworks have shortcomings in software engineering. Based on these observations, we highlight the best practices that could foster a more active community around quantum computing software that welcomes newcomers to the field, but also ensures high-quality, well-documented code.
Article
Full-text available
The creation of a global quantum network is within reach combining satellite links and quantum memory based approaches. Applications will range from secure communication and fundamental physics experiments to a future quantum internet.
Article
Full-text available
The announcement of a quantum computer that can be accessed remotely by anyone from its laptop is a big event for the quantum computation scientist. In this work we present the International Business Machines (IBM) quantum computer and its platform IBM Quantum Experience (IBM-QE) as a didactic proposal in quantum computation and information. In addition we also consider this paper as scientific divulgation of the IMB advertisement. In this paper we show the main tool (quantum gates) present in the IBM-QE and, through a simple strategy, we discuss about a possible decoherence source in the IBM 5 q-bit chips. As an example of application of our study, we show how to implement the quantum teleportation using the IBM-QE.
Article
Full-text available
In the near future, a major challenge in quantum computing is to scale up robust qubit prototypes to practical problem sizes and to implement comprehensive error correction for computational precision. Due to inevitable quantum uncertainties in resonant control pulses, increasing the precision of quantum gates comes with the expense of increased energy consumption. Consequently, the power dissipated in the vicinity of the processor in a well-working large-scale quantum computer seems unacceptably large in typical systems requiring low operation temperatures. Here, we introduce a method for qubit driving and show that it serves to decrease the single-qubit gate error without increasing the average power dissipated per gate. Previously, single-qubit gate error induced by a bosonic drive mode has been considered to be inversely proportional to the energy of the control pulse, but we circumvent this bound by reusing and correcting itinerant control pulses. Thus our work suggests that heat dissipation does not pose a fundamental limitation, but a necessary practical challenge in future implementations of large-scale quantum computers.
Article
Full-text available
This paper provides an overview of the state of the art technologies for software development in cloud environments. The surveyed systems cover the whole spectrum of cloud-based development including integrated programming environments, code repositories, software modeling, composition and documentation tools, and application management and orchestration. In this work we evaluate the existing cloud development ecosystem based on a wide number of characteristics like applicability (e.g. programming and database technologies supported), productivity enhancement (e.g. editor capabilities, debugging tools), support for collaboration (e.g. repository functionality, version control) and post-development application hosting and we compare the surveyed systems. The conducted survey proves that software engineering in the cloud era has made its initial steps showing potential to provide concrete implementation and execution environments for cloud-based applications. However, a number of important challenges need to be addressed for this approach to be viable. These challenges are discussed in the article, while a conclusion is drawn that although several steps have been made, a compact and reliable solution does not yet exist.
Conference Paper
If large-scale quantum computers become commonplace, the operating system will have to provide novel abstractions to capture the power of this bizarre new hardware. In this paper, we consider this and other systems-level issues that quantum computers would raise, and we demonstrate that these machines would offer surprising speed-ups for a number of everyday systems tasks, such as unit testing and CPU scheduling.