Quantum Computing Didn't Kill Analogue. It Resurrected It
I don't know if everyone remembers. The late 1970s analogue computers, with their dials and gauges. Racks of knobs, needles twitching against calibrated scales, patch cords linking amplifiers into circuits that modelled a problem before you'd written a single line of code. Engineers thought in physics, not syntax. You wired the equation, not the algorithm.
Then digital took over. Discrete bits replaced continuous voltages. Precision replaced drift. Everyone assumed analogue was a dead end, a museum piece next to the punch card.
Quantum computing has brought a version of it back, though not the dials themselves. What survived is the logic underneath them.
Continuous, not discrete
A classical bit is 0 or 1, clean and countable. A qubit is not that. Its state is a continuous superposition, described by complex amplitudes that can take any value until the moment you measure it. That's not a digital abstraction wearing a quantum costume. It's a return to continuous physical quantities as the substrate of computation, which is exactly what those analogue rigs were built on.
In my experience, people new to quantum computing assume the "computer" part means it works like a laptop underneath. It doesn't. Underneath, it behaves more like a voltage on a dial than a bit in a register. The discreteness only arrives at readout.
Solving by letting physics do the work
An analogue computer never executed a differential equation step by step. You built a circuit whose physical behaviour obeyed the same equation as your problem, let it settle, and read the answer off a gauge. There's no instruction set running, no loop counter ticking over, just physics arranged to mirror the maths.
Quantum simulation works the same way. You construct a Hamiltonian, an energy description of a system, that matches the chemistry or materials problem you actually care about. You let it evolve. You measure the result. There's no line-by-line calculation of a molecule's binding energy happening inside the machine. There's a physical process standing in for the answer, the same trick the analogue engineers were running with capacitors and op-amps.
This is a genuine trade-off, and worth naming plainly: you gain access to problems that are effectively unsolvable by direct calculation, at the cost of losing the auditability of a step-by-step digital trace. You can't inspect "line 47" of a quantum simulation. You can only prepare, evolve, and measure.
Noise was always the enemy
Analogue computers had a reputation problem: component drift, temperature sensitivity, electrical noise bleeding into the signal. A circuit calibrated on Monday might read differently by Friday. Precision was never guaranteed, it was maintained, constantly, against physics trying to degrade it.
Quantum hardware has inherited this exact fight under a new vocabulary: decoherence, gate errors. A qubit that behaved perfectly in isolation starts leaking its state the moment it touches the environment, or another qubit, or a stray photon. Quantum error correction exists because of this, and it's arguably a harder problem than anything classical digital error correction ever faced, because you can't simply copy a quantum state to check it against itself. Measuring it collapses the very thing you're trying to protect.
The parallel here is structural, not decorative. Both paradigms trade the clean guarantees of discreteness for direct access to physical behaviour, and both pay for that access in fragility.
Where the analogy runs out
I'd be doing the topic a disservice if I stopped there. Quantum computing is not simply "analogue, but weirder." Superposition combined with entanglement gives access to a state space that grows exponentially with the number of qubits. There's no analogue equivalent to that scaling, not in any circuit built from resistors and capacitors. And a large share of quantum computing is explicitly digital in its architecture, built from gate-based circuits and discrete logical operations, compiled into instruction sequences that look, on paper, a lot like the assembly code from a conventional machine.
So the honest position sits between the two extremes. Quantum computers run on continuous physical evolution, the way analogue machines did. But they carry a discrete logical layer bolted on top, imposed by the gate model, by error correction schemes, by the entire software stack built to make the hardware programmable.
The dials and gauges are long gone, but the underlying commitment, that a well-chosen physical process can compute an answer faster than an explicit algorithm can derive it, never actually left. It just went quantum.