Learn Zig Series (#136) - Stack-Based Virtual Machine What will I learn? What a virtual machine actually is once the mystique is stripped away -- a loop, an instruction pointer, and a stack -- and why

Learn Zig Series (#135) - Bytecode Design What will I learn? Why a tree-walking interpreter is slow by construction, and what a flat instruction stream buys you that a tree never can; What bytecode actually

Learn Zig Series (#134) - Type Checking What will I learn? Why a program that parses perfectly can still be complete nonsense, and what a type checker actually is -- the stage that asks "does this

Learn Zig Series (#133) - AST Design and Traversal What will I learn? Why the bare tree we hacked together last episode is not good enough the moment you want to do anything with a program, and what a

Learn Zig Series (#132) - Recursive Descent Parsing What will I learn? Why a recursive-descent parser is just one small function per grammar rule, and how that maps almost mechanically onto the language

Learn Zig Series (#131) - Lexing a Simple Language What will I learn? Why the tokenizer we wrote for SQL last episode is the exact same tool we need to build a whole programming language, and what changes

Learn Zig Series (#130) - Mini Project: Database Engine - SQL Parser What will I learn? Why an index you drive by calling insert and search from Zig is a library, not a database, and what the missing piece

Learn Zig Series (#129) - Mini Project: Database Engine - B-Tree Index What will I learn? Why a flat heap of records in pages is storage but not yet a database, and how an index turns "scan every

Learn Zig Series (#128) - Mini Project: Database Engine - Page Storage What will I learn? Why real databases store their data in fixed-size pages in stead of writing records at arbitrary offsets, and how

Learn Zig Series (#127) - Mini Project: Search Engine - Query Parser What will I learn? Why a search box that only takes a flat bag of words is missing the thing users actually type -- structure -- and

Learn Zig Series (#126) - Mini Project: Search Engine - TF-IDF What will I learn? Why an engine that only finds matching documents is only half a search box, and what the missing half -- ranking -- actually

Learn Zig Series (#125) - Mini Project: Search Engine - Inverted Index What will I learn? Why the obvious way to search -- scan every document for the word on every query -- is fine for a shoebox of files

Learn Zig Series (#124) - Consistent Hashing What will I learn? Why the innocent-looking hash(key) % server_count -- the first thing everyone reaches for to spread keys across a cluster -- turns into a

Learn Zig Series (#123) - LRU Cache What will I learn? Why a cache with a hard size limit needs to answer two questions at once -- "what is this key's value?" and "which entry have I not

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