Demonstration on CS Theorems

Mutual Exclusion Without Hardware Support

Fri, 24 Dec 2027 12:00:00 +0100

Symptom

Two threads increment a shared counter a million times each. The final value is 1,374,522.

You know why: the increment is a read, an add, and a write, and the interleavings lose updates. The fix is a lock. But a lock is provided by your runtime, which gets it from the OS, which gets it from a hardware instruction — lock xchg, cmpxchg, ldrex/strex.

Bloom Filters

Fri, 12 Nov 2027 12:00:00 +0100

Symptom

Every request to your service checks whether a user ID exists before doing anything else. The check hits the database. Ninety-eight percent of the time the answer is no, because most of the traffic is bots probing for accounts that were never created.

Consistent Hashing

Fri, 29 Oct 2027 12:00:00 +0100

Symptom

You shard a cache across ten servers with the obvious rule:

server = servers[hash(key) % len(servers)]

It works. Then you add an eleventh server, and % 10 becomes % 11.

Every key now maps somewhere else. Not one tenth of them — essentially all of them. A key landing on the same server after the change is a coincidence with probability about $1/11$, so roughly 91% of your cache is instantly invalid. Every request misses, every miss hits the database, and the database, sized for a 95% cache hit rate, now receives twenty times its provisioned load and falls over.

Paxos, Raft, and the Shape of Consensus

Fri, 20 Aug 2027 12:00:00 +0100

Symptom

Your database has two nodes that both believe they are the primary.

Each has been accepting writes. Each has a coherent log. Neither has crashed. The old primary was declared dead by a health check that timed out during a GC pause, a new one was elected, and then the old one woke up still holding what it thinks is a valid lease. You now have two divergent histories of the same data and no principled way to merge them, because both contain acknowledged writes that customers were told had succeeded.

Universal Hashing

Fri, 23 Apr 2027 12:00:00 +0100

Symptom

Your service went down under a hash collision attack.

Somebody noticed your web framework put POST parameters into a hash table, found thousands of distinct keys colliding under its hash function, and posted a form with 20,000 of them. Every insert walked a chain. Quadratic behaviour, one CPU pinned per request, service dead. This actually happened, across PHP, Python, Ruby, Java and .NET in 2011, and again against Rust’s default HashMap before it switched to SipHash.