1 A few words about quantum computing
Quantum computing is presented as a fundamentally different paradigm from classical computing, one that relies on quantum-mechanical phenomena and therefore resists day-to-day intuition. The chapter lowers the barrier to entry by advocating a physics-light, learn-by-doing approach: build understanding through solving problems and writing quantum programs. It targets readers who already know the basics—quantum states, gates, Dirac notation, control and adjoint operations, and measurement—along with comfort in linear algebra and some trigonometry. Brief refreshers appear where needed, while more thorough introductions can be paired from external resources. The overarching goal is to transition from abstract concepts to practical, program-oriented reasoning about quantum computation.
The discussion separates hype from reality: quantum computers will not replace classical machines, but can offer advantages on specific, hard problems. Practical quantum advantage requires that the best classical methods are too slow, the quantum solution is fast enough to matter, and the task itself is meaningful. Promising domains include simulating quantum systems and materials science, where “small-data, big-compute” structures can be exploited and speedups beyond quadratic are plausible. At the same time, the chapter stresses practicality: theoretical improvements (for example, quadratic search speedups) may be eclipsed by structured classical methods or by the high cost of quantum subroutines, so careful algorithmic and implementation-level analysis is essential to identify truly useful advantages.
The chapter then peeks inside modern quantum systems, organized around three components that coevolve: algorithms, hardware, and software. Hardware remains in the noisy intermediate-scale era, progressing toward fault tolerance via error correction and scale, with milestones moving from proofs of concept to demonstrations of advantage and ultimately to solving practical problems. The software stack mirrors classical computing, from high-level languages and libraries through compilation, optimization, and error-correction layers down to platform-specific control, with simulators playing a central role in development and testing. A developer-oriented workflow follows four steps—implement (often in hybrid quantum-classical form), test and debug (largely via simulators), estimate resources, and run on hardware—and this book focuses on the first three, using Qiskit and Q# to build hands-on proficiency amid a rapidly growing ecosystem and job market for quantum technologies.
Quantum advantage: the time a quantum computer takes to solve a problem grows at a slower rate than the time a classical computer takes as the problem size increases. The problems for which crossover time is months or more offer no practical advantage, since the problem instances that have practical value are much larger than the crossover size and take much longer to solve, and running a quantum computer for months or years to solve a single problem instance is not really practical.

The major milestones of quantum hardware development. The first two, showing the use of quantum mechanics to perform a computation and having a quantum computer solve an artificial problem that a classical computer can not, have already been achieved. The next milestone, building a fault-tolerant quantum computer that can run long computations, is the current focus. The final goal is to build a quantum computer that can solve practical problems that a classical computer can not.

Quantum software stack serves as an interface between the quantum algorithms and the hardware running them. Its components mirror those of the classical software stack.

Quantum application software development workflow. From the developer perspective it is similar to the classical software development workflow, with some differences to account for the nature of quantum computing. For example, using quantum simulators instead of the hardware makes testing the software on small problems faster and easier, since it eliminates the need to account for noise.

Summary
- Quantum computing cannot speed up arbitrary classical computing tasks; instead, it will let us solve some highly specialized problems such as quantum systems simulations that are too complicated for classical (super)computers.
- To yield practical advantage over the best classical algorithms for the same problem, quantum algorithms have to offer significant speedups, featuring at least exponentially better asymptotic complexity compared to that of the classical algorithms.
- Quantum hardware is in its "noisy intermediate-scale era", with devices too large to be simulated classically but too small and too noisy to solve practical problems.
- The software stack plays a critical role for quantum computers, enabling the execution of algorithms on hardware and accessing the quantum systems via the cloud, accelerating algorithms research and driving the requirements for hardware design.
- Governments and companies worldwide pay increasing attention to quantum computing and invest in its continued development.
- Learning quantum computing can give you a lot of opportunities to contribute to this domain and, like learning any new computing paradigm, make you a better thinker!
FAQ
What does Chapter 1 cover?
It introduces the essential context for quantum computing, focusing on:- Which problems quantum computers might solve better than classical ones
- The three main components of quantum systems: algorithms, hardware, and software
- The quantum software development workflow, from implementation to testing, resource estimation, and execution
- A hands-on, physics-free path to learning through programming
What is quantum computing and how is it different from classical computing?
Quantum computing uses quantum-mechanical phenomena to perform computation. Unlike classical computing (which feels intuitive and models computation with bits and logic gates), quantum computing relies on phenomena we don’t encounter in daily life, requiring mathematical reasoning and specialized programming models to harness superposition, interference, and entanglement.Who is this book for, and what are the prerequisites?
This book targets readers who already know the basics of quantum computing and want to deepen their understanding and start building non-trivial solutions. You should be comfortable with:- Quantum states as vectors; gates as matrices; applying gates via matrix–vector multiplication
- Dirac notation and computations in Dirac notation
- Main gates: X, Y, Z, H, Ry, S, T; controlled/adjoint variants; CNOT and CCNOT
- Single- and multi-qubit measurements and their probabilistic effects
- Linear algebra: complex numbers, inner/outer products, tensor products; basic trigonometry; eigenvalues/eigenvectors as needed
- Basic Python; the book uses Qiskit (Python) and Q#
Do I need deep knowledge of quantum physics to follow along?
No. The chapter proposes a physics-free approach centered on solving problems and writing quantum programs. You’ll rely on math (complex numbers, linear algebra, and some trigonometry) rather than advanced physics. Short refreshers are included where needed.Will quantum computers replace classical computers?
No. Even though a large quantum computer could, in principle, run any classical computation, it would typically be slower for everyday tasks. Quantum computers are expected to provide advantages only for specialized problems where classical methods are inefficient.What is practical quantum advantage, and which problems are likely to show it?
Practical advantage means a quantum solution is meaningfully faster for real-world instances. Requirements include:- Classical best-known algorithms take too long (years or more)
- Quantum methods can solve instances in useful time (hours to days)
- The task has practical value (not just a contrived benchmark)
- “Small-data big-compute” problems (e.g., factoring, quantum simulations)
- Exploitable structure (e.g., periodicity in factoring)
- Speedups better than quadratic; in practice, often exponential or greater
Why doesn’t Grover’s algorithm make general database search faster in practice?
Grover’s offers a quadratic speedup for black-box search, but:- Classical systems exploit structure (indexes, partitions) to beat brute force
- Grover’s can’t leverage that structure as efficiently
- Quantum elementary operations and function evaluations are slower and more complex, offsetting theoretical gains
What are the three main components of quantum computing systems?
- Algorithms: Discover, analyze, and refine quantum methods with an eye on practical implementability
- Hardware: Physical qubits and devices (e.g., superconducting circuits, trapped ions, photons, spins, neutral atoms), currently in the NISQ era
- Software: A stack connecting algorithms to hardware (languages, compilers, optimizers, error correction, cloud access, simulators)
What is the current state of quantum hardware and the key milestones ahead?
We are in the NISQ era: devices too noisy and small for practical tasks, yet beyond easy classical simulation. Milestones:- Proof-of-concept quantum computations (achieved)
- Demonstrations of problems infeasible classically but not necessarily useful (contenders exist)
- Fault tolerance via quantum error correction and scale-up (current focus)
- Solving practically significant problems beyond classical reach (ultimate goal)
How does the quantum software stack and workflow look from a developer’s perspective?
Software stack highlights:- Application software (implements algorithms)
- Programming tools (languages like Qiskit and Q#, libraries, IDEs)
- Middle layer (compilation, optimization, decomposition to primitives, error correction, cloud access)
- Control software (hardware-specific pulse/laser control)
- Simulators at various layers for development and validation
- Implement the algorithm (often hybrid quantum–classical)
- Test and debug (use simulators to “peek” at state and avoid hardware noise)
- Estimate resources and performance (qubits, gates, runtime)
- Run on hardware (currently for validation; importance grows with maturity)