Crypto Ch2: Programmable Blockchains

Chapter 2. Ethereum: Why programmable blockchains emerged

2.1 Why Bitcoin was not enough

Bitcoin can express spending conditions, but it is not designed to support rich, persistent, general-purpose application logic.

Ethereum extends the idea of blockchain from a settlement ledger to a shared programmable state machine.

Where Bitcoin asks, “How do we securely transfer value without a central administrator?”, Ethereum also asks, “How do we allow arbitrary shared programs to execute in a globally agreed environment?”

2.2 The big shift

Bitcoin focuses on value transfer. Ethereum adds the ability to deploy programs that everyone can execute and agree on.

This creates a new abstraction:

• A blockchain is not only a ledger
• It can also be a shared execution platform

That shift is foundational. In Ethereum, transactions do not merely move assets. They can also trigger code execution and state transitions inside contracts.

2.3 Account model

Ethereum uses an account-based model, not UTXOs.

An Ethereum account can contain:

• Balance
• Nonce
• Code (if it is a contract)
• Storage

This makes Ethereum more natural for applications with rich state because smart contracts often need long-lived internal variables, mappings, and logic branches.

2.4 Two account types

Externally Owned Accounts (EOAs)

• Controlled by private keys
• Used by users to initiate transactions

Contract Accounts

• Controlled by code
• Contain logic and persistent storage
• Execute when called

The distinction matters because EOAs create transactions, but contracts execute logic when called and may call other contracts in turn.

2.5 What it means to deploy a contract

Deploying a smart contract is simply sending a special transaction that contains compiled bytecode. The network executes it and creates a new contract account.

So “publishing code on-chain” means:

• Write source code
• Compile it to bytecode
• Send a contract-creation transaction
• The contract receives its own on-chain address

A useful framing is that a contract is not just “stored code.” It is code plus state plus a stable addressable interface on the chain.

2.6 What it means to call a contract

A user or another contract sends a transaction or call to that contract address, supplying input data that identifies the function and parameters.

A call can:

• Read state
• Change balances
• Update storage
• Emit logs
• Trigger other contract calls

This is why Ethereum applications can look like programmable financial systems rather than mere token ledgers.

2.7 Why Ethereum needs a VM

All nodes must reach the same result when executing the same transaction on the same prior state. That requires a constrained, deterministic execution environment.

This is the role of the EVM (Ethereum Virtual Machine).

A normal backend program can freely use local clocks, random sources, external APIs, operating system behavior, and files. Consensus execution cannot. It must be deterministic across thousands of machines.

2.8 Why gas exists

If arbitrary programs were free to run on-chain, users could exploit the system with endless computation and state bloat.

Gas is the resource metering unit for execution.

You can think of it as a way to price:

• Computation
• Storage access
• State modification

The fee paid is the monetary cost of the gas consumed.

So:

• Gas = resource units
• Gas fee = $\text{gas used} \times \text{gas price}$

Gas exists both as an anti-spam mechanism and as a way to ration scarce shared execution resources.

2.9 Why smart contracts are different from normal backend services

Smart contracts differ from ordinary backend systems in several ways:

• They are executed by a network, not by one operator’s server
• State changes must follow protocol rules, not admin commands
• Code is hard to change after deployment
• Resource use is explicitly priced
• Outputs are transparent and auditable
• Trust shifts from institutions toward code, governance, and protocol design

One of the most important consequences is that mistakes are structurally harder to patch. Smart contract design must think much more about immutability, upgrade paths, admin privileges, and failure modes.

2.10 Upgrades and immutability

Deployed contract code is typically not edited in place. In practice, systems that want upgradeability often use proxy architectures or migration patterns.

That means a key distinction in Ethereum is:

• Immutable code as a security ideal
• Upgradeable systems as a product reality

This introduces governance and admin risk even in systems that market themselves as decentralized.

2.11 What Ethereum made possible

Ethereum’s architecture made it possible to build:

• DeFi
• NFTs
• DAOs
• Token systems
• Rollups and L2 ecosystems

This happened because Ethereum put assets, state, execution, and composability inside one common environment.

Key takeaway

Ethereum turns blockchain into a programmable shared state machine, enabling applications whose rules are encoded and executed in a common settlement environment.

— Mar 21, 2026

Crypto Ch2: Programmable Blockchains by Lu Meng is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License. Permissions beyond the scope of this license may be available at About.