Compilers & runtimes

Hand-written top-down parser with one function per grammar rule; simple, fast, with full control over error messages and recovery.

Table-driven expression parsing with one loop and a numeric binding power per operator; the compact core of precedence handling in hand-written parsers.

Reparse only the region an edit damaged and splice the new subtrees into the old tree, sharing everything else; O(edit) instead of O(file).

Bind every use of a name to its declaration with a scope stack, handling shadowing, hoisting and closure capture in one AST walk.

Split checking into two mutually recursive modes, check against a known type and synthesize an unknown one, so annotations are needed only at a few points.

Give every variable exactly one definition, merging at joins with phi functions; def-use becomes explicit and optimizations turn sparse and cheap.

Split a linear instruction list into basic blocks and connect them by jumps; the graph every optimizer, SSA builder and dataflow pass walks.

Compute a fact per program point (live variables, reaching definitions, available expressions) by iterating transfer functions over the CFG to a fixed point.

Prove which allocations never outlive or leave their creator, then put them on the stack, split them into scalars, or drop their locks.

Turn a jump graph into nested block, loop and if constructs with numbered breaks; reducible graphs need no duplication.

Cover the IR with target instruction patterns at least cost; greedy maximal munch is simple, dynamic programming over a tree or DAG is optimal.

Map unlimited virtual registers onto a few machine registers, spilling the rest to the stack; linear scan is fast, graph coloring and splitting allocators give better code.

The linker merges object files, matches each undefined name to one definition, assigns addresses and patches every recorded reference (relocation); dynamic linking defers part of that to load time.

A section-based module container with LEB128 integers and structured, typed code, so untrusted bytes are validated in one pass and compiled as they stream in.

Flatten an AST into compact linear instructions with a constant pool, backpatched jumps and slot-numbered locals, so a small loop can execute it.

Describe a library's C-ABI surface once (header, attributes or IDL) and generate the declarations, converters and wrappers for each caller language.

DWARF stores a tree of typed entries (DIEs), a line-number bytecode, unwind tables and location expressions that map machine state back to source; pick it for ELF/Mach-O debug builds.

Insert counters into compiled code to record which blocks, edges or lines ran; a spanning tree of the control-flow graph cuts the counters needed.

Run cold code in a cheap tier, count executions, and compile only what gets hot, trading warm-up time and memory for peak speed.

Per-call-site cache of "this object shape, that slot or target", turning dynamic property and method lookup into a compare and a load.

Objects that gained the same properties in the same order share one layout descriptor, so a property is an index and the layout is one comparable id.

Speculate with guards, and on failure rebuild the slow-tier frames from compile-time metadata and resume there, so optimized code may assume the common case.

Count loop back-edges, compile code that can start at a loop header, and copy the live frame state into it, so one running call gets faster.

Pack the type and the payload of any value into one 64-bit word, using spare low bits of aligned pointers or the unused payload of NaNs, so type tests are one mask compare.

How interpreters and compilers let a function keep using its enclosing variables after they return: flat closures, open and closed upvalues, closure conversion, capture by value or reference.

How JITs and code generators emit machine code under W^X: RW to RX flips, dual mappings, per-thread write toggles, and the instruction-cache flush.

Charge a fuel budget per instruction or per basic block and trap at zero, so untrusted code is bounded by work done, deterministically.

Replace code in a running process by swapping an indirection point, then migrate the live state to the new layout at a safe moment.

Find everything reachable from the roots, free the rest in place; handles cycles, never moves objects, and is the base of most production collectors.

Split the heap by age, collect the small young region often and cheaply, and rarely touch old data; wins whenever most objects die young.

Trace the heap in small steps or on other threads while the program runs, and use barriers to keep the collector's view correct.

Keep a count of owners in each object, free it when the count hits zero; deterministic and local, but pays on every copy and leaks cycles.

Extract definitions and references per file, give each symbol a stable string id, and store symbol to occurrences, re-indexing only files whose content hash changed.

One JSON-RPC conversation over a pipe lets any editor drive any language's analysis server; the cost is keeping a live, edited document in sync and answering before it changes.

Store byte offsets, convert to (line, column) on demand with a line-start table and binary search, and count columns in the unit the peer negotiated.