Tag
dispatch
- Sep 19, 2026 Cache Miss Handling and Patching Code at the Access Site What happens on the first execution of a property access, how the runtime rewrites the site without breaking other threads, and why the patched instruction must be safe to overwrite atomically. language runtimes
- Jun 13, 2026 Middleware Composition and Why Order Changes Behaviour What a middleware chain actually is at runtime, which orderings the mechanism forces, and how buffering middleware breaks streaming responses. backend systems
- Jun 10, 2026 Superinstruction Selection and In-Place Opcode Quickening How interpreters fuse frequent opcode pairs and rewrite instructions after first execution, and why every such rewrite needs an invalidation path. language runtimes
- Nov 26, 2025 Computed Goto and Direct Threading in Bytecode Interpreters How the dispatch loop dominates interpreter cost, and why a table of label addresses beats a switch statement on the same instruction stream. language runtimes
- Feb 5, 2025 Monomorphic Inline Caches and the Guard That Makes Them Work How a single cached layout and offset turn a dynamic property access into a compare and a load, what the guard must verify beyond layout identity, and why one shape is the case worth optimizing hardest. language runtimes
- Jan 10, 2024 Method Resolution Order in Multiple Inheritance How C3 linearisation produces a consistent method order from a class graph, why depth-first search fails on diamonds, and what the monotonicity property forbids. programming languages
- Dec 26, 2023 Polymorphic and Megamorphic Inline Caches What a cache does when a second and then a fourth layout arrives at the same site, how the compare chain and the hash stub differ, and where the threshold between them sits. language runtimes
- May 13, 2023 Route Matching Precedence and the Cost of Ambiguity How a dispatcher chooses one handler among overlapping patterns, why specificity beats registration order, and where percent-decoding changes which route wins. backend systems
- Feb 26, 2023 Tree-Walking Interpretation and the Cost of Re-Deciding at Every Node Why an interpreter that evaluates syntax nodes spends most of its time on type dispatch and environment lookup, and which of those costs a bytecode compiler removes. programming languages