Decentralized Systems

You learn three words that are often mixed up and the real differences between them. You leave able to look at any system and describe who controls it, where it runs and what happens when a part fails.

You learn why many cooperating computers are harder to build than one, and you meet the three problems behind it: delay, failure and disagreement. You finish with the CAP theorem and eventual consistency, the two ideas that explain most design choices in later weeks.

You learn how computers with equal roles find each other and share work without a central server. You study BitTorrent, distributed hash tables, gossip and the NAT problem, and you build a tiny gossip simulation.

You learn how a group of computers can agree on one value when some of them crash or lie. You study the idea of consensus, Paxos and Raft at an intro level, and the Byzantine generals problem.

You learn to name data by what it contains instead of where it lives, and you see how that one idea powers Git, IPFS, Filecoin and Arweave. You build a small content-addressed store and a Merkle tree in Python.

You learn how a key pair works as an identity, how decentralized identifiers and verifiable credentials build on it, and how passkeys bring the same idea to everyday logins. You also weigh the real costs of self-sovereign identity.

You learn how a person can prove a fact without revealing the data behind it. You also see how these ideas make private voting possible on public networks.

You learn what a decentralized autonomous organization is, how it makes decisions with votes and delegation, and how it manages shared funds. You also study the common ways DAO governance fails so you can design around them.

You learn how to design rules so that self-interested people produce good group outcomes. You study Sybil resistance, quadratic voting and funding, conviction voting, futarchy, and cosmo-local ideas.

You learn how separate systems exchange data and messages: oracles bring outside facts onto chains, cross-chain messaging links networks, and federated protocols connect social servers. You also see why local-first software keeps data with its owner.

You study decentralized communities as human institutions: network states and pop-up cities, cooperatives, and the commons governance work of Elinor Ostrom. You finish with a practical guide to running a decentralized community responsibly.

You combine the course into one project: a design for a decentralized application or a community protocol, presented with a demo and reviewed by peers. You practice scoping, documenting trust assumptions, and giving useful feedback.