A world computer
Ethereum is a decentralized computing network. Thousands of independent nodes run identical software, execute the same transactions, and agree on a shared ledger. Anyone can deploy programs called smart contracts that run the same way everywhere — there is no central server to shut down or a single company that controls the rules.
- Bitcoin stores value; Ethereum stores value and runs arbitrary logic on top of it.
- Smart contracts are programs deployed at an address — they hold ETH, tokens, and state.
- Every node re-executes every transaction to verify correctness; trust comes from cryptography and consensus, not reputation.
Accounts and transactions
Every action on Ethereum is a transaction signed by an account. Externally owned accounts (EOAs) are controlled by a private key — your wallet. Contract accounts are controlled by their code. Transactions cost gas, paid in ETH, and are included in blocks roughly every 12 seconds on mainnet.
- EOAs initiate transactions; contracts can only react when called.
- A transaction carries a nonce, gas limit, gas price (or EIP-1559 fee fields), value in wei, and optional calldata.
- Failed transactions still consume gas — the EVM ran your code until it reverted.
// A minimal contract stores a greeting anyone can read
import "@openzeppelin/contracts/access/Ownable.sol";
contract Greeter is Ownable {
string public greeting;
constructor(string memory initialGreeting, address initialOwner)
Ownable(initialOwner)
{
greeting = initialGreeting;
}
function setGreeting(string memory newGreeting) external onlyOwner {
greeting = newGreeting;
}
}The EVM in one paragraph
The Ethereum Virtual Machine is a stack-based interpreter with a fixed instruction set. Solidity compiles to EVM bytecode. Gas meters every opcode so infinite loops cannot stall the network. Storage (SSTORE) is expensive; memory is cheap but ephemeral; calldata is cheapest for read-only inputs.
- 256-bit words: addresses, balances, and arithmetic are uint256 under the hood.
- view / pure functions do not change state — they cost no gas when called off-chain via eth_call.
- Reverts undo all state changes in the current call frame but keep gas spent.
Layers and rollups
Base-layer Ethereum (L1) prioritizes security and decentralization. Rollups (L2s) batch thousands of transactions and post proofs or data back to L1. Users interact on L2 for lower fees; assets can be bridged between layers. The programming model — Solidity, the EVM, OpenZeppelin libraries — is largely the same.
- Optimistic rollups (Optimism, Base) assume validity unless challenged.
- ZK rollups (zkSync, Scroll) post cryptographic proofs of correct execution.
- Contract addresses on L2 differ from L1 — always verify the chain ID.
What people build
Ethereum hosts DeFi protocols, NFT platforms, DAOs, identity systems, and on-chain games. Most production contracts compose audited OpenZeppelin primitives — ERC20 for tokens, Ownable or AccessControl for permissions, Governor for voting — rather than reinventing standards.
- DeFi: swaps, lending, staking, and derivatives without custodians.
- NFTs: unique or semi-fungible assets with on-chain ownership and royalties.
- DAOs: treasuries and parameter changes governed by token holders.
How to learn next
Understand wallets before you hold real funds. Learn gas before you deploy. Read Etherscan before you trust a contract. This learning path walks you through each layer — from safety basics to advanced security patterns.
- Beginner: wallets, gas, Etherscan, nonces.
- Intermediate: token standards, approvals, events, reading Solidity.
- Advanced: proxies, storage, reentrancy, gas optimization, account abstraction.