Field
Computer Science
Algorithms, complexity and the limits of computation — how machines solve problems, and what they provably cannot.
19 articles · 38 widgets
Compilers: From Source Code to Silicon
How a compiler translates human-readable source into machine code through lexing, parsing, and code generation — and why the compiled-vs-interpreted split is really about implementation.
Data Compression: Saying More With Less
Why frequent symbols deserve shorter codes, how Huffman coding builds them, and the counting argument proving no lossless scheme can shrink every possible file.
Caching: The Art of Keeping the Right Things Close
Why a small fast cache in front of slow memory speeds everything up, why locality makes it work, and why eviction policy decides the hit rate.
Concurrency: When Threads Collide
Why interleaving threads corrupt shared state, how locks enforce mutual exclusion to fix races, and how those same locks can deadlock in a circular wait.
Error-Correcting Codes: Fixing Bits Without Asking Again
How computers repair corrupted bits on their own using built-in redundancy — from parity to Hamming codes, syndromes, and the geometry of minimum distance.
Floating-Point: Why 0.1 + 0.2 ≠ 0.3
Why 0.1 + 0.2 lands on 0.30000000000000004, how IEEE-754 packs a sign, exponent, and mantissa into 64 bits, and why float errors are deterministic, not glitches.
How Neural Networks Learn
What a neuron actually computes, why the squashing function is the part that matters, and how backpropagation extracts every partial derivative in a single backward sweep.
Public-Key Cryptography
One-way functions let two people who have never met build a shared key in the open — and the same asymmetry that protects the key is what a quantum computer would dismantle.
Distributed Consensus
Why agreement across unreliable machines is genuinely hard, how quorum intersection and Raft's leader election solve it in practice, and what the FLP impossibility result and CAP actually say.
Hash Tables
How hashing converts a key directly into a memory location, why collisions are unavoidable, and why the O(1) everyone quotes is an average that a bad day can destroy.
P vs NP
Why verifying a solution and discovering one look like utterly different tasks, what NP-completeness says about that gap, and why fifty years of effort has not settled the most important open question in computing.
The Halting Problem
Why no program can decide whether another program halts, how Turing's diagonal argument proves it, and what undecidability means for the tools that check your code.
Recursion: Functions That Call Themselves
The base case, the call stack, and why naive recursive Fibonacci is exponential until one cache makes it linear.
Finite Automata and Regular Expressions
How a regular expression compiles into a tiny memoryless machine, why that makes it fast, and why it provably cannot match balanced brackets.
Logic Gates: How Computers Do Arithmetic
How on/off switches become logic gates, gates become adders, and adders turn binary digits into arithmetic — with no understanding anywhere in the machine.
Dynamic Programming
Why naive recursive Fibonacci takes billions of calls, how remembering answers collapses it to n, and how the same trick solves edit distance and knapsack.
Graph Traversal
How queues and stacks determine whether you explore a graph level by level or depth by depth.
Binary Search
How halving the search space every step turns a million possibilities into twenty comparisons.
Sorting Algorithms
From bubble sort to quicksort — see exactly how each algorithm works, step by step.