The Pub-Time Parliament
Imagine a busy pub on a Friday night. It’s crowded, loud, and everyone is talking at the same time. Some people are sober, some are tipsy, and my mate Stevo has already fallen off his barstool.
Now imagine trying to get this crowd to agree on something simple — say which football team is worst this week.
Surprisingly, this is a pretty good model for distributed systems.
Getting computers to agree on something should be easy. In reality, machines crash, networks drop messages, clocks drift, and nodes confidently insist they’re right even when they’re not. Yet somehow we still manage to build reliable systems on top of this unreliable mess.
Key Takeaways
- Why agreement in distributed systems is fundamentally difficult
- The strengths and limitations of Two-Phase Commit, Paxos, and Raft
- Why simplicity and human comprehension matter in protocol design
- How RIOT aims to combine Raft-like safety with improved scalability
Who Is This For
- Software engineers working with distributed systems
- Architects designing data-intensive systems
- Anyone curious how consensus algorithms actually work in practice
Level
Practitioner → Advanced
What This Session Covers
Distributed systems rely on consensus protocols to ensure correctness despite failure.
In this talk we revisit classic approaches such as Two-Phase Commit, Paxos, and Raft, exploring the trade-offs they make between correctness, fault tolerance, and scalability.
Along the way we’ll look at why some algorithms succeed in theory but prove difficult to implement in practice, and why protocols designed for human understanding often outperform theoretically elegant alternatives.
Finally, we’ll look at RIOT, a newer consensus approach designed to retain the simplicity and safety of Raft while improving scalability.
Talk style
- Conceptual explanations of consensus algorithms
- Architecture diagrams and system design examples
- Practical lessons from real distributed database systems
Full Description
Imagine a busy pub on a Friday night. It's crowded, lots of people are talking at the same time. They're all exchanging information with each other which makes tiny changes in their brains. Some folks are taking it easy on the drink, a few are a bit tipsy after one too many beers, and my mate Stevo is plastered, falling off his barstool. Classic Stevo. Now imagine trying to get this crowd to agree on something when they can't even agree on which footy team is the worst this week and some of them can't remember their own names.
In comparison you'd think that getting a bunch of computers to agree on something, say a simple number would be pretty easy. Computers can do way smarter things than agreeing upon a number, right? Sadly not. Computers are often in various states of being wrong or crashing. Much like a bunch of drunks they all want to talk at the same time, and they're confident they have the best opinion.
How have we have built such incredible systems on such a flakey foundation? In this talk we will visit classic consensus algorithms and see how they provide benefits of correctness and fault-tolerance for systems but at the price of reduced scalability. Then we'll explore some new research which aims to provide both correctness and scalability for distributed systems. The talk will be interactive - you may need a drink yourself afterwards.
