English static mirror for SEO/GEO · AI-assisted translation · Read Chinese original

Circuits, Pulses, and the Assembly Age: The Quantum Programming Model

Forum topic · 小凯 · 2026-11-07

Summary

This article from the "From Coins to Error Correction" quantum computing column (Part 076) argues that quantum programming today sits in an era analogous to classical computing's assembly-language age, structured as two layers of "assembly": the circuit layer (structured assembly—sequences of gates tightly coupled to hardware) and the pulse layer (machine-specific dialects, where the same gate uses different microwave waveforms on different devices or qubits), joined by a continuously updated calibration table. It explains why high-level quantum languages cannot yet be built, citing three missing foundations: the no-cloning theorem undermines the variable concept, noisy operations break the assumption of faithful instruction execution until fault tolerance arrives, and destructive measurement eliminates non-invasive debugging. The author describes the current workflow—build circuits, compile, submit, apply readout correction, tune against noise—likened to designing delivery routes for fragile goods, with gate-depth budget as the fuel gauge. The outlook ties future quantum high-level languages to logical qubits and error correction, while noting that 1950s classical programmers likewise wrote the first compilers in assembly.

> Prerequisite navigation: You need Part 075 (call stack), 024 (circuit diagrams), 023 (universal gate set), 061 (microwave pulses), 051 (noise list). > Next up: Part 077, "Fitting a Billion Gates into Real Hardware: Compilation Optimization."

Circuits, Pulses, and the Assembly Age: The Quantum Programming Model

How did the earliest programmers write programs? Flip switches, plug cables—a "program" was a board full of wires. Later came machine instructions, then assembly, then high-level languages—today, one line of code you write rests on hundreds of millions of lines of infrastructure underneath.

Where does quantum programming stand? The plugboard era is long gone (the kind where you literally wired up a chip), but the high-level-language era hasn't arrived—quantum programming as a whole is stuck in the "assembly age." This post explains exactly what abstraction levels quantum programmers work at today, and why a high-level language still can't be built.

The Current Map: Two Layers of "Assembly"

Quantum programming today is actually split into two layers:

The circuit layer—"structured assembly." This is what Part 024's circuit diagram is: a sequence of gates plus measurement. Today's quantum frameworks (Python-based, covered in Part 080) are essentially circuit builders—you write code, and they assemble the circuit diagram for you. We call this "assembly" rather than a "high-level language" because it hugs the hardware: every gate is a direct instruction for a physical action, with no deeper layer of semantics shielding you from it.

The pulse layer—machine-specific dialect. One level down, as Part 061 explained: every gate is physically a nanosecond-scale microwave waveform. The same H gate uses a different waveform on different machines—even on different qubits of the same machine. Pulses are the device's dialect. Ordinary users never see this layer (the framework calibrates it for you), but it genuinely exists, and both Part 077's compilation discussion and Part 097's hands-on work will step into it.

Between the two layers sits a calibration table: the current pulse parameters for every gate on every machine, updated daily—the machine's "health report," a living document in the programming model.

Why a "High-Level Language" Still Can't Be Built

The essence of a high-level language is forgetting the底层 for you—variables, functions, objects; every abstraction spares you one layer of thinking. The quantum world can't build these abstractions because three foundations are missing:

1. No memory model. Classical abstractions (assignment, parameter passing, caching) all rest on one premise: information can be copied. Part 028 legislated that unknown quantum states cannot be cloned—the foundation of the very concept of a "variable" is gone. 2. No reliable operations. Classical languages assume "instructions execute faithfully"; today's quantum machines error constantly (see Part 051's list), and noise lives beneath every layer of abstraction—until the fault-tolerant era arrives (Batch 6), abstractions dare not stand. 3. Readout is destructive. In classical programs, "reading a variable" is casual and lossless; quantum measurement is a one-way door (Part 002)—"take a peek whenever you want," the programmer's basic debugging move, simply doesn't exist in the quantum world.

In one sentence: the value of a classical abstraction is that leaks don't matter; a quantum abstraction's leaks are errors—noise seeps up through every crack, so today's quantum programmers dare not forget any layer.

The Realistic Day-to-Day Workflow (as of 2026-11)

Putting the two layers together gives you a day in the life of a quantum software engineer:

Write circuits (the framework's circuit builder) → Compile (Part 077: adapt to machine topology, optimize gate count) → Submit (the five-layer stack from Part 075) → Readout correction (Part 096: the readout itself lies) → Tune circuits against noise.

The accurate picture of this daily work isn't "writing code"—it's "designing delivery routes for fragile goods": every gate is one handling step, fewer handlings is better, and you need to know how bumpy every route is (the noise)—Part 050's "gate-depth budget" is the fuel gauge on that route map.

Where's the Exit from the Assembly Age?

An honest outlook: when will there be a "quantum high-level language"? Industry consensus points to following error correction—once Batch 6's logical qubits become reliable, the foundation of "trustworthy computation" exists, and abstractions can dare to be built on top. A middle path (compiler-style quantum intermediate representations, previewed in Part 077) is being paved.

A final word of defense, so "assembly age" doesn't sound like an insult: the classical programmers of the 1950s wrote the first compilers in assembly. Today's quantum programmers are doing the same thing—forging the next generation of tools by hand, in the roughest tools available. In Parts 091–100 (the hands-on workshop), you'll get to touch this "assembly" yourself.

Taking the Analogy Apart

What the language history borrowed—and where it breaks:

  • Disanalogy #1: Classical machine instructions execute faithfully—the same program run ten thousand times gives the same result; quantum pulses drift (Part 067's one-in-a-thousand drift)—the same program run twice can give different results. "Missing determinism" is an opponent classical language history never faced.
  • Disanalogy #2: When classical abstractions leak, it's usually a performance problem (costs some extra time); when quantum abstractions leak, it's a correctness problem (the answer is void)—the line between daring and not daring to build abstraction layers is drawn here.

What to Take Away

1. Two layers of assembly: the circuit layer (structured assembly—gate sequences hugging the hardware) and the pulse layer (machine dialect—the same gate, different waves on each machine), sandwiched around a calibration table updated daily. 2. Three missing foundations of high-level languages: no-cloning (variables have no foundation), unreliable operations (abstractions leak noise), destructive readout (debugging is a one-way door)—whether abstractions dare to stand follows fault tolerance. 3. Daily work = designing delivery routes (2026-11 view): write circuits → compile → submit → readout correction; the gate-depth budget is the fuel gauge—the assembly age isn't an insult; it's the same situation as the classical programmers of the 1950s.

Hook for the next stop: the circuit is written and needs to run on real hardware—but real gates are outrageously expensive and the connectivity is incomplete. How do you fit an algorithm of "a billion gates" into a machine with "a few thousand gates"? The three-tier martial arts of compilation optimization. Part 077: "Fitting a Billion Gates into Real Hardware: Compilation Optimization."

*Original hashtags: quantum computing, From Coins to Error Correction, programming models, quantum software.*

Tags

#quantum-computing#programming-models#quantum-circuits#pulse-control#assembly-language#compilers#error-correction#quantum-software

This page is an English static mirror generated for search and AI citation. It may be a full translation or structured summary of the Chinese original. Canonical interactive discussion lives on the Chinese page: https://zhichai.net/topic/178636910