The Quantum Codex: Where Physics, AI, and Software Converge

Abstract

How Quantum Computing, AI, and New Physical Substrates May Change the Future of Software Engineering examines how the convergence of these technologies will reshape software development, moving beyond silicon transistors toward physical systems that directly harness natural laws.

• The Reality of Quantum Hardware: Highlights the actual engineering, like QPUs and dilution refrigerators needed for quantum coherence, over abstract mathematical models.
• Foundational Quantum Phenomena: Utilizes physical phenomena (superposition, entanglement, interference, tunneling) as computational resources to model nature directly, avoiding complex classical approximations.
• Computation Beyond Silicon: Views computation as designing problem-solving systems using alternative substrates like Photonics or DNA computing, showing silicon is just one implementation method.
• The Shift in Software Development: Requires transitioning from deterministic to probabilistic logic. Stacks like Qiskit abstract hardware complexity, while AI orchestrates workflows across classical CPUs/GPUs and quantum QPUs.
• Scientific and Industrial Impact: May excels at modeling biological and chemical systems (protein-ligand interactions, photosynthesis, nitrogen fixation) and discovering advanced materials like room-temperature superconductors or improving battery chemistries.
• A Hybrid Future: Anticipates a hybrid model where quantum computers act as specialized accelerators. Engineers will design higher abstraction layers, utilizing AI to manage complexity and identify quantum-advantage problems.

Ultimately, quantum computing serves as a new scientific instrument. Despite noisy hardware and costly logical qubits, developing abstraction layers signals a new engineering era focused on manipulating the natural world.

1. Meeting a Quantum Computer

1.1 From the Cloud to the Cryostat

While visiting VivaTech 2026, I finally had the opportunity to meet an IBM Quantum Computer similar to the one I had been studying and programming remotely through IBM Quantum Platform using Qiskit. It felt strangely familiar.

For almost a year, I had been writing code, submitting quantum circuits to the cloud, reading research papers, and learning how these extraordinary machines work. Yet until that day, I had never actually stood next to one.

Ironically, the most impressive part of the picture I brought home isn't the computer. It's the giant golden chandelier behind me. Or rather... what I originally assumed was the computer. It wasn't.

That elegant structure is a dilution refrigerator, one of the most sophisticated refrigeration systems ever engineered. Its only purpose is to cool a tiny quantum processor to temperatures of only a few millikelvin above absolute zero (i.e. colder than outer space) where quantum coherence (i.e. the limited time during which a qubit preserves the phase relationships required for computation) can survive long enough to perform useful computations [1.1] [1.2].

The actual computer is almost hidden. Deep inside that refrigerator, protected from vibration, heat, electromagnetic interference, and almost every interaction with the outside world. It's a coin-sized processor, the Quantum Processing Unit (QPU), hosted inside a cryogenic assembly; which can be seen in the chandelier picture as a gray box at the bottom.

That contrast fascinated me. The largest and most visible part of the machine exists only to protect one of its smallest components.

As an Electronic Engineer, I instinctively started focusing on the processor.

Unlike traditional CPUs packed with billions of CMOS transistors switching billions of times per second, IBM's superconducting quantum processors are built from microwave resonators, superconducting circuits, capacitors, cryogenic control systems, and an extraordinary amount of engineering whose sole objective is to preserve one of nature's most fragile resources: quantum information.

One of the core aspects built inside are the Josephson junctions, which provide the nonlinearity required to isolate two energy levels that behave as a qubit [1.1] [1.2]. This gives the circuit the nonlinear behavior needed to create distinguishable quantum energy levels, allowing the two lowest levels to behave as the |0⟩ and |1⟩ states of a qubit.

For years, qubits had been abstract concepts from books, university lectures, scientific papers, and even from the IBM Quantum Platform.

But standing next to the machine, I could finally connect those abstract ideas with the physical hardware that makes them possible. It reminded me why I fell in love with engineering in the first place.

Engineering is the art of transforming the invisible into something tangible.

Electricity becomes light. Mathematics becomes software. And now... the strange rules of quantum mechanics become computers.

1.2 The Strange Behaviour We First Observed in Nature

Before trying to understand how a quantum computer works, it helps to remember that engineers did not invent quantum behaviour. We discovered it in nature. And much of what we discovered appeared to contradict common sense.

As Richard Feynman famously remarked in his book “The Character of Physical Law” (1965):

“I think I can safely say that nobody understands quantum mechanics”

Let's consider entanglement as an example.

1.2.1 Quantum Entanglement: Correlated Quantum States of Particles Beyond Classical Explanation

In a typical experiment, a laser is directed through a special nonlinear crystal. Under the right conditions, a pump photon can undergo spontaneous parametric down-conversion producing two lower-energy photons whose quantum properties are linked (i.e. they were entangled) [1.7]. They can then travel in different directions and be measured far apart. Each individual measurement may appear random. Yet when researchers compare the results, they find correlations that cannot be explained by imagining that each photon carried a conventional, pre-agreed answer from the beginning. The correlation depends on how both photons are measured, and experiments testing Bell's inequalities have repeatedly matched quantum-mechanical predictions [1.5] [1.6].

In simple terms, the crystal can produce two photons in a shared quantum state called entanglement. Before measurement, we cannot describe each photon independently as already being either |0> or |1>. When both are measured in the same way, their results are strongly correlated: depending on how the pair was prepared, they may always match, both |0> or both |1>, or always be the opposite.

This correlation remains even when the photons are far apart. It can feel as though an invisible link connects them, but no message is being transmitted between them. The better way to think about it is that the two photons form one shared quantum system, even after they have separated. Distance does not appear to weaken this shared quantum description. This does not allow us to send information faster than light. But it tells us that the two particles cannot always be described as fully independent objects, even after they have separated. Similar to a Rubik’s Cube where any move of a single square requires the whole vertical column or horizontal row of squares to be moved together as an “entangled” array of squares.

Einstein famously disliked this implication and referred to it as “spooky action at a distance.” Today, we call it quantum entanglement.

1.2.2 Superposition and Wave-Particle Duality in Quantum Mechanics

Another strange phenomenon appears in the famous double-slit experiment. Imagine firing photons toward a barrier containing two narrow openings. If photons behaved only like tiny classical particles, we might expect them to pass through one opening or the other and form two bright bands on the screen behind the barrier. Instead, an interference pattern gradually appears: alternating bright and dark bands, similar to the pattern produced when water waves overlap when throwing two stones a couple meters apart [1.8].

More remarkably, the pattern still emerges when photons are released one at a time. Each photon is detected at a single location, like a particle. But the distribution created after many photons behaves as if each photon had explored multiple possible paths like a wave. If we measure which slit the photon passes through, the interference disappears.

The experiment does not mean that a photon is secretly a small ball that physically splits into two pieces. It means that, before measurement, its quantum state can contain a combination of possible paths. That is the intuition behind superposition.

A classical bit must be either zero or one. Similarly, a qubit, when measured, also can only be found in either a |0> or |1>. But before that, it can be prepared in a quantum combination of both possibilities, with probability amplitudes that can reinforce or cancel one another through interference.

Oxford physicist Andrew Briggs, uses a helpful variation of the spinning-coin analogy to illustrate the distinction between uncertainty and measurement: Imagine I toss a coin in front of a class, when spinning in the air it shows both faces simultaneously, so it can potentially be in a “superposition” of both face and tail at the same time. But when I catch it, its fate is already decided. If I slightly open my hand and sneak peek at it, I am “measuring” it, which gives me 100% certainty of the result. But for the rest of the class, a 50%-50% probability still remains, similarly to when it was spinning.

Of course the analogy stops there, as quantum states are much more than just the uncertainty of 1 and 0. Intermediate Quantum states contain phases, amplitudes and signs, which can also be manipulated and operated with. Especially when you have more than just 1 qubit, all those operations start to show the enormous parallelism and combination powers using interference as a mechanism. So, I came up with a corollary, extending the original analogy a bit further « every physicist reading this is now wincing, and they are right to ».

Now imagine I toss 10 coins at the same time, and when spinning, I start a fan that spills drops of liquid iron gluing to some of the coins while also causing others to collide “interfering” on their spins. While still in the air hitting, I turn-on a special magnet, hidden behind the floor, that “increases the probability” of the iron spilled faces to get attracted toward the ground. When the coins hit the floor, their faces or tails are automatically “measured” and uncovered. It is important to highlight that such “operations” are done, not one by one, but simultaneously over the affected coins while in the air during a very short “coherence” time.

1.2.3 Thinking About a Qubit

At this point, a natural question arises: If a classical bit is either 0 or 1, what exactly is a qubit?

A spinning coin analogy is still a completely classical object. At every instant it has a well-defined orientation, even if we don’t know what it is. The uncertainty exists only in our knowledge of the outcome.

A qubit is fundamentally different. Before measurement, it is not simply an unknown 0 or an unknown 1. One way I like to think about it is through white light.

To our eyes, white light appears to be a single, uniform color. Yet when it passes through a prism, we discover that it is actually composed of many different wavelengths that were always present, even though we couldn’t distinguish them beforehand.

A quantum state is similar in spirit, but even more remarkable. Before measurement, a qubit is described by a combination of probability amplitudes for its possible outcomes. These amplitudes can reinforce or cancel one another through interference, much like the waves we encountered in the double-slit experiment.

When we finally measure the qubit, we do not observe that rich quantum description. We obtain a single classical result: 0 or 1.

This transition from a quantum state to a definite classical outcome is commonly referred to as the collapse of the quantum state.

Unlike the spinning coin, the uncertainty is not simply due to our lack of knowledge. It is part of the mathematical description of nature itself.

A useful way to visualize the state of a single qubit is with something called the Bloch sphere. Think of it as a globe: the north pole represents |0⟩, the south pole represents |1⟩, and every other point on the surface represents a different possible quantum state, combining different amplitudes and relative phases. Going back to the coin analogy, you can imagine the coin tracing this virtual globe while spinning, rather than being limited to only heads or tails. The Bloch sphere is only a visualization tool, though, it is not required to understand or mathematically describe a qubit; alternative approaches work directly with the mathematical representation of quantum states [1.10] [1.11].

The goal of a quantum algorithm is therefore not to keep all possibilities forever, but to carefully shape these probability amplitudes through interference so that, when we finally measure the qubits, the most useful answer is the one most likely to emerge.

1.2.4 Quantum Tunnelling: How Particles Pass Through Barriers in Quantum Mechanics

Another strange but real phenomenon in nature is quantum tunnelling. It is present in radioactive decay, nuclear fusion in stars, and various chemical reactions. It is also widely explored in technology for the operation of tunnel diodes and scanning tunneling microscopes [1.9].

To help understand quantum tunneling, imagine rolling a ball upwards toward a hill. In classical physics, if the ball lacks enough energy to reach the top, it rolls back. In a quantum world, however, the particle doesn't act like a solid ball. Instead, it behaves like a wave that can extend into and through the hill. Because of this wave-like nature, there is a small probability that the particle will simply "tunnel" through the barrier and appear on the other side of the hill, even though it classically lacked the energy to overcome it. It has not drilled a tunnel through the barrier or borrowed energy to jump over it. Its quantum state simply does not obey the same sharply defined boundaries we expect from everyday objects.

1.2.5 How the Laws of Nature at the Microscale Differ from Our Everyday Experience

Entanglement. Superposition. Interference. Tunnelling. These phenomena sound strange because human intuition evolved around objects that are large, warm and continuously interacting with their environments.

At the microscopic scale, however, entanglement, superposition, interference and tunnelling are not exceptions. They are part of the normal behaviour of nature.

The difficulty appears when many quantum particles interact.

To represent a general state of one qubit, we track two probability amplitudes. For 2 qubits, 4. For 3 qubits, 8. For n qubits, as many as 2ⁿ. At only 50 qubits, the general state already involves more than one quadrillion amplitudes [1.4].

Real molecules contain many interacting electrons and nuclei, making their exact quantum description extraordinarily demanding for classical computers [1.4].

Classical methods remain enormously useful and can model large systems by using approximations, fragmentation, statistical methods and carefully selected active regions. But the most strongly correlated quantum interactions can make computational requirements grow beyond practical reach.

This led Richard Feynman to a deceptively simple idea: If nature is quantum mechanical, perhaps the most natural way to model it is with another controllable quantum system [1.3].

Instead of forcing a classical computer to keep an exponentially growing description of every quantum possibility, build a machine whose physical state already follows quantum rules. That idea became one of the intellectual foundations of quantum computing.

Quantum computers therefore do not merely calculate superposition, interference, entanglement and tunnelling. They engineer controllable physical systems that use those phenomena as computational resources.

Therefore, they are not merely faster versions of classical computers. They are machines built from a different model of reality.

1.3 A Computer That Doesn't Fight Nature

These quantum phenomena are not equally important, nor do they play the same role.

• Superposition gives quantum systems an exponentially rich mathematical state space.
• Entanglement creates correlations between qubits that cannot be decomposed into independent parts.
• Interference is the mechanism that allows quantum algorithms to amplify useful possibilities while suppressing others.
• Quantum tunnelling, while not required by every quantum computer, is fundamental to several hardware technologies and forms the computational principle behind quantum annealers.

Together, they transform some of nature’s strangest behaviours into the building blocks of computation.

After observing them, scientists began asking a powerful question: What if, instead of merely studying these phenomena, we could control them and use them to compute?

Classical computers represent information through controlled physical switches. Vacuum tubes first regulated the flow of electrons; transistors later performed the same role faster, more reliably and at microscopic scale. From these switches emerged binary logic: 0 or 1, on or off. Every application we use today, from operating systems and databases to cloud platforms and Large Language Models, ultimately runs on that foundation.

Quantum computers use a different model. Their qubits are engineered so that superposition, interference and entanglement can be prepared, transformed and measured as computational resources. Rather than reducing every problem to sequences of binary switches, they allow information to evolve according to quantum rules. This matters especially when the problem itself is quantum.

Classical computers can “simulate” molecules, proteins and materials with remarkable sophistication. But they must represent quantum behaviour using classical information and, as systems grow, increasingly depend on approximations, fragmentation and carefully selected regions of interest.

It is a little like trying to reproduce an orchestra using only a piano. You may recreate the melody beautifully, but some harmonies and interactions inevitably become harder to preserve.

In contrast, quantum computers offer a fundamentally different possibility: modeling quantum systems using controllable quantum states. That does not mean they reproduce nature perfectly. They still depend on mathematical models, finite representations, experimental assumptions and error-prone hardware. But they speak a language much closer to that of the systems being studied.

Nature does not approximate itself. It simply follows its own laws

The true promise of quantum computing extends far beyond sheer computational speed or algorithmic milestones like prime factorization in Shor's algorithm. Its real excitement lies in providing a novel scientific instrument capable of tackling questions that remain fundamentally intractable for classical architectures.

Similarly, the microscope did not replace our eyes. The telescope did not replace observation from Earth. They expanded what humanity could investigate.

Quantum computers may play a similar role: helping us model and eventually engineer aspects of chemistry, biology and materials that remain beyond our practical computational reach.

But quantum computing is also part of an even larger story. It reminded me that computation is not synonymous with silicon. Transistors are only one physical way to represent and transform information. Light, molecules, atoms and superconducting circuits can also become computational substrates.

And that leads to the next question: What, exactly, makes a machine a computer?

2. Computation Beyond Silicon

One of the biggest ideas I took home from that visit, attending VivaTech and being close to an IBM actual quantum computer (see chapter 1.1 for details), had less to do with quantum mechanics and more about computation itself. It became especially clear after witnessing a presentation by Q.ANT on photonic processors (NPU: Native Processing Unit) designed for AI inference and training, where they were claiming that nonlinear functions can be processed natively and efficiently using light, at remarkably low power consumption [2.8].

For most of my career, I unconsciously associated computation with silicon chips: CPUs, Memory, Gates, Motherboards and Electronic circuits. After all, that's what every electronics and software engineer grows up with. But standing next to the IBM machine made me realize something much deeper. Silicon is not computation itself. It is only one way to implement computation.

This idea isn't new. Almost a century ago, Alan Turing introduced the concept of a Universal Machine: a machine capable of performing any computation, provided it can represent information and execute a sufficient set of elementary operations [2.1].

What's remarkable is that a Universal Computer doesn't care whether information is represented by electrical voltages, magnetic fields, photons, molecules, or quantum states. It only cares that information can be represented, transformed, and measured in a predictable way.

Looking back at the history of computing, this becomes surprisingly obvious. Early machines relied on bulky (vacuum valves), fragile components that were eventually replaced by smaller, faster, and more reliable technologies (silicon chips with millions of transistors). Over time, architectures evolved, performance increased, and new capabilities emerged. Yet through all these transformations, the underlying concept of computation remained unchanged.

Quantum computing may simply be the next chapter in that story. It expands our understanding of what a computer can be « silicon is not going anywhere; it is getting company ».

2.1 Computing Using the Laws of Physics

Once I started looking at computing from that perspective, I began noticing something fascinating. Researchers are increasingly building computers that exploit different physical phenomena instead of relying exclusively on electronic switches. But quantum computing is only one example.

Consider OPTICAL computing, like the Q.ANT example. Instead of moving electrons through transistors, optical processors manipulate light. In carefully designed optical systems, phenomena such as diffraction and interference naturally perform analog linear transformations, like Fourier transforms, as light propagates through lenses or integrated photonic circuits [2.2] [2.3].

The physics itself performs part of the computation. Light does the arithmetic on its way through the lens.

DNA computing takes an entirely different approach. Instead of transistors or photons, information is encoded into molecular sequences. Computations emerge from biochemical reactions, molecular recognition, and programmable interactions between DNA strands. The remarkable property of DNA isn't speed. It's massive molecular parallelism. Millions or even billions of candidate solutions can be represented simultaneously inside a tiny test tube [2.4].

QUANTUM computers exploit yet another set of physical laws. Instead of manipulating electrical currents, they manipulate probability amplitudes through superposition, interference, and entanglement.

Each of these paradigms has different strengths. Some are general-purpose. Others are highly specialized. Some may eventually become universal computers. Others will remain extraordinary accelerators for specific classes of problems. But together they reveal something profound. Computation is no longer limited to transistors. It is becoming the science of designing physical systems that naturally solve information-processing problems.

As engineers, we have spent decades learning how to make transistors smaller, faster, and more efficient. Perhaps the next great revolution may come from recognizing that nature already offers many different ways to compute.

2.2 Many Roads to Quantum Computing

Even within quantum computing, there isn't a single way to build a quantum computer.

IBM and Google use superconducting circuits, where carefully engineered electrical components behave as quantum systems when cooled to temperatures only a few millikelvin above absolute zero [1.1] [1.2] [1.3].

Companies such as IonQ and Quantinuum follow a completely different path. Their qubits are individual ions suspended in free space using electromagnetic fields and manipulated with exquisitely precise laser pulses. It looks as though it came straight out of a science fiction novel, but it is actually engineered to work. And instead of preserving quantum information inside superconducting circuits, they preserve it inside individual atoms [2.5] [2.6].

Other companies pursue neutral atoms (Pasqal), photonic qubits (Xanadu), silicon spin qubits (Intel), or even more exotic approaches [2.6]. One of those, quantum annealing, was pioneered commercially by D-Wave. Rather than executing sequences of quantum gates, quantum annealers exploit quantum tunnelling to explore many possible solutions and naturally converge toward low-energy ones [2.7]. They are not universal quantum computers, but they have shown promise for tackling specialized optimization problems in logistics, scheduling, manufacturing and finance.

Every modality (i.e. the physical approach used to implement qubits) exploits different quantum phenomena, makes different engineering trade-offs, and may ultimately excel at different classes of problems. Some offer longer coherence times (e.g., trapped ions). Others execute operations faster (e.g., superconducting circuits). Some scale more naturally (e.g., photonic systems). Others currently achieve higher fidelities (e.g., trapped-ions) [2.5] [2.6].

I don't yet know which architectures, or combination of architectures, will dominate over the coming decades, or whether they will resemble the quantum computers of 50 years from now.

It's like trying to imagine silicon chips at the time of Charles Babbage, when his Analytical Engine was designed around brass, gear trains, and levers. Perhaps that's exactly what sparks my curiosity and makes this moment so exciting.

2.3 From Hardware to Software

At this point, many software engineers usually ask me the same question: "Interesting... but what does any of it have to do with me?"

Just as operating systems hide transistor physics and compilers hide assembly language, modern quantum software stacks increasingly hide the complexity of cryogenics, lasers, microwave electronics, and hardware-specific control systems.

Most of us will never manipulate a Josephson junction. Or align a laser to trap an ion. We'll interact with quantum computers exactly as we do with every other computing platform: through software abstractions.

And that's where the story becomes especially interesting for software engineers.

3. Programming Quantum Computers: A New Way of Thinking

« I expected alien syntax, and I was almost disappointed ».

After learning how these machines are built, the next obvious question is:

How do you actually program one?

Before writing my first quantum program, I imagined something radically different from the software I had been developing throughout my career.

Instead, I found... Python. Familiar syntax, familiar structure, but strangely hollow if you don’t understand the physics beneath it.

It reminded me of Oliver Sacks’ account of prosopagnosia (face blindness), where he could see a face, and yet fail to recognize it, sometimes even apologizing to his own reflection in a mirror as if it were a stranger. The features were all there, perfectly visible, but the meaning never quite assembled.

In the same way, the code looks recognizable, almost comforting, but without an understanding of the underlying quantum principles, it feels like staring at something you know you should understand, yet somehow cannot fully grasp.

One of the first quantum programs I built through IBM Quantum Platform (IBM's cloud platform for interacting with quantum hardware) was Grover's algorithm with just 2 qubits. It is a quantum search method that provides a quadratic speedup for finding specific items in an unsorted database, making it highly efficient for unstructured search problems. By using quantum interference to amplify the probability of the correct answer, it significantly reduces the number of operations required compared to classical brute-force approaches [3.3].

Important clarification: Grover's algorithm queries an oracle rather than searching a traditional database. Although the phrase "unsorted database" originates from Grover's 1996 paper title [3.3], the quadratic speedup specifically applies to brute-force evaluation of a function that identifies the target answer; applying it to a physical dataset would necessitate large-scale quantum memory that has yet to be constructed.

from qiskit import QuantumCircuit

# Grover's search for the state |11> on 2 qubits
qc = QuantumCircuit(2)

# 1. Initialization: Create superposition of all states 
#    (|00>, |01>, |10>, |11>)
qc.h([0, 1])

# 2. Oracle: Flip the phase of the target state |11>
# A CZ gate flips the phase only when both qubits are 1
qc.cz(0, 1)  # to -|11>
# 3. Amplification (Diffusion Operator): Inversion about the mean
qc.h([0, 1]) # Apply Hadamard gate to change basis
qc.x([0, 1]) # Apply Pauli-X (NOT gate) to flip the qubits
qc.cz(0, 1)  # Apply Controlled-Z gate to flip the phase of the |11> state
qc.x([0, 1]) # Apply Pauli-X to flip the qubits back
qc.h([0, 1]) # Apply Hadamard to return to the computational basis

# 4. Measure & show
qc.measure_all()
print(qc)

If you've written Python before, there is nothing intimidating about the syntax. But don't let that simplicity fool you. The way these programs behave is profoundly different from anything we have been taught in traditional software engineering [3.1].

Each line is preparing the quantum system to evolve in a carefully controlled way.

The two Hadamard gates place both qubits into a superposition, so instead of representing only one state, they collectively represent all four possible combinations (|00⟩, |01⟩, |10⟩ and |11⟩).

Next, the Controlled-Z gate acts as an oracle. It doesn’t “select” the correct answer. Instead, it quietly marks the target state by changing its phase, leaving all other possibilities untouched.

The remaining gates perform what is known as the diffusion operator. Rather than searching through every possibility one by one, they use quantum interference to reinforce the marked state while reducing the probability of the others.

Finally, measuring the qubits converts the quantum state into an ordinary classical result. After repeating the circuit enough times, the marked answer appears much more frequently than the alternatives [3.1] [3.3].

The remarkable part isn’t that the computer explored every answer one after another. It is that the algorithm shaped the evolution of the entire quantum state so that interference made the desired answer the most likely outcome.

An intuitive analogy

Imagine searching for one name on four identical cards lying face down:

• H gates: Lay out all four cards equally so each has the same chance.
• Oracle (CZ): Secretly place a tiny invisible mark on the correct card.
• Diffusion operator: Shake the table in a special way that only works because of that hidden mark, causing the marked card to become much more prominent while the others fade.
• Measurement: Turn over the card, you now almost always find the marked one.

The remarkable part is that the oracle never says which card is correct. It only marks it by changing its phase, and the diffusion operator converts that invisible phase difference into a much higher probability of measuring the correct answer. That conversion from a hidden phase change into a measurable probability increase is the key idea behind Grover’s search algorithm.

3.1 Every Generation Hides More Complexity

The history of computing has always been the history of better abstractions.

Very few software engineers today think about transistor physics when writing Java or Python. Even fewer think about how cache hierarchies, branch prediction, or instruction pipelines work inside modern processors. Compilers, operating systems and programming languages allow us to focus on solving problems instead of controlling hardware.

Quantum computing is following exactly the same path.

Although today's developers still manipulate quantum gates explicitly, libraries such as Qiskit already abstract away most of the complexity of microwave pulses, laser control, calibration, timing, cryogenics and hardware-specific implementations [3.1].

Tomorrow, those abstractions will become even higher.

3.2 It Feels Surprisingly Familiar

Programming a quantum computer reminded me of learning Assembly language at university. Back then, writing software meant thinking in terms of elementary CPU instructions.

MOV, ADD, CMP, JMP.

Each instruction directly manipulated registers, memory addresses or processor flags.

Quantum programming feels remarkably similar. Instead of processor instructions, we compose quantum gates. Instead of manipulating registers, we transform quantum states.

One way I like to think about quantum algorithms is that they rely on three fundamental “verbs.”

• Superposition creates a rich space of possible computational states.
• Entanglement links qubits so they behave as parts of a single quantum system rather than as independent variables.
• Interference is what gives quantum algorithms their power, reinforcing the probability of useful answers while cancelling less useful ones.

Quantum gates are simply the operations that manipulate these three resources with extraordinary precision.

A typical quantum circuit may contain gates such as:

• Hadamard (H): creates an equal superposition when applied to a computational-basis state such as ∣0⟩. qc.h()
• Pauli-X: the closest equivalent to a classical NOT gate. qc.x()
• CNOT (Controlled-NOT): correlates two qubits and is one of the fundamental building blocks for creating entanglement. That happens when the control is already in a suitable superposition. qc.cx()
• Rotation gates (Rx, Ry, Rz): rotate the quantum state around different axes of the Bloch sphere [3.1] [3.2]. qc.rx(), qc.ry(), qc.rz()

To understand where this evolution leads, it helps to pull back one more layer. In Qiskit, most circuits can be exported into OpenQASM, a low-level, hardware-agnostic specification for gates and measurements. Much like the classic MOV and JMP instructions in assembly language, OpenQASM serves as the quantum equivalent. Originating at IBM, it is currently maintained as an open-source community standard at version 3.1. [3.8].

The Python code below uses Qiskit to build a simple Bell state, which is then translated directly into OpenQASM 3:

from qiskit import QuantumCircuit, qasm3
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
print(qasm3.dumps(qc))

This produces the following lower-level representation:

OPENQASM 3.0;
include "stdgates.inc";
bit[2] meas;
qubit[2] q;
h q[0];
cx q[0], q[1];
barrier q[0], q[1];
meas[0] = measure q[0];
meas[1] = measure q[1];

Working in Qiskit means you rarely need to inspect this OpenQASM text directly. Stepping up another abstraction level, IBM Quantum Composer provides a visual drag-and-drop canvas where gates are placed onto qubit wires with a mouse, generating both OpenQASM and Python code side by side. Together, the Python SDK, OpenQASM, and Composer represent a single quantum circuit across three distinct tiers of abstraction, telling the exact same story in three different ways. As circuits scale in complexity, developers encounter concepts unique to quantum paradigms, such as the timeline view of Grover's algorithm below illustrating qubit state transitions through quantum gates.

The diagram shows the quantum state evolving through ordered layers of gates, some of which can act in parallel.

One example is the Hamiltonian, a mathematical description of the total energy of a physical system. Many quantum simulation algorithms are not expressed as "execute these logical steps." Instead, they are formulated as:

Prepare this quantum system and allow it to evolve according to its Hamiltonian [3.4].

Coming from software engineering, I found that fascinating. We are no longer only writing instructions. We are increasingly describing how we want a physical system to evolve.

3.3 It Also Reminded Me of Designing Digital Circuits

In some ways, today's quantum programming resembles something even older than Assembly language: Digital electronics.

When we first learn electronics, we don't begin with operating systems or programming languages. We begin with logic gates.

AND, OR, NOT, NAND, Flip-flops, Registers, Counters.

Eventually those simple building blocks become processors.

Quantum computing feels very similar today. Instead of wiring together AND and OR gates, we compose quantum gates that manipulate probability amplitudes instead of voltage levels.

Today's quantum software often feels like programming at the level where hardware and software still meet. History suggests that this won't last forever. As hardware matures, software abstractions always rise.

While Qiskit serves as a prime example, it represents merely a slice of an expanding software ecosystem spanning diverse levels of abstraction. This landscape already reaches far beyond the tools highlighted here, with each framework occupying a distinct tier within the computational stack. Schematic tools such as IBM Quantum Composer sit at the top. High-level languages such as Microsoft’s Q# let developers describe algorithms more abstractly, and intermediate formats such as OpenQASM carry circuits down toward the hardware [3.8] [3.10]. Academic languages like Quipper, an embedded Haskell language developed at Dalhousie University, shaped many of these ideas [3.11], although today they remain mostly of historical and academic interest. Table 1 summarizes a selection of the tools in use today [3.12].

Table 1: A selection of quantum software tools and the layer of the stack where each one sits.

While implementations vary, every platform shares a unified architecture: framework for circuit definition, a translation layer, and an execution engine.

3.4 The Biggest Change Isn't the Syntax

It Is the Mindset. The probabilistic mindset.

Classical software engineering has conditioned us to think deterministically. Given the same inputs, we expect exactly the same outputs. Unit tests verify that expectation.

Quantum computing challenges that assumption. Running exactly the same quantum program multiple times does not necessarily produce the same result. And that doesn't mean something went wrong. The probability distribution is part of the answer. Surprisingly, this idea no longer feels completely foreign.

Generative AI has already started changing how many of us think about software. Large Language Models rarely produce identical responses to the same inputs (especially if temperature is different from 0). We increasingly evaluate prompts statistically rather than expecting deterministic outputs [3.5]. Instead of relying exclusively on unit tests, we now design evaluations, compare probability distributions, measure quality, and optimize prompts through repeated experimentation.

Quantum computing pushes that mindset even further. Rather than writing software that always computes a single deterministic answer, we often design circuits whose objective is to make the correct answer overwhelmingly more likely than all the alternatives.

As software engineers, we are already beginning to learn this new way of thinking through AI. Quantum computing simply extends that journey.

3.5 Will AI Write Quantum Software?

AI is helping researchers calibrate qubits, mitigate errors, optimize quantum circuits, discover new algorithms and even generate quantum programs from natural-language descriptions [3.6] [3.7] [5.6].

Soon, AI agents will likely be able to synthesize entire quantum circuits for us. Once again, AI will free software engineers from acting as human compilers, no longer needing to memorize syntax, and allowing them to focus on solving the underlying problems, which are inherently complex and remain unsolved by classical approaches. Therefore the challenges will be in understanding:

• Which problems are suitable for quantum computing?
• How to reason probabilistically instead of deterministically?
• How to evaluate stochastic results rather than expecting identical executions?
• How to combine CPUs, GPUs, TPUs and QPUs into hybrid architectures?
• How to collaborate with AI agents that increasingly generate, optimize and validate quantum software?

The history of software engineering has never been about programming closer to the hardware. It has been about building better abstractions. I believe quantum computing will follow exactly the same path.

And if the last few years have taught us anything through Generative AI, it is that learning a new programming language is usually the easiest part. Learning a new way of thinking is where the real transformation begins.

4. Why Humanity Should Care

Why are governments, universities and technology companies investing billions of dollars in quantum computing?

Quantum computing is ultimately about understanding nature well enough to engineer it. Throughout history, every major scientific breakthrough has started the same way. We first observed nature. Then we understood it. Finally, we learned how to reproduce it. As examples:

• We observed electricity long before we built power grids.
• We studied electromagnetism before inventing radios.
• We understood semiconductors before creating the modern computer.

Quantum computing may become another example.

For the first time, we may eventually build computers capable of modeling complex quantum systems using the same quantum rules that govern them « as Richard Feynman originally proposed [1.3]», rather than relying exclusively on increasingly sophisticated classical approximations.

That distinction may sound subtle. But it changes the kinds of questions we may finally be able to ask, and respond.

4.1 Modeling Life Instead of Approximating It

Perhaps the most exciting opportunity lies in biology.

Proteins are often described as the molecular machines of life. They transport oxygen. Repair DNA. Fight infections. Transmit signals between neurons. Catalyze nearly every chemical reaction that keeps us alive. Understanding how proteins fold, interact and change shape remains one of the greatest scientific challenges.

Today's supercomputers can model portions of these systems, but only by making approximations whose computational cost grows dramatically as the molecules become larger and their interactions more complex [1.4] [4.1].

Quantum computing offers a different vision. Instead of approximating every interaction classically, future quantum computers may model many of those quantum interactions more naturally [4.1]. If we succeed, the impact could be extraordinary.

This capability extends beyond physical hardware advancement. Released in 2017 as an open-source project, Google’s OpenFermion library handles the essential underlying conversion process: translating a molecule's electronic structure into fermionic operators and executable quantum circuit primitives. [4.10]. It serves as the practical engine for the concept introduced in Section 3: initializing a physical state and letting it evolve naturally under its Hamiltonian. While OpenFermion cannot solve protein folding by itself, it forms the crucial bridge linking the physical principles introduced in the prior section with the biological applications discussed next.

Drug design still leans heavily on trial and error. What if we could predict biologically relevant interactions with greater accuracy before synthesizing a candidate?

The same capability would reach Alzheimer's, Parkinson's, rare genetic disorders, autoimmune diseases and even cancer. It would also reach the molecular mechanisms of aging: the processes that make our cells deteriorate over time.

The mechanism is less magical than the headline, and more useful: quantum computers could help us understand biology at a level we struggle to model today.

4.2 Learning From Plants

One of my favorite examples is photosynthesis.

Every day, plants perform something astonishing. Using only sunlight, water and carbon dioxide from the atmosphere, they produce carbohydrates and release the oxygen we breathe from the water.

Nature has spent billions of years refining this process. And despite decades of research, we still cannot reproduce it with comparable elegance or efficiency.

Understanding photosynthesis deeply enough, and artificial systems become designable: sunlight, water and atmospheric carbon dioxide turned into fuels or useful chemicals, at efficiencies approaching those nature perfected. Such systems could help produce sustainable fuels, capture atmospheric carbon and reduce our dependence on fossil resources [4.2].

Again, the objective is to learn from nature. Photosynthesis is the teacher, not the blueprint.

4.3 Feeding a Growing Planet

Although about 78% of Earth's atmosphere is nitrogen, most plants cannot use it directly.

Nature solves this through specialized bacteria containing an extraordinary enzyme called nitrogenase, capable of converting atmospheric nitrogen into compounds that plants can absorb [4.3].

Humanity accomplishes the same objective through the Haber-Bosch process, one of the most important industrial discoveries in history. Without it, billions of people would not have enough food.

The downside is that it consumes roughly 1–2% of the world's total energy production while generating significant carbon emissions [4.4].

Now put nitrogenase within reach of simulation. Catalysts engineered from nature's own solution would mean cheaper fertilizers, lower energy consumption and greenhouse-gas emissions, and food that more people can afford. Ultimately, helping feed a growing global population more sustainably.

4.4 New Materials We Cannot Yet Imagine

Many of history's greatest technological revolutions have been driven by new materials (e.g. Bronze, Steel, Silicon, Carbon fiber and Graphene to name a few).

What materials remain undiscovered simply because we cannot accurately model them?

One of the most intriguing prospects is the discovery of near room-temperature superconductors without requiring extreme pressures. While high-temperature superconductors like cuprates exhibit zero resistance around 77 K (liquid nitrogen temperatures), IBM's aluminum-based quantum processors are cooled to millikelvin temperatures primarily to suppress thermal noise and prevent environmental decoherence, rather than because superconductivity itself requires such extreme cold [4.5].

If materials with similar properties worked at room temperature, the consequences would be difficult to overstate:

• Electricity could travel across power grids with dramatically lower losses.
• Magnetic levitation transportation could become significantly more practical.
• MRI systems could become cheaper and more accessible.
• Fusion reactors would benefit from simpler and less expensive magnetic confinement systems.
• Even entirely new electronic devices might emerge.

For these reasons, materials science is considered one of the most promising long-term applications of quantum computing.

4.5 Better Batteries, Smarter Grids and Stronger Materials

Some applications are already much closer to today's industry.

Researchers are using hybrid quantum-classical techniques to better understand battery chemistry, aiming to design longer-lasting, safer and higher-capacity energy storage systems [4.6].

Others are exploring quantum optimization to improve electrical-grid management as renewable energy sources become increasingly distributed and variable [4.8].

The aerospace industry is investigating how quantum chemistry can help model the degradation of advanced composite materials, potentially leading to lighter aircraft with longer service lives and lower maintenance costs [4.7].

Financial institutions are experimenting with hybrid quantum algorithms for portfolio optimization and risk analysis, searching for better solutions to complex optimization problems [4.9].

None of these applications are fully solved today. Many remain active areas of research. But together they illustrate something important. Quantum computing is already moving beyond theoretical demonstrations.

It is gradually becoming another tool that scientists and engineers can combine with classical computing to tackle problems that were previously out of reach.

4.6 The Real Opportunity

When people ask me whether quantum computers will replace classical computers, my answer is always the same. I don't think that's the right question.

The more interesting question is: What problems become possible once we stop forcing nature to fit classical approximations?

Perhaps quantum computing's greatest contribution will not be faster algorithms. It may be giving humanity a better language for understanding the universe itself. And history suggests that every time we learn a new language of nature, remarkable things follow.

5. The Next Abstraction Layer

Standing beside that machine, it was easy to imagine the future.

But it was equally important to recognize how much work remains before that future becomes practical.

Today's quantum computers are extraordinarily fragile [5.1]. Heat, vibration, electromagnetic interference, manufacturing imperfections and interactions with the surrounding environment can disturb a qubit and corrupt the information it carries.

Consequently, one of the most urgent challenges in quantum computing is quantum error correction.

In classical computing, information can be copied and protected using familiar redundancy techniques. If one bit is damaged, other copies can help reconstruct it. Quantum information is more difficult.

An unknown quantum state cannot simply be copied [5.2], and errors may affect not only whether a qubit represents zero or one, but also its phase. Preserving a qubit is a little like trying to preserve the ripple pattern on a perfectly still lake while someone keeps throwing pebbles nearby. To protect one reliable logical qubit, quantum error-correction codes distribute its information across multiple imperfect physical qubits [5.3].

With some established approaches, obtaining one sufficiently reliable logical qubit may eventually require hundreds; or, depending on the hardware quality and algorithm, potentially many more, physical qubits. But, different error-correcting codes require vastly different overheads. IBM and other researchers are developing lower-overhead approaches, including quantum low-density parity-check codes, intended to reduce that enormous resource cost [5.4].

This distinction is important: A machine may advertise hundreds or thousands of physical qubits, but what ultimately matters for large, useful algorithms is how many reliable logical qubits it can operate, and for how long.

For software engineers, however, this is currently more of a hardware and systems-engineering constraint than an application-programming responsibility.

Researchers must improve qubit quality, connectivity, fabrication, control electronics and real-time decoding. Error correction also requires sophisticated codes and software, so it is not exclusively a hardware problem, but application developers should increasingly encounter it through abstractions provided by the platform rather than implementing it themselves.

This is similar to how most developers do not design ECC memory, transistor layouts or CPU branch predictors. We benefit from them through reliable abstractions. Quantum computing will probably evolve in the same way.

5.1 A Hybrid Future

The future is hybrid, and the division of labour is already visible:

• CPUs will continue coordinating general-purpose logic.
• GPUs and TPUs will accelerate AI and highly parallel numerical workloads.
• QPUs may tackle selected problems involving quantum systems, optimization or other algorithms where quantum resources provide a genuine advantage. [5.5]
• And AI may help orchestrate the entire environment.

AI systems are already being explored to assist with hardware calibration, circuit optimization, error mitigation, algorithm discovery and interpretation of experimental results [5.6] [3.6] [3.7]. In the future, AI agents may translate a scientist's or engineer's intent into a workflow that combines classical and quantum resources without requiring the user to manually design every gate.

But higher abstraction does not eliminate the need for engineering judgment.

Software engineers will still need to understand:

• which problems genuinely benefit from quantum computation;
• how to design hybrid architectures;
• how to reason about probabilistic outputs;
• how to define evaluations and confidence thresholds;
• and how to distinguish meaningful advantage from an impressive experiment.

Generative AI has already started preparing us for part of this transition. Quantum software will demand an even deeper version of that probabilistic mindset. AI agents may eventually hide the gates. But they will not remove the need to understand probabilities, uncertainty and the problem being solved.

5.2 Returning to the Machine

When I look again at the picture from VivaTech, I no longer see only the chandelier, the refrigerator or the small processor hidden inside it.

I see several layers of human inventiveness:

• Converting fundamental physical laws into usable hardware.
• Exposing that hardware through a low-level instruction set.
• Abstracting the instruction set within Python-like programming constructs.
• And placing the entire stack into the hands of researchers exploring fundamental questions about the natural world.

Rather than waiting for external innovation, IBM proactively introduced the Qiskit Functions Catalog in 2024. This suite of managed services addresses domain-specific challenges in quantum chemistry, graph optimization, and differential equations, insulating users from circuit gates, transpilation, and error mitigation [5.7]. At its unveiling, Jay Gambetta, IBM’s quantum lead and the architect of Qiskit, suggested that abstracting hardware complexity in this way represents a paradigm shift on par with to the moment IBM put the quantum computer on the cloud, pivoting the developer focus from low-level gate mechanics to high-level workflow integration. This vision aligns with current trajectories: the high-level abstraction described in this section is already operational via a dedicated catalog page. Although presently tailored to scientific researchers and computational experts on premium tiers, it lays the groundwork for broader adoption.

At Parser, we spend much of our time thinking about how emerging technologies will reshape software engineering and how to turn technical possibilities into useful systems for our clients.

Quantum computing is not yet ready to replace today's enterprise platforms, and probably never will in the way the expression suggests. But that is not what makes it important. Cloud computing did not replace every computer. GPUs did not replace CPUs. Artificial Intelligence is not replacing every form of software.

Each introduced a new capability and a new abstraction that changed what engineers could build. Quantum computing may become the next one.

Looking back, I realized that I hadn’t really gone to see a new kind of computer. I had gone to witness the birth of another abstraction layer. Just as transistors disappeared behind operating systems and programming languages, today’s quantum hardware will eventually disappear behind software frameworks and, perhaps, AI agents. What remains is the set of problems we become able to solve.

The hardware remains noisy. The logical qubits remain expensive. The useful applications are still emerging.

But the abstraction layers are already being built. And as an engineer, I find it difficult to imagine a more exciting future to help shape.

Every generation of engineers inherits an abstraction it did not build and hands over one it barely finished. This one happens to be made of physics.

Martín Miceli, Oct. 2026

Martín Miceli is CTO at Parser, and an electronics engineer who crossed over to the dark side of the force to build software systems. He stayed fascinated by how new technologies work and how they connect to nature and to intelligence, and he writes about them for a selfish reason: explaining something is still the best way he manages to understand it « a similar feeling he used to get from teaching ».

References

Section1 - Meeting the Quantum Computer

[1.1] Superconducting qubits and their physical implementation
Kjaergaard, M., et al. (2020). Superconducting Qubits: Current State of Play. Annual Review of Condensed Matter Physics, 11, 369–395. https://arxiv.org/abs/1905.13641 https://doi.org/10.1146/annurev-conmatphys-031119-050605,

[1.2] Engineering and controlling superconducting qubits
Krantz, P., et al. (2019). A Quantum Engineer’s Guide to Superconducting Qubits. Applied Physics Reviews, 6(2), 021318. https://doi.org/10.1063/1.5089550, https://arxiv.org/abs/1904.06560

[1.3] The original argument for quantum simulation
Feynman, R. P. (1982). Simulating Physics with Computers. International Journal of Theoretical Physics, 21, 467–488, p.486. https://doi.org/10.1007/BF02650179

[1.4] Quantum chemistry and classical-computing limitations
Cao, Y., Romero, J., et al. (2019). Quantum Chemistry in the Age of Quantum Computing. Chemical Reviews, 119(19), 10856–10915. https://doi.org/10.1021/acs.chemrev.8b00803 https://arxiv.org/abs/1812.09976

[1.5] Experimental evidence for photon entanglement
Aspect, A., Grangier, P., & Roger, G. (1982). Experimental Realization of Einstein-Podolsky-Rosen-Bohm Gedankenexperiment: A New Violation of Bell’s Inequalities. Physical Review Letters, 49(2), 91–94. https://doi.org/10.1103/PhysRevLett.49.91

[1.6] Bell tests with changing measurement settings
Aspect, A., Dalibard, J., & Roger, G. (1982). Experimental Test of Bell’s Inequalities Using Time-Varying Analyzers. Physical Review Letters, 49(25), 1804–1807. https://doi.org/10.1103/PhysRevLett.49.1804

[1.7] Crystal-based generation of entangled photon pairs
Kwiat, P. G., et al. (1995). New High-Intensity Source of Polarization-Entangled Photon Pairs. Physical Review Letters, 75(24), 4337-4341. https://doi.org/10.1103/PhysRevLett.75.4337

[1.8] The quantum double-slit experiment
Sayer, R., Maries, A., & Singh, C. (2017). Quantum Interactive Learning Tutorial on the Double-Slit Experiment to Improve Student Understanding of Quantum Mechanics. Physical Review Physics Education Research, 13, 010123. https://doi.org/10.1103/PhysRevPhysEducRes.13.010123

[1.9] Quantum tunneling: theory and applications
Razavy, M. (2014). Quantum Theory of Tunneling. 2nd Edition. World Scientific Publishing. https://doi.org/10.1142/8743

[1.10] Bloch Sphere graphical visualization
Nielsen, M. A., & Chuang, I. L. (2010). Quantum Computation and Quantum Information. 10th Anniversary Edition. Cambridge University Press. 702 pp., ISBN 9781107002173

[1.11] Alternative visual and mathematical approaches to quantum states
Glassner, A. (2025). Quantum Computing: From Concepts to Code. No Starch Press. 424 pp., ISBN 978-1-7185-0400-4

Section2 - Computation Beyond Silicon

[2.1] Universal computation
Turing, A. M. (1936). On Computable Numbers, with an Application to the Entscheidungsproblem. Proceedings of the London Mathematical Society, 42(1), 230–265. https://doi.org/10.1112/plms/s2-42.1.230

[2.2] The physics and limitations of optical computing
McMahon, P. L. (2023). The Physics of Optical Computing. Nature Reviews Physics, 5, 717–734. https://doi.org/10.1038/s42254-023-00645-5

[2.3] Optical Fourier transformation
Macfaden, A., Gordon, G., & Wilkinson, T. (2017). An optical Fourier transform coprocessor with direct phase determination. Scientific Reports, 7. https://doi.org/10.1038/s41598-017-13733-1

[2.4] DNA as a computational substrate
Adleman, L. M. (1994). Molecular Computation of Solutions to Combinatorial Problems. Science, 266(5187), 1021–1024. https://doi.org/10.1126/science.7973651

[2.5] Trapped-ion quantum computing
Bruzewicz, C. D., Chiaverini, J., McConnell, R., & Sage, J. M. (2019). Trapped-Ion Quantum Computing: Progress and Challenges. Applied Physics Reviews, 6(2), 021314. https://doi.org/10.1063/1.5088164

[2.6] Comparing quantum-computing modalities
Ladd, T. D., Jelezko, F., Laflamme, R., Nakamura, Y., Monroe, C., & O’Brien, J. L. (2010). Quantum Computers. Nature, 464, 45–53. https://doi.org/10.1038/nature08812

[2.7] Quantum annealing
Albash, T. & Lidar, D. A.(2018). Adiabatic Quantum Computation, Reviews of Modern Physics, 90, 015002, https://doi.org/10.1103/RevModPhys.90.015002.

[2.8] Photonic Native Processing Units for AI workloads
Q.ANT. (2026). Q.ANT Runs Generative AI on Photonic Hardware. June 23, 2026. https://qant.com/press-releases/q-ant-runs-generative-ai-on-photonic-hardware/

Section3 - Programming Quantum Computers

[3.1] The quantum-circuit model and Qiskit abstractions
IBM Quantum. Qiskit Documentation: Quantum Circuits and IBM Quantum Platform. Continuously updated technical documentation. https://quantum.cloud.ibm.com/docs/en/guides https://quantum.cloud.ibm.com/docs/api/qiskit/qiskit.circuit.QuantumCircuit

[3.2] Elementary quantum gates and universal circuits
Barenco, A., et al. (1995). Elementary Gates for Quantum Computation. Physical Review A, 52(5), 3457–3467. https://doi.org/10.1103/PhysRevA.52.3457 https://arxiv.org/abs/quant-ph/9503016

[3.3] Grover’s quantum search algorithm
Grover, L. K. (1996). A Fast Quantum Mechanical Algorithm for Database Search. Proceedings of the 28th Annual ACM Symposium on Theory of Computing (STOC ’96), 212–219. https://doi.org/10.1145/237814.237866. https://arxiv.org/abs/quant-ph/9605043

[3.4] Hamiltonian evolution and quantum simulation
Lloyd, S. (1996). Universal Quantum Simulators. Science, 273(5278), 1073–1078. https://doi.org/10.1126/science.273.5278.1073

[3.5] Evaluating probabilistic AI systems
Liang, P., et al. (2023). Holistic Evaluation of Language Models. Transactions on Machine Learning Research. https://arxiv.org/abs/2211.09110

[3.6] Machine learning for quantum error mitigation
Liao, H., Wang, D.S., Sitdikov, I. et al. (2024) Machine learning for practical quantum error mitigation. Nat Mach Intell 6, 1478–1486. https://doi.org/10.1038/s42256-024-00927-2

[3.7] AI-assisted quantum error decoding
Bausch, J., et al. (2024). Learning High-Accuracy Error Decoding for Quantum Processors. Nature, 635, 834–840. https://doi.org/10.1038/s41586-024-08148-8

[3.8] OpenQASM as a hardware-independent circuit language
Cross, A. W., Bishop, L. S., Smolin, J. A., & Gambetta, J. M. (2017). Open Quantum Assembly Language. arXiv:1707.03429. https://arxiv.org/abs/1707.03429. Cross, A., Javadi-Abhari, A., et al. (2022). OpenQASM 3: A Broader and Deeper Quantum Assembly Language. ACM Transactions on Quantum Computing, 3(3). https://arxiv.org/abs/2104.14722. OpenQASM project (live specification, current version 3.1): https://github.com/openqasm/openqasm

[3.9] IBM Quantum Composer
IBM Quantum Platform documentation. IBM Quantum Composer. https://quantum.cloud.ibm.com/docs/en/guides/composer

[3.10] Q# and the Microsoft Quantum Development Kit
Microsoft Quantum Development Kit (QDK) documentation. https://learn.microsoft.com/azure/quantum/

[3.11] Quipper and early quantum programming languages
Green, A. S., Lumsdaine, P. L., Ross, N. J., Selinger, P., & Valiron, B. (2013). Quipper: A Scalable Quantum Programming Language. Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’13), 333–342. https://arxiv.org/abs/1304.3390

[3.12] Other quantum software frameworks
Official documentation: Cirq, https://quantumai.google/cirq ; PennyLane, https://pennylane.ai; Amazon Braket, https://docs.aws.amazon.com/braket/; pyQuil, https://pyquil-docs.rigetti.com/en/stable/

Section4 - Why Humanity Should Care

[4.1] Large-scale hybrid protein–ligand modelling
Merz, K. M. Jr., Shajan, A., Kaliakin, D., Liang, F., et al. (2026). Crossing the 12,000-Atom Barrier with Heterogeneous Quantum-Classical Supercomputing: Quantum Chemistry of Protein-Ligand Complexes. https://arxiv.org/abs/2605.01138

[4.2] Quantum simulation of photosynthetic energy transfer
Wang, B.-X., Tao, M.-J., et al. (2018). Efficient Quantum Simulation of Photosynthetic Light Harvesting. npj Quantum Information, 4, 52. https://doi.org/10.1038/s41534-018-0102-2

[4.3] Nitrogen fixation as a quantum-chemistry challenge
Reiher, M., Wiebe, N., Svore, K. M., Wecker, D., & Troyer, M. (2017). Elucidating Reaction Mechanisms on Quantum Computers. Proceedings of the National Academy of Sciences, 114(29), 7555–7560. https://doi.org/10.1073/pnas.1619152114

[4.4] Energy and environmental costs of industrial ammonia production
Smith, C., Hill, A. K., & Torrente-Murciano, L. (2020). Current and Future Role of Haber–Bosch Ammonia in a Carbon-Free Energy Landscape. Energy & Environmental Science, 13, 331–344. https://doi.org/10.1039/C9EE02873K

[4.5] Superconductivity and its technological importance
Hott, R., Kleiner, R., Wolf, T., & Zwicknagl, G. (2015). Review on Superconducting Materials. In Encyclopedia of Applied Physics. https://arxiv.org/abs/1306.0429

[4.6] Quantum modelling of battery-surface reactions
Barroca, M. A., Gujarati, T., et al. (2025). Scaling Active Spaces in Simulations of Surface Reactions through Sample-Based Quantum Diagonalization. https://arxiv.org/abs/2503.10923

[4.7] Aerospace-material degradation
Smith, T., Gujarati, T. P., Motta, M., et al. (2025). Quantum-Centric Simulation of Hydrogen Abstraction by Sample-Based Quantum Diagonalization and Entanglement Forging. https://arxiv.org/abs/2508.08229

[4.8] Decentralized energy-system optimization
Mastroianni, C., et al. (2023). Assessing Quantum Computing Performance for Energy Optimization in a Prosumer Community. https://arxiv.org/abs/2311.10594.

[4.9] Fixed-income portfolio optimization
Agliardi, G., Alevras, D., et al. (2025). Portfolio construction using a sampling-based variational quantum scheme. https://arxiv.org/abs/2508.13557

[4.10] OpenFermion: translating chemistry problems into quantum circuits
McClean, J. R., Rubin, N. C., Sung, K. J., et al. (2017). OpenFermion: The Electronic Structure Package for Quantum Computers. https://arxiv.org/abs/1710.07629 Google Research (2017). Announcing OpenFermion: The Open Source Chemistry Package for Quantum Computers. https://research.google/blog/announcing-openfermion-the-open-source-chemistry-package-for-quantum-computers/

Section5 - The Next Abstraction Layer

[5.1] Noisy intermediate-scale quantum computing
Preskill, J. (2018). Quantum Computing in the NISQ Era and Beyond. Quantum, 2, 79. https://doi.org/10.22331/q-2018-08-06-79

[5.2] The no-cloning theorem
Wootters, W. K., & Zurek, W. H. (1982). A Single Quantum Cannot Be Cloned. Nature, 299, 802–803. https://doi.org/10.1038/299802a0

[5.3] The foundations of quantum error correction
Shor, P. W. (1995). Scheme for Reducing Decoherence in Quantum Computer Memory. Physical Review A, 52(4), R2493–R2496. https://doi.org/10.1103/PhysRevA.52.R2493

[5.4] Lower-overhead quantum error correction
Bravyi, S., Cross, A. W., et al. (2024). High-Threshold and Low-Overhead Fault-Tolerant Quantum Memory. Nature, 627, 778–782. https://doi.org/10.1038/s41586-024-07107-7

[5.5] Quantum-centric and hybrid supercomputing
IBM Quantum. (2023). IBM Debuts Next-Generation Quantum Processor and IBM Quantum System Two. Official technical announcement. https://newsroom.ibm.com/2023-12-04-IBM-Debuts-Next-Generation-Quantum-Processor-IBM-Quantum-System-Two-Extends-Roadmap-to-Advance-Era-of-Quantum-Utility

[5.6] Machine learning across the quantum stack
Dunjko, V., & Briegel, H. J. (2018). Machine Learning and Artificial Intelligence in the Quantum Domain: A Review of Recent Progress. Reports on Progress in Physics, 81(7), 074001. https://doi.org/10.1088/1361-6633/aab406

[5.7] The Qiskit Functions Catalog
IBM Quantum (2026). Qiskit Functions updates accelerate research for the year of quantum advantage. IBM Quantum Blog. https://www.ibm.com/quantum/blog/functions-2026. TechCrunch (2024). IBM makes developing for quantum computers easier with the Qiskit Functions Catalog. https://techcrunch.com/2024/09/16/ibm-makes-developing-for-quantum-computers-easier-with-the-qiskit-functions-catalog