#zig

Learn Zig Series (#122) - Union-Find What will I learn? What the union-find (or disjoint-set) structure actually answers -- the deceptively simple question "are these two things in the same group

Learn Zig Series (#121) - Topological Sort What will I learn? What a topological sort actually is, why it only makes sense on a directed acyclic graph (a DAG), and how it turns "these things depend

Learn Zig Series (#120) - Dijkstra and A* What will I learn? Why the BFS shortest path we built last episode quietly breaks the moment edges stop being equal, and why that single assumption is the whole

Learn Zig Series (#119) - BFS and DFS What will I learn? Why breadth-first search (BFS) and depth-first search (DFS) are secretly the same algorithm, and how the only real difference is whether you pull

Learn Zig Series (#118) - Graph Representation What will I learn? Why a graph is the right shape for data that is connected rather than ordered -- roads, dependencies, friendships, web links -- and why

Learn Zig Series (#117) - Binary Search Variations What will I learn? Why binary search is the payoff that sorting buys you -- an unsorted array answers "is this here?" in O(n), a sorted one

Learn Zig Series (#116) - Sorting Algorithms in Zig What will I learn? Why sorting is a solved problem you never stop paying for -- the comparison model, the O(n log n) lower bound, and why "just

Learn Zig Series (#115) - Slab Allocators What will I learn? What a slab allocator actually is -- not a new trick, but the machine episode 114 was pointing at: take the single-size memory pool we built

Learn Zig Series (#114) - Memory Pools What will I learn? Why a memory pool (a.k.a. object pool, fixed-size block allocator, or free-list allocator) is the idea episode 113 was quietly walking toward --

Learn Zig Series (#113) - Ring Buffers: Lock-Free What will I learn? Why a ring buffer (a.k.a. circular buffer) is the data structure that answers the question episode 112 ended on -- a buffer of exactly

Learn Zig Series (#112) - Cuckoo Filters What will I learn? Why the cuckoo filter answers the exact question the bloom filter left dangling at the end of episode 111 -- membership testing with clean deletion

Learn Zig Series (#111) - Bloom Filters What will I learn? Why a bloom filter throws out the one thing every structure so far has quietly insisted on -- storing the keys themselves -- and keeps nothing

Learn Zig Series (#110) - Tries: Prefix Trees What will I learn? Why a trie throws out the one assumption every tree so far has quietly leaned on -- that the only thing you can do with a key is compare

Learn Zig Series (#109) - Red-Black Trees What will I learn? Why a red-black tree is the exact same balancing idea as last episode's B-tree, only squeezed back down onto a binary node -- one key, two children

Learn Zig Series (#108) - B-Trees What will I learn? Why a B-tree is the deterministic answer to the exact question skip lists answered with coin flips -- "how do I keep an ordered collection fast

Learn Zig Series (#107) - Skip Lists What will I learn? Why a skip list is what you get when you take last episode's linked list and let each node hold more than one forward pointer -- and why that single

Learn Zig Series (#106) - Linked Lists: Singly and Doubly What will I learn? Why a linked list is the simplest data structure you can build out of nothing but a node and a pointer, and why starting the

Learn Zig Series (#105) - Mini Project: Reverse Proxy - Health Checks What will I learn? Why last episode's failover -- discovering a dead backend by dialing it and getting refused -- is a reactive safety

Learn Zig Series (#104) - Mini Project: Reverse Proxy - Load Balancing What will I learn? Why a route pointing at a single backend is only half a reverse proxy, and what changes the moment one prefix can

Learn Zig Series (#103) - Mini Project: Reverse Proxy - Routing What will I learn? What a reverse proxy actually is, how it differs from the forward proxy your VPN uses, and why almost every production