Ethereum & the World Computer
Chapter 5 was entirely about Bitcoin as digital money. This chapter turns to Ethereum — a blockchain built for a genuinely different purpose. Where Bitcoin is deliberately narrow (a ledger for tracking who owns what bitcoin), Ethereum was designed from the start as a general-purpose, programmable platform — often nicknamed "the world computer." This chapter introduces the design differences that made that possible; the full mechanics of writing and running smart contracts are Course 2's own territory.
Ethereum's Real Origin
The Account Model: A Genuinely Different Design From Bitcoin
Chapter 5 covered Bitcoin's UTXO model in detail — ownership tracked as a scattered collection of discrete, unspent transaction outputs. Ethereum deliberately chose a different approach: a straightforward account-based model, much closer to a bank balance, with two distinct kinds of accounts:
- Externally Owned Accounts (EOAs) — controlled by a private key, exactly like a Bitcoin address (Chapter 2's public/private key pairs apply here too). A person or organization directly controls one of these.
- Contract Accounts — controlled not by a private key at all, but by code. This is a genuinely new category Bitcoin's own design doesn't really have an equivalent for, and it's the whole basis of everything the rest of this chapter covers.
Both account types have an address and can hold a balance of ETH (Ethereum's native currency), but only a Contract Account can also hold and run its own program.
| Bitcoin (UTXO) | Ethereum (account-based) | |
|---|---|---|
| What's tracked | Discrete unspent "coin" objects | A running balance per account, plus optional stored code and data |
| Controlled by | Whoever holds the private key for a given output | Either a private key (EOA) or autonomous code (Contract Account) |
| Real purpose | Tracking ownership of a currency | Running arbitrary, general-purpose programs alongside a currency |
Smart Contracts: An Idea Older Than Blockchain Itself
It's genuinely worth knowing that the term "smart contract" wasn't invented by Ethereum, or even by blockchain technology generally. Computer scientist and legal scholar Nick Szabo introduced the term by 1996 — roughly two decades before Ethereum existed — describing a contract enforced through mechanical or software means rather than a legal system alone, and famously illustrated it with the humble vending machine: a physical mechanism that automatically enforces its own terms (insert enough money, receive the item, no human clerk required to adjudicate the exchange).
A smart contract, as run on Ethereum, is a program stored inside a Contract Account that automatically executes exactly as written whenever it's called — enforcing an agreement's terms in code rather than relying on a court, a company, or any other trusted party to interpret and carry it out. This is the direct blockchain-era realization of Szabo's original, much older idea.
The DAO Hack: A Real, Documented Test of "Immutable"
Chapter 3 established that a blockchain's history is tamper-evident — altering the past means redoing an enormous amount of proof-of-work. In 2016, Ethereum faced a real, well-documented event that tested exactly how absolute that immutability really is in practice, not just in theory.
"The DAO" (Decentralized Autonomous Organization) was a smart contract built on Ethereum that raised roughly $150 million worth of ETH from thousands of participants in a crowdsale — a huge sum, and a real, early demonstration of what smart contracts could coordinate at scale. In June 2016, an attacker exploited a genuine flaw in the DAO's own contract code to drain approximately $50 million worth of ETH into a separate account.
This forced a real, contentious debate across the whole Ethereum community: leave the chain exactly as it was, accepting the theft as a permanent, immutable fact (however unfair it felt), or deliberately execute a hard fork — a coordinated, one-time rule change — to effectively reverse the theft and return the stolen funds. The community chose to fork. The result: the chain split into two.
Another Real Design Difference: No Fixed Supply Cap
Unlike Bitcoin's hard 21 million cap from Chapter 5, Ethereum has no fixed maximum supply of ETH built into its protocol. Its monetary policy has itself changed over time (including adjustments made alongside the real 2022 Merge to proof-of-stake covered in Chapter 4) — a real, ongoing design difference worth knowing about rather than assuming every blockchain necessarily follows Bitcoin's own fixed-supply model.
Hands-On Exercises
Three exercises reinforcing Ethereum's account model, smart contracts, and the real DAO fork, before Chapter 7 turns to wallets and how a real transaction is actually put together and signed.
Quick Reference
- Ethereum — proposed by Vitalik Buterin in a late-2013 whitepaper, publicly announced January 2014, launched 30 July 2015.
- Account model — Externally Owned Accounts (private-key controlled) and Contract Accounts (code controlled); a genuine departure from Bitcoin's UTXO model.
- Smart contract — a program stored in a Contract Account that automatically executes as written; the term predates blockchain, coined by Nick Szabo by 1996.
- EVM / Solidity / gas — the execution environment, primary language, and per-operation fee for running contract code; full depth in Course 2.
- The DAO hack — a real June 2016 exploit draining ~$50 million from a $150 million smart contract, resolved by a contentious hard fork that split the chain into Ethereum (ETH) and Ethereum Classic (ETC).
- No fixed ETH cap — unlike Bitcoin's 21 million cap, Ethereum has no hard-coded maximum supply.