showstack

The object itself

A neural network is a learned function

Take some numbers in. Multiply each by a weight and add them up. Bend the result — pass it through a simple non-linear function, which is what stops the whole stack collapsing back into one multiplication. Do that again, in layers, and read the numbers at the far end.

That is a neural network. There is no reasoning module, no store of facts, no rulebook. The only thing that distinguishes a useful one from noise is the values of the weights, and those were not written by anybody. They were found.

This matters more than it sounds. A model does not contain knowledge in a form you can inspect or edit. It contains a very large number of numbers that, together, implement a mapping from inputs to outputs. That is why you cannot open one up and correct a fact, and why "why did it do that" is a genuinely hard research question rather than a lookup.

The distinction that clears up most confusion

Training and inference are different jobs

Training is the search for the weights. Show the network an example, compare its output to the right answer, calculate how much each individual weight contributed to the error, and nudge all of them slightly in the direction that reduces it. Repeat across an enormous number of examples. It takes vast compute, it happens once, and it happens somewhere else.

Inference is running the finished function forwards on new input. It is comparatively cheap — cheap enough to run on a laptop, a phone, or a machine in a rack backstage.

Nearly every practical question resolves once you know which one is being discussed. "Does it need the internet?" — inference often does not. "Does it learn from what I give it?" — not during inference; that is a separate training run somebody else decided to do. "Why is it slow?" — inference cost scales with model size and, for generative models, with how many steps you asked for.

Images

Why a generator starts from pure noise

A diffusion model is trained on a strange task: given an image with a known amount of noise added, predict the noise. Do that well enough, across every level from barely-speckled to completely random, and you have a model that can remove a little noise from anything.

Generation runs that backwards. Start with a field of pure random noise. Ask the model what noise it sees, remove a fraction of it, and look again. Repeat twenty or fifty times. Each step the image becomes slightly more like something the model considers plausible, and after enough steps you are left with a picture that was never in the training data but sits comfortably inside the distribution of things that were.

The text prompt steers it. The words are turned into a vector by a text encoder trained to place descriptions and images near each other, and that vector biases every denoising step toward the region of the space that matches. It does not fetch anything. It bends the path.

Two consequences fall straight out. The same prompt with the same starting noise — the seed — gives the same image every time, because nothing about the process is actually random after that first field. And the model has no model of the world: hands come out wrong not because hands are hard to draw but because nothing in the process counts fingers.

Language

A model that only ever predicts the next token

A language model is trained on one task: given a run of text, predict what comes next. Not the answer, not the meaning — the next token, which is a word or a fragment of one. It outputs a probability for every token it knows.

To produce a sentence it picks one, appends it, and asks again. Everything a language model appears to do — answering, summarising, translating, writing code — is that loop, run repeatedly, on a model whose weights encode an extraordinary amount of structure about how text goes together.

Temperature controls how the pick is made. Low temperature takes the most probable token nearly every time: consistent, predictable, and dull. Raise it and the distribution is flattened, so less likely tokens get a real chance: more varied, and more likely to wander somewhere untrue.

This also explains the failure everybody has met. A model has no separate sense of whether it knows something. A confident false statement and a confident true one are produced by the same process, with the same fluency, because fluency is what was optimised. The tone of the output carries no information about its reliability, and reading it as if it did is the mistake.

What inference actually costs you

Two numbers decide whether a generative step fits into a working session: how many denoising steps you asked for, and how fast each one is on the machine you have.

On a show

Where it earns its place, and where it does not

The question people always ask next

What quantum computing actually changes

It is worth being precise here, because the popular description is wrong in a specific and misleading way.

A quantum computer does not try every answer at once and pick the right one. A qubit can be in a superposition of states, and a register of them can represent an enormous number of combinations simultaneously — but reading it out collapses the whole thing to a single value, and by default that value is random and useless.

The actual skill is interference. A quantum algorithm has to be constructed so that the paths leading to wrong answers cancel each other out and the paths leading to right ones reinforce, so that when you finally measure, the answer you want is overwhelmingly the likely one. Only a small number of problems have a known structure that allows this, and building a new one is a research achievement rather than a programming task.

Shor's algorithm factors large numbers efficiently, which breaks RSA and elliptic-curve cryptography — the mathematics under essentially all of today's secure connections. Grover's algorithm gives a quadratic speedup on unstructured search, which effectively halves the strength of a symmetric key. Those are the two that matter.

Where it is today: machines exist, they are noisy, and error correction costs an enormous ratio of physical qubits to each reliable logical one. Nobody is close to running Shor's at a useful scale.

So what does it mean for you

For processing: nothing, for the foreseeable future. It will not render frames faster, mix audio, drive fixtures or run a show network. Those are not problems with the mathematical structure quantum algorithms exploit, and a GPU is a far better answer to all of them.

For security: something real, and already. The concern is harvest now, decrypt later — an adversary recording encrypted traffic today and decrypting it once a capable machine exists. That is why NIST standardised post-quantum algorithms in 2024 and why browsers, VPNs and messaging systems have begun switching. It is a supply-chain and vendor question, not a show-floor one, and it is the one place your industry will actually encounter this.

The realistic near-term uses are simulation of quantum systems themselves — chemistry and materials — and specific optimisation research. If a vendor tells you a quantum computer is improving your media server, that is marketing.

Keeping it in its place

A tool, aimed at a person

Everything on this page is a machine doing a version of something the previous stage describes a person doing: taking in a signal, finding structure, deciding what it means. A network of weights is a crude imitation of a network of neurons, and a very good one for narrow jobs.

What none of it does is care what the show is for. It has no audience, no intent, no sense of a room going quiet. It produces material; a person decides whether the material is any good and whether it belongs.

That is not a limitation to be engineered away in the next release. It is what the tool is — and treating it that way is what makes it genuinely useful rather than either frightening or oversold.