Parametricity: Theorems for Free
A polymorphic type alone tells you what the function must do. can only permute.
A polymorphic type alone tells you what the function must do. can only permute.
Interaction plus randomness lets a prover convince you of things you could never check alone.
"Well-typed programs don't go wrong", stated as the two lemmas that actually prove it. What a type system does and does not promise.
Every typable term has one most general type, and it's inferable. Why ML and Haskell need so few annotations, and why subtyping breaks it.
Programs are proofs, types are propositions, evaluation is proof simplification. The most beautiful idea in the series.
Three rules, all of computation, and recursion built from nothing. Absorbs Church–Rosser confluence: reduction order doesn't change the answer.
A program can be coordination-free iff it's monotone. The positive result hiding behind all the impossibility ones.
What it actually says, why it's routinely misquoted, and why latency (the "ELC") is the part that governs real designs.
How real systems dodge FLP impossibility: safety always, liveness only when the network cooperates.
One inequality generating the entire read/write consistency tradeoff space.
A language is regular iff it has finitely many distinguishable prefixes; and this gives you the unique minimal DFA.
Two very different-looking formalisms, exactly the same power. Explains how a regex engine really works.
Randomness probably doesn't add power; the surprise is that hardness is what buys you fake randomness.
Beyond P vs NP: why your O(n^2) string algorithm is probably optimal too.
An actual, unconditional circuit lower bound. Proof that lower bounds are possible at all, which is what stops The barriers: relativization and natural proofs from...
An unknown quantum state cannot be copied, and the two-line proof is just linearity.
Sample above twice the bandwidth or lose information irrecoverably.
You need 3f+1 nodes to tolerate f liars, and that bound is tight.
No deterministic consensus in an asynchronous system with one crash fault. The rigorous theorem that CAP only gestures at.
Detecting concurrency exactly, at the cost of O(n) metadata. The tradeoff every eventually-consistent store makes.