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

Learn Zig Series (#102) - Mini Project: HTTP Load Tester - Part 2 What will I learn? Why the Part 1 tester was quietly benchmarking the TCP handshake in stead of the server, and how keep-alive (connection

Learn Zig Series (#101) - Mini Project: HTTP Load Tester - Part 1 What will I learn? Why a load tester is really just "make the same request over and over, time each one, and do statistics on the

Learn Zig Series (#100) - Mini Project: Port Scanner What will I learn? Why a TCP port scan is, at its heart, nothing more than "try to connect and watch how the attempt fails" -- and how those

Learn Zig Series (#99) - Mini Project: DNS-over-HTTPS Proxy What will I learn? Why the operating system still asks for names in plaintext UDP long after the rest of your traffic went encrypted -- and how

Learn Zig Series (#98) - Mini Project: Chat Server - Rooms and History What will I learn? Why a chat room with no memory feels broken the moment you walk in late -- and how to give a room a bounded

Learn Zig Series (#97) - Mini Project: Chat Server - Client TUI What will I learn? Why a chat client is a genuinely different problem from the server -- not "read a socket" but "do two things

Learn Zig Series (#96) - Mini Project: Chat Server - Server Core What will I learn? How to turn last episode's paper protocol into a running server that many people can connect to at once; Why the heart