the second hundred · metaphor 161
Is there a test — a reference call, a personality read, a gut check at the door — that tells you in advance how someone will actually behave? Not really. There is no shortcut for character. You can only let them act, and watch what comes out.
We badly want the test to exist. A question that reveals the liar, a résumé line that predicts the flake, a first impression that settles it. So we read surfaces — the confident handshake, the tidy CV, the right words in the interview — and we treat the surface as if it were the substance. It almost never is. The kindest-seeming can be cruel in private; the awkward one turns out to be the one who stays. The words a person is made of are not the same as what those words do.
Computer science proved a sharp version of this about programs, and it reaches further than code. Rice's theorem says: for any real question about what a program actually does — not how it's written, but its behavior — there is no general algorithm that answers it by inspection. No universal test. The only fully reliable handle on behavior is to run the thing and see. And even then, what you've seen is only what you've seen so far.
Honest scope: this is a live illustration, not a browser proof. The programs really run (every cell is a computed output); the "surface verdict" is a genuine syntactic heuristic — it flags anything with a nonzero digit in its source. The point it makes is real: no reading of the text is reliable, and no finite run is conclusive. The impossibility itself is proved by the reduction sketched below, not by this widget.
Syntax is not semantics
Two of those programs are the zero function in disguise — they churn through arithmetic and always land on nothing. One of them, busy-zero, computes 3×n − 3×n: full of activity, a nonzero digit right there in the source, and yet its output is zero forever. The surface check sees the 3 and convicts it. Meanwhile count — the plain program output n — has no suspicious digit at all, so the surface check acquits it as harmless, and it is wrong the very first time n isn't zero.
This is the crux. A program's text and a program's behavior are different objects, and no amount of staring at the first bridges to the second. You can rewrite the zero function ten thousand ways so it looks like anything you please; you can dress up a wild function to look tame. Any test that reads the source is testing the costume. The behavior lives somewhere the costume can't reach — in what happens when it runs.
What to try
Select wait-7 with the budget low — say K = 4. Run it: every output is zero, the running verdict glows green, "looks like the zero function." Now push the budget past 7 and run again: at n = 7 a red cell appears and the verdict flips. The program didn't change. Your window did. Everything you concluded from the short look was true and useless.
Then try wait-800. It outputs zero for the first eight hundred inputs — further than the budget can reach. No matter how long you watch, it agrees with the zero function the whole time, and it is not the zero function. This is the theorem made tangible: whatever finite patience you bring, a program can be built to behave impeccably right up to the edge of it and betray you one step past. The good behavior you observed was real. It was also never a guarantee.
Why no universal test can exist
You might still hope for something cleverer than running — a static analyzer that, without executing anything, decides whether a program has some behavioral property. Rice's theorem says that for any nontrivial property of behavior, no such analyzer exists. Here is the shape of the proof, reducing it to the already-known impossibility of the halting problem:
Suppose an analyzer Z(P) could decide, for any program P, whether P computes the zero function — purely by inspection, always halting with a yes or no. (Zero-ness is nontrivial: some programs have it, some don't.)
Take any program M and any input w, the raw material of the halting problem. Build a new program P: "first run M on w; only if that finishes, output 0 forever." P is the zero function exactly when M halts on w.
Now feed P to our supposed analyzer. If Z(P) says "yes, zero function," then M halts on w. If it says "no," then M never halts. We have decided halting — by inspection, without running.
But halting is provably undecidable. So Z cannot exist. And nothing about "zero function" was special — swap in any nontrivial property of behavior and the same trap springs. No general test for any real property of what a program does. Only running, and watching.
The mapping
Swap "program" for "person" and "behavior" for "character," and the theorem reads like hard-won folk wisdom. You cannot read conduct off appearance. The résumé, the charm, the confident story are the source code — the costume — and the thing you actually need to know is what this person does under load, over time, when it costs them. That is the behavior, and it is a different object from the presentation, no matter how carefully you inspect the presentation.
So the only real handle is to run them and see — a trial, a small responsibility, a low-stakes collaboration before a high-stakes one. And Rice's second, colder lesson: even running is never conclusive. The colleague reliable for two years can defect in the third; the wait-800 pattern is a marriage that works until the one pressure it was never tested against. Good conduct observed is evidence, not proof. You extend trust anyway — but you extend it knowing it is a bet, priced by how much you have watched, never certified by a test that doesn't exist.
Read as life lessons
A vibe, a first impression, a polished bio are all reads of the source, not the conduct. They can be authored to say anything. Useful as a prior; worthless as a verdict.
Since running is the only handle, make it affordable. Small, reversible tests before large irreversible ones — a project before a partnership, a weekend before a lease.
No length of good behavior certifies the next. What watching buys you is a better estimate, never a guarantee. Extend trust as a bet sized to the evidence — and stay watchable yourself.
The mapping, exactly
| Mathematics | Life |
|---|---|
| a program's source | Someone's résumé, reputation, manner, story — the readable surface they present. |
| a program's behavior | What they actually do under real conditions over time — the thing you truly need to know. |
| nontrivial semantic property | Any real question of character: are they honest, reliable, kind when it costs them? |
| no decider by inspection | No interview, test, or gut read reliably settles the question from the surface alone. |
| running the program | Giving them a role, a trial, time — letting them act so you can watch the fruits. |
| the wait-800 trap | Good behavior that holds until the one situation it was never tested against. |
Where the metaphor tears
Rice's theorem forbids a general test that works for every program. It says nothing against tests that work well for most people you'll meet. In practice, references, track records, and structured interviews carry real signal — they just can't be perfect and can't cover the adversarial case built to beat them. Reading the theorem as "character is unknowable" over-claims wildly; the honest reading is "no method is foolproof, especially against someone trying to fool it."
A program's behavior is settled the moment it's written; a person's is not. People grow, break, reform, and respond to how they're treated — the wait-800 who defects might have held forever under different conditions. So "run them and see" observes a moving target, and past fruits predict future ones only as far as the person stays the same person. The metaphor models the limits of testing, not a fatalism about who someone must remain.
The theorem is exact about computable functions and total inspection. Human judgment runs on thick context the theorem ignores — bodies, tone, shared history, the thousand tells of a face. That context genuinely narrows the space, which is why we are not helpless at reading each other. The lesson to keep is the direction of the arrow: watch conduct over surface, and price your certainty honestly. The theorem sharpens that instinct; it doesn't replace it.