## Every Digital System Is a Computer With State YouTube, Instagram, your bank, WhatsApp, an online store — they look nothing alike, but underneath they are all the exact same machine: a **computer holding data**, plus **rules** for how that data changes when you act. That stored data is called **state**. A like adds one to a counter. A payment moves a number between two rows. A message appends a line to a log. Every digital system you have ever used is a live *rendering* of some state, and every tap you make is a request to change it. <viz id="1"></viz> **Switch the app** between the social feed, the bank, and the chat — then **press the action button** (or click a post, your account card, or the compose box) to like, pay, or send. Watch the pulse land in the table on the right: every action becomes a row changing. **Flip "show state" off** to feel how apps normally hide this from you — then flip it back on. Different pixels, same machine. The feed, the bank, and the chat all reduced to the same picture: a **table of state**, mutated by your actions through the app's rules. Notice the bank especially — "sending money" was nothing more than two cells changing at once. Once you see apps this way, one question matters more than any feature: *who holds that table, and who is allowed to change it?* On the next slide, you become that person. ## The Company Holds the Admin Key In <ref slide="1">Every Digital System Is a Computer With State</ref> you watched your actions change the state table. But that table doesn't live in your pocket — it lives on the **company's computer**. And the app's rules only bind *users*. Whoever owns the computer doesn't go through the app at all: they hold the **admin key**, and with it they can edit the table **directly** — any row, any value, no rule check, no permission asked. You've felt this as a user. Now feel it from the other side. <viz id="2"></viz> **Pick a target**, then use the admin key: **drag the likes slider** to hand them thirty thousand likes, **delete their post**, or **ban them** outright — and watch each edit land in their app instantly, stamped with the one fact that matters. Press **Act as user** in between to feel the difference: users go through the rules, the owner strikes the table directly. Notice the two kinds of arrows. The user's like travelled *through the app* — checked by rules. Your admin edits **bypassed the app entirely** and rewrote the state itself. That asymmetry is the deal you accept with every account you create: the likes, the posts, the followers are yours in experience, but **theirs in ownership**. To be fair, this power is often *fine* — someone has to remove spam and stop abuse. But hold onto the feeling of watching a number you didn't earn appear under your name, or a post vanish with no appeal. When the state is your money or your voice, "trust the key-holder" starts to feel thin. So here's the question the rest of this lesson answers: *what would a computer with no admin key even look like?* ## A Computer Nobody Can Stop Why does the admin key from <ref slide="2">The Company Holds the Admin Key</ref> work at all? Because the whole app lives on **one party's computer**. One owner means one off-switch: pull the plug, seize the server, delete the database — the state and everyone's access to it dies with it. And the off-switch is only half of it. On a machine you own, you sit **above the software**. The company could promise the fairest rules in the world — but on their own hardware, a rule is just a *setting*, rewritable the moment it becomes inconvenient, silently, with no way for anyone outside to even notice. What we actually want is a computer that **nobody can stop *and* whose rules nobody can change**. A single owner can never give you the second one, because you'd be trusting exactly the person the rules are supposed to bind. So here's the first move toward a computer with no owner — one that attacks *both* problems: **run many copies**. Put machines in different countries, operated by **different, independent people** — each holding a full copy of the state, each serving the same app. And that word *copy* is doing real work: these are not thirty different databases, they are **one state, replicated thirty times**. Every time a user's action changes the state, that change must reach *every* copy, so that all thirty machines keep telling the exact same story. Now "stopping the app" doesn't mean pulling a plug — it means pulling *every* plug, in every country, all at once. And changing the rules is no longer one owner's quiet decision, because no single party's machine sits above the software anymore — the next two slides show how that becomes a hard guarantee. <viz id="3"></viz> Each node's **colour is its copy of the state** — watch a write land and ripple outward until every node flips to the identical new colour. Then **click nodes to unplug them**: requests reroute, and the dead node's colour freezes, stuck with a stale copy. **Press Attack** to knock out a third at once. Finally **drag the node slider down to** `1` and attack again: one plug, dead app. Push it to `30` and try your best to kill it. At one node, you rebuilt the company from <ref slide="1">Every Digital System Is a Computer With State</ref>: a single computer, a single off-switch. At thirty nodes on five continents, there is no switch left to flip — a government can raid a building, a company can shut down a datacenter, and the app doesn't even flicker. **Nobody can stop it.** But notice what kept this working: after every single write, all the copies converged back to the **same identical state** — you watched the colour sweep the map. That only happened because every node honestly followed the same sync rule. Thirty copies are only *one computer* while they agree. So who — or what — **forces** them to agree? When one operator quietly edits *their* copy — gives themselves thirty thousand likes, say — which version is the truth? Unstoppable is only half the problem. The other half is next: <ref slide="4">Rules Replace the Admin</ref>. ## Rules Replace the Admin In <ref slide="3">A Computer Nobody Can Stop</ref> the copies stayed identical because every node honestly relayed every change. But "honestly" is doing a lot of work there — one of those node operators is a person, and their copy sits on *their* machine. What stops them from playing admin on it? Here is the answer, and it's the heart of the whole idea: every node runs the **same software**, and that software contains the **rules** — agreed on by everyone — for what counts as a valid change. The state can move *only* through a transaction that passes those rules, and **every node checks every transaction independently, against its own copy**. There is no referee to convince, and no admin to bribe. The rules don't just bind the users this time — **they bind the operators too**. <viz id="4"></viz> **Send the valid payment** and watch it hop node to node — each copy checks it, stamps it green, and applies it, so all seven ledgers move together. **Send the impossible payment** (500 alice doesn't have) and watch every node independently reject it. Then **press Tamper**: one operator edits her own copy — and the majority overwrites the lie in seconds. Keep sending valid payments until alice runs dry, and watch the "valid" one start bouncing too. Compare this to <ref slide="2">The Company Holds the Admin Key</ref>. There, one keyholder edited the table and the change simply *was* the truth. Here, a tampered copy just makes its node **disagree with the majority** — and the network treats the odd one out as broken and overwrites it. Rewriting history would mean out-shouting most of the network at once, not flipping one switch. That's the trade at the core of a blockchain: you give up the flexibility of a trusted admin, and you get **state that changes by agreed rules or not at all**. One question left, and it's a practical one: these seven operators are burning real electricity to check your payments. Why on earth would they bother? That's <ref slide="5">Why the Machine Pays Its Own Workers</ref>. ## Why the Machine Pays Its Own Workers The seven operators in <ref slide="4">Rules Replace the Admin</ref> are burning real electricity, real hardware, real bandwidth — checking your payments around the clock. A company would put them on payroll. But this computer **has no company**. Nobody owns it, so nobody can pay for it. If running a node costs money and pays nothing, every rational operator walks away — and you're left watching the network from <ref slide="3">A Computer Nobody Can Stop</ref> die node by node, not from attack, but from neglect. So the machine does something remarkable: **it pays its own workers**. The rules that validate payments also *mint* new coins as a **reward** to the nodes doing the work, and every user attaches a small **fee** to their transaction. And here's why it must be a **native cryptocurrency** and not, say, dollars: a bank paying the operators would put the bank's owned computer right back at the centre of the system we built to escape it. The reward money has to live as **state on this very ledger**, governed by the same rules as everything else — money no admin can freeze, mint, or seize, because there is no admin. The fees answer the other half of your question: the computer's capacity is **finite**. If using it were free, it would drown in junk. Charging per use rations a scarce, shared machine. <viz id="5"></viz> Watch the loop run: users attach **fees**, operators earn **fees + minted reward** against their electricity cost. **Turn the block reward off** and watch operators quit one by one until the network is dead — then **raise the fee slider** and watch them come back. Finally **push demand past capacity** and watch the queue grow: this is why using the computer can't be free. You just watched the last piece click into place. The coin isn't a gimmick bolted onto the technology — it **is** the technology: the payroll that keeps an ownerless computer staffed, and the meter that rations its capacity. Step back and look at what this lesson built: apps are **state plus rules** (<ref slide="1">Every Digital System Is a Computer With State</ref>); normally one company owns that state (<ref slide="2">The Company Holds the Admin Key</ref>); so we spread identical copies across the world (<ref slide="3">A Computer Nobody Can Stop</ref>), forced them to agree by rules instead of admins (<ref slide="4">Rules Replace the Admin</ref>), and paid for it all with money native to the machine. That stack has a name: **a blockchain**. One slide left — to see why this isn't just a clever database, but a genuine inversion of how computers have always worked: <ref slide="6">Software Now Commands the Hardware</ref>. ## Software Now Commands the Hardware Every computer ever built had the same chain of command: whoever **owns the hardware** controls the software running on it — and through it, the state. That's why the admin key in <ref slide="2">The Company Holds the Admin Key</ref> was absolute: the company owned the machines, so the company's will *was* the truth. Software was always the servant of whoever held the box. Look carefully at what you built across the last three slides, because it quietly **inverted that chain**. The protocol — the software rules from <ref slide="4">Rules Replace the Admin</ref> — now sits *above* the machines. Thousands of interchangeable computers compete to serve it (<ref slide="3">A Computer Nobody Can Stop</ref>), are paid by it (<ref slide="5">Why the Machine Pays Its Own Workers</ref>), and any machine that disobeys it gets overruled and replaced. For the first time in computing history, **the code is sovereign and the hardware is disposable**. <viz id="6"></viz> **Flip between the two worlds.** In the normal computer, **press Intervene** — the owner's edit becomes the truth — and **press Unplug** — the software dies with its machine. Then switch to the blockchain and press the same two buttons: the edit is overruled, and a fresh machine slides in to replace the unplugged one. Finally, **open the dropdown** and walk through what a sovereign program makes possible. Why is that a revolution? Because a program that no person can stop or rewrite is a new kind of **institution**. Until now, every promise on the internet was really a promise from a company — "your money is safe with us", "your account is yours". Now a promise can be made by *software itself*, and kept even if every original author disappears. That's what the **internet of value** actually means. The internet of information copies things — send a photo and you both have it; fine for information, fatal for money. A sovereign program that follows rules absolutely is the first place value can live *natively* online: sent, not copied, owned by *you* rather than by a platform. Money without banks is only the first application. Savings a government can't quietly inflate away, records no official can erase, identity no platform can revoke, social networks owned by the people who fill them with life, software agents that hold and spend their own money — an application spectrum we've barely begun to explore, open to anyone with an internet connection. **That's why blockchain matters.**