#zig

Learn Zig Series (#142) - Regex: NFA to DFA What will I learn? Why the set-of-states NFA simulation from last episode, though linear, still does quit some redundant work on every single character; What

Learn Zig Series (#141) - Regex: Thompson NFA What will I learn? What a regular expression really is underneath the syntax -- a description of a tiny state machine, not a magic string; Why the fast, industrial

Learn Zig Series (#140) - JIT Compilation Basics What will I learn? What a JIT compiler really is -- and why it sits between an interpreter and an ahead-of-time compiler rather than replacing either; How

Learn Zig Series (#139) - Garbage Collection: Generational What will I learn? Why the mark-and-sweep collector from last episode does far too much work, and how the weak generational hypothesis -- "most

Learn Zig Series (#138) - Garbage Collection: Mark and Sweep What will I learn? What a garbage collector actually is once you strip away the folklore -- a subsystem that answers one question, "which

Learn Zig Series (#137) - Closures and Upvalues What will I learn? What a closure really is once you strip away the mystique -- a function bundled together with the variables it captured -- and why that

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