Learn Zig Series (#157) - Line Drawing: Bresenham What will I learn? Why drawing a straight line between two arbitrary points is a genuinely hard problem, and how the pixel grid quietly fights you every

Learn Zig Series (#156) - Framebuffer Basics What will I learn? What a framebuffer actually is -- why every pixel you have ever seen on a screen ultimately lives in a flat, one-dimensional slice of memory,

Learn Zig Series (#155) - Mini Project: Regex Engine - Matching Part of a multi-episode project What will I learn? How to run the NFA we built last episode -- feeding it text and getting back a yes-or-no

Learn Zig Series (#154) - Mini Project: Regex Engine - NFA Part of a multi-episode project What will I learn? Why a regular expression is really two machines stacked -- a small parser that turns a string

Learn Zig Series (#153) - Mini Project: Lisp - Standard Library Part of a multi-episode project What will I learn? Why a real language is two things -- a small core of primitives written in the host language,

Learn Zig Series (#152) - Mini Project: Lisp - Special Forms and Macros Part of a multi-episode project What will I learn? What a macro actually is -- a function that runs at expand time and returns new

Learn Zig Series (#151) - Mini Project: Lisp - Evaluator Part of a multi-episode project What will I learn? What the "eval" in Read-Eval-Print-Loop actually does, and why it is a genuinely separate

Learn Zig Series (#150) - Mini Project: Lisp - Reader Part of a multi-episode project What will I learn? What the "read" in Read-Eval-Print-Loop actually means, and why in Lisp it is a genuinely

Learn Zig Series (#149) - Mini Project: Calculator - VM with Debugger Part of a multi-episode project What will I learn? Why the "bare-bones runner" from last episode was only a preview, and

Learn Zig Series (#148) - Mini Project: Calculator - Bytecode Compiler Part of a multi-episode project What will I learn? Why a tree-walking interpreter is a lovely thing to reason about and a mediocre

Learn Zig Series (#147) - Mini Project: Calculator - Interpreter Part of a multi-episode project What will I learn? How to turn the AST we built last time into an actual answer -- a tree-walking evaluator

Learn Zig Series (#146) - Mini Project: Calculator - Lexer/Parser Part of a multi-episode project What will I learn? How to start a real mini project -- a working four-function-plus calculator -- by building

Learn Zig Series (#145) - Register Allocation What will I learn? What register allocation actually is -- the problem of mapping an unbounded number of intermediate values onto a fixed, small set of machine

Learn Zig Series (#144) - Code Generation: AST to Machine Code What will I learn? What a code generator actually is -- instruction selection, the leap from a tree to a flat stream of bytes, and why a stack

Learn Zig Series (#143) - Regex: Matching Engine What will I learn? Why a DFA answers "does this match?" but cannot tell you where each capture group landed -- and why that pushes us back to

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