Topic domain
Language Runtimes
The machinery that keeps managed and dynamic languages running.
- Articles
- 80
- Clusters
- 8
- Foundational
- 24
- Intermediate
- 32
- Advanced
- 24
Bytecode dispatch, stack frames, and interpreters.
- Stack Machines and Register Machines as Bytecode Targets
- Computed Goto and Direct Threading in Bytecode Interpreters
- How an Interpreter Lays Out a Stack Frame
- Constant Pools and Operand Encoding in Bytecode
- Calling Conventions on an Operand Stack
- Exception Tables and Frame Unwinding in Bytecode
Tracing, reference counting, and collector tradeoffs.
- Reachability from Roots and the Transitive Closure
- Reference Counting and Its Structural Blindness to Cycles
- Mark-Sweep and the Fragmentation It Leaves Behind
- Copying Collection, Cheney Scanning, and the Bump Pointer
- Generational Collection and the Write Barrier That Enables It
- Mark-Compact: Sliding Objects Without a Second Semispace
Profiling, tiering, and speculative optimization.
- Interpreter Dispatch Overhead and the Cost That Justifies Compilation
- Hot Code Detection with Invocation and Back-Edge Counters
- Tiered Compilation and On-Stack Replacement
- Type Feedback and Inline Caches in Dynamic Call Sites
- Speculative Inlining and Guard Placement
- Deoptimization and Frame State Reconstruction
Inline caches, shapes, and hidden classes.
- The Dictionary Object Model and the Cost of a Name Lookup
- Hidden Classes and the Transition Tree Behind Property Writes
- Monomorphic Inline Caches and the Guard That Makes Them Work
- Property Attributes, Accessors, and the Demotion to Dictionary Mode
- Polymorphic and Megamorphic Inline Caches
- Type Feedback and the Speculation Budget
Schedulers, green threads, and event loops.
- Readiness Notification and the Single-Threaded Event Loop
- Green Threads and the Cost of a User-Space Context Switch
- Yield Points and What Makes a Task Cooperatively Schedulable
- Readiness and Completion: Two Ways to Ask the Kernel for I/O
- Work-Stealing Deques and Why the Thief Takes the Oldest Task
- Stackful and Stackless Coroutines: Where Suspension Is Allowed
Calling conventions across language boundaries.
- The C Calling Convention as an Interoperability Contract
- Symbol Mangling and Linkage in Cross-Language Calls
- Struct Passing and Register Classification Across ABIs
- String Encoding and Buffer Ownership at the FFI Boundary
- Allocator Mismatch and Cross-Runtime Deallocation
- Native Callbacks Into Managed Code
Dependency resolution, artifacts, and environments.
- Dependency Resolution as Backtracking Search Over Version Sets
- Version Precedence and the Semantics of Range Operators
- Lockfiles as Reproducibility Contracts and Why They Drift
- Registry Index Metadata and Resolution Without Downloading Artifacts
- Content Addressing and What Artifact Hashes Actually Prove
- Platform Tags and Binary Compatibility in Distributed Artifacts
Sandboxing, capability models, and isolation.
- The Runtime as Reference Monitor: Mediation and the Trusted Base
- Capability References and the Absence of Ambient Authority
- Syscall Filtering and the Process as a Security Boundary
- Linearity and Aliasing as a Confinement Discipline
- WebAssembly Imports as the Only Channel to the Host
- Deserialization as Re-entry Across the Trust Boundary
All Language Runtimes articles
- 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.
- Sep 13, 2026 Calling Conventions on an Operand Stack How arguments, return values, receivers, and frame transitions are encoded in a stack machine, and why the receiver occupies slot zero of a method frame.
- Sep 11, 2026 Reference Counting and Its Structural Blindness to Cycles Why a count per object frees memory deterministically and still leaks a two-node cycle, what the counting discipline costs per assignment, and how trial deletion recovers.
- Sep 8, 2026 When a Blocking Call Enters an Asynchronous Runtime A blocking system call inside a task stalls the carrier thread and every task queued behind it. What detection is possible, what a blocking pool costs, and why the boundary is drawn at the library.
- Aug 27, 2026 What a Sandbox Proof Establishes and What It Assumes How verification of a sandbox reduces the isolation guarantee to a set of machine-checked lemmas, where the specification gap appears, and why the assumptions are the part that matters.
- Aug 5, 2026 Capability References and the Absence of Ambient Authority Why naming a resource by path or file descriptor grants more than the caller needs, and how unforgeable references make authority a property of what a program holds rather than who it claims to be.
- Aug 5, 2026 Content Addressing and What Artifact Hashes Actually Prove The difference between a hash that identifies bytes and a signature that identifies a publisher, how digest verification fails, and why a matching hash is a narrower guarantee than it appears.
- Jul 29, 2026 Opaque Handles and Ownership Transfer in C APIs Why handle-based interfaces survive changes that struct-based ones cannot, how borrowing differs from transfer, and what an invalidated handle means to the caller.
- Jul 23, 2026 Prototype Chain Guards and Validity Cells Why a compiled access through a prototype is invalidated by an assignment to the prototype rather than by a failed layout check, and how a one-word cell makes that invalidation cheap.
- Jul 21, 2026 Vendored Source Trees and Offline Artifact Mirrors How copying dependencies into the repository changes the resolution problem, what it costs in update latency and duplication, and how mirrors extend the same idea to binary artifacts.
- Jul 20, 2026 Stack Machines and Register Machines as Bytecode Targets Why bytecode formats choose implicit stack operands or named registers, and what that choice costs in encoding width, instruction count, and verifier complexity.
- Jun 26, 2026 Mark-Sweep and the Fragmentation It Leaves Behind How a sweep pass rebuilds allocatable space, why segregated free lists and size classes delay the fragmentation problem rather than solve it, and what coalescing costs.
- 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.
- Jun 3, 2026 Cancellation and Drop at Suspension Points Stopping a task means unwinding or abandoning whatever state it holds at the moment it was suspended. Why cancellation is safe only at suspension points, and what a partially completed operation leaves behind.
- Jun 3, 2026 Syscall Filtering and the Process as a Security Boundary How seccomp filters restrict a process to a fixed set of system calls, why argument inspection is limited by the kernel interface, and where the remaining escape routes lie.
- Jun 1, 2026 Designing a C ABI That Survives Version Changes Which parts of an interface are frozen by binary compatibility, how struct sizing and symbol versioning let a library grow, and what a versioned entry point must promise.
- Apr 14, 2026 Tri-Colour Marking and the Barriers That Keep It Honest Why a concurrent marker must prevent a black object from pointing at a white one, how insertion and deletion barriers each enforce that, and what the invariant costs per store.
- Apr 6, 2026 Code Cache Management and Invalidation How generated code and its metadata are stored, why stale code must be retired rather than deleted, and how a runtime finds every compiled method that depended on a class it can no longer trust.
- Mar 17, 2026 Array Element Kinds and Representation Transitions How a homogeneous array of small integers becomes an array of doubles and then an array of boxed values, why the transitions are one-way, and what the kind check costs on each read.
- Mar 17, 2026 Readiness Notification and the Single-Threaded Event Loop How one thread watches thousands of file descriptors through epoll or kqueue, why edge-triggered notification forces handlers to drain until EAGAIN, and where the dispatch loop stalls.
- Feb 20, 2026 The Dictionary Object Model and the Cost of a Name Lookup How a dynamically typed object resolves a property name through a per-object table, what a single access costs in instructions and bytes, and which conditions must hold before the lookup can become a fixed offset.
- Feb 14, 2026 String Encoding and Buffer Ownership at the FFI Boundary Why passing a string across a language boundary requires agreeing on encoding, termination, and allocation, and how the two-call pattern avoids guessing at buffer sizes.
- Feb 14, 2026 The C Calling Convention as an Interoperability Contract How arguments, return values, and stack alignment are encoded at a call site, and why extern C is a narrower promise than most callers assume.
- Jan 26, 2026 Provenance Attestations and the Trust Boundary of a Package Install What an in-toto attestation binds together, how transparency logs change the meaning of a verified install, and which attacks remain outside the model.
- Jan 2, 2026 Symbol Mangling and Linkage in Cross-Language Calls Why C++ and Rust rename functions before the linker sees them, how name mangling differs between compilers, and what dlsym requires of an exported symbol.
- Dec 15, 2025 Reproducible Builds and the Sources of Byte-Level Nondeterminism Why two builds of identical source produce different archives, which fields carry the difference, and what verification requires beyond a matching hash.
- Dec 8, 2025 Hot Code Detection with Invocation and Back-Edge Counters How runtimes decide that a function or loop is worth compiling, why method entries and loop back edges need separate counters, and what the counter arithmetic gets wrong.
- 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.
- Nov 20, 2025 Bytecode Verification and Stack Map Frames How a verifier proves that operand stack depths and types are consistent at every branch target, and why stack map frames replaced full dataflow analysis.
- Oct 8, 2025 Deoptimization and Frame State Reconstruction What must be rebuilt when compiled code abandons a speculative assumption, how the compiler describes frame state at each guard, and why the metadata is the expensive part of the mechanism.
- Oct 6, 2025 Dependency Resolution as Backtracking Search Over Version Sets Why choosing the newest version of each dependency in turn fails, how resolvers represent partial assignments, and what conflict-driven backjumping buys over chronological backtracking.
- Sep 24, 2025 How an Interpreter Lays Out a Stack Frame The header, locals, operand stack, and spill area of an interpreter frame, and why the frame is allocated as one block with a fixed maximum size.
- Sep 23, 2025 Tiered Compilation and On-Stack Replacement Why runtimes compile the same method more than once, how a frame in the middle of an interpreted loop moves into optimized code, and what the transfer must reconstruct.
- Sep 20, 2025 Covert Channels That Survive Logical Isolation Why a sandbox that prevents every direct access can still carry information through shared caches, timing, and resource contention, and what the bandwidth of each channel implies for policy.
- Sep 11, 2025 Hidden Classes and the Transition Tree Behind Property Writes How a runtime derives a shared layout descriptor from the sequence of property additions, why the order of those additions decides which descriptor an object ends up with, and what a transition edge has to store.
- Aug 30, 2025 Attaching Foreign Threads to a Managed Runtime What a runtime needs from a thread before managed code can run on it, why a library-spawned worker thread has none of it, and how attach and detach bracket the transition.
- Aug 28, 2025 The Runtime as Reference Monitor: Mediation and the Trusted Base How an interpreter or managed runtime becomes the enforcement point for security policy, which operations escape its mediation, and what the resulting trusted computing base contains.
- May 21, 2025 Readiness and Completion: Two Ways to Ask the Kernel for I/O Readiness notification tells a program when an operation can start; completion notification tells it when one has finished. The difference decides how many syscalls a runtime makes and where its buffers live.
- Mar 27, 2025 Speculative Inlining and Guard Placement How an optimizing JIT inlines a callee it cannot prove is the right target, what the guard costs, and why the number of guards rather than the amount of inlining sets the limit.
- Mar 20, 2025 Constant Pools and Operand Encoding in Bytecode Why bytecode instructions reference large constants indirectly through a pool, how the pool is laid out, and what the fixed-width index fields cost.
- Mar 19, 2025 Green Threads and the Cost of a User-Space Context Switch What a green thread actually saves compared with a kernel thread, which registers a switch must preserve, and why a scheduler that lives in user space changes the blocking rules of the whole runtime.
- 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.
- Jan 30, 2025 Weak References, Finalization, and Ephemerons How a collector clears references that must not keep objects alive, why finalization needs its own reachability class, and the fixed-point iteration that ephemeron tables require.
- Nov 18, 2024 Type Feedback and Inline Caches in Dynamic Call Sites How a runtime records which types actually reach a polymorphic operation, how an inline cache turns that history into a few comparisons, and why monomorphic feedback changes what the compiler can generate.
- Nov 6, 2024 Stackful and Stackless Coroutines: Where Suspension Is Allowed A stackful coroutine can suspend inside any call; a stackless one can only suspend where the compiler emitted a resume point. The difference is a per-task stack versus a state machine, and it decides which libraries a task may call.
- Sep 22, 2024 Work-Stealing Deques and Why the Thief Takes the Oldest Task Per-worker deques with LIFO local execution and FIFO stealing keep hot data on one core, and the memory-ordering requirements that make the concurrent deque correct are narrower than they look.
- Sep 12, 2024 Platform Tags and Binary Compatibility in Distributed Artifacts How wheels encode interpreter, ABI, and platform into a compatibility tag, how that tag is matched against an ordered list of supported tags, and where the encoding leaks.
- Aug 27, 2024 WebAssembly Imports as the Only Channel to the Host Why a validated module can reach nothing but its own linear memory and its declared imports, and how host functions, tables, and shared memories widen that surface.
- Aug 13, 2024 Type Feedback and the Speculation Budget How a runtime decides what to speculate about from what the interpreter observed, why the counters that trigger optimization are the same counters that guard it, and what happens when a speculative bet loses.
- Aug 12, 2024 Version Precedence and the Semantics of Range Operators How version strings are ordered, why caret and tilde ranges expand the way they do, and where precedence rules diverge between ecosystems badly enough to change an install.
- Aug 3, 2024 Struct Passing and Register Classification Across ABIs How a compiler decides whether a struct travels in registers or in memory, what the eightbyte classification rules encode, and where layouts diverge between C and other languages.
- Jun 24, 2024 Yield Points and What Makes a Task Cooperatively Schedulable Why a scheduler that cannot interrupt needs the compiler to place checkpoints, how the choice of checkpoint changes latency, and what a missing yield point does to every task behind it.
- Jun 3, 2024 Copying Collection, Cheney Scanning, and the Bump Pointer Why a semispace collector trades half the heap for allocation in a few instructions, how Cheney's breadth-first scan avoids a recursion stack, and what forwarding costs.
- May 30, 2024 Attenuation and Revocation of Delegated Authority How a capability can be narrowed before it is passed on, why revocation in a capability system is either impossible or requires indirection, and what each indirection costs.
- May 20, 2024 Heap Growth and the Pacing of Collection Cycles How a runtime decides when to collect and how much heap to add, why the live-set measurement after each cycle determines the next one, and how pacing trades memory against pause.
- Apr 9, 2024 Generational Collection and the Write Barrier That Enables It How the weak generational hypothesis justifies splitting the heap by age, why a young-only collection must be told about old-to-young pointers, and what each barrier flavour costs.
- Feb 22, 2024 Prefix-Based Environments and Why Activation Is Only Path Surgery How a virtual environment isolates packages by rewriting interpreter paths and sys.path, why moving one breaks its scripts, and what containers change about the same problem.
- Feb 5, 2024 Reachability from Roots and the Transitive Closure How a tracing collector enumerates its root set, walks the object graph to a fixed point, and why unreachability rather than uselessness is the property it can actually compute.
- Feb 3, 2024 Lockfiles as Reproducibility Contracts and Why They Drift What a lockfile must record to make an install repeatable, which inputs it cannot capture, and how lockfiles fall out of sync with manifests without either side being wrong.
- Jan 30, 2024 Allocator Mismatch and Cross-Runtime Deallocation Why freeing memory across a language boundary corrupts the heap, how separate C runtimes end up with separate heaps, and which API shapes make the allocator identity explicit.
- Jan 21, 2024 Exception Tables and Frame Unwinding in Bytecode How a thrown exception finds its handler using a table of protected ranges, and why the table is separate from the code rather than encoded as instructions.
- Jan 11, 2024 Hierarchical Timing Wheels for Millions of Timeouts A heap of deadlines costs O(log n) per insertion and O(1) to read the next one. A hashed wheel with cascading levels makes insertion O(1) and confines expiry to one bucket, at the price of resolution and a bounded maximum interval.
- Jan 9, 2024 Conservative Stack Scanning Without Type Maps How a collector can treat any word that falls inside the heap as a pointer, why that forces a non-moving heap, and what the ambiguity costs in retention and false roots.
- 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.
- Dec 6, 2023 Deserialization as Re-entry Across the Trust Boundary Why parsing untrusted bytes into objects is the most exposed operation a runtime performs, how format-directed object construction grants authority, and which design choices contain the damage.
- Dec 4, 2023 Shape Identity, Interning, and Structural Equality Why two layouts with the same property names and offsets may still need to be distinct, when an engine may safely merge them, and how the identity comparison in a guard depends on that decision.
- Nov 28, 2023 Unwinding Across an FFI Boundary Why an exception cannot safely propagate through a C frame, how table-based unwinding locates a handler, and what a boundary must do instead of throwing through it.
- Jul 11, 2023 Registry Index Metadata and Resolution Without Downloading Artifacts How registries expose version lists, dependency metadata, and hashes as separate resources, and why fetching full archives during resolution is a design error.
- May 14, 2023 Property Attributes, Accessors, and the Demotion to Dictionary Mode Why a plain field and an accessor cannot share one layout slot, how attribute bits and non-extensibility force a representation change, and why that change is one-way in practice.
- May 10, 2023 Sample-Based Profiling and Stack Walking in Compiled Code How a runtime learns where time goes by interrupting threads rather than instrumenting them, what a walk over compiled frames must decode, and why sampled profiles are biased in ways counters are not.
- Apr 13, 2023 Resumable Frames for Generators and Coroutines Why a generator cannot keep its state on the machine stack, how its frame is moved to the heap, and what suspension costs in copying and in bookkeeping.
- Mar 14, 2023 Mark-Compact: Sliding Objects Without a Second Semispace How a compacting collector relocates live objects into one end of the same heap, the two passes needed to compute and then apply new addresses, and why the ordering of objects matters.
- Feb 24, 2023 Line Tables, Breakpoints, and Single Stepping in an Interpreter How a debugger maps a bytecode offset back to a source line, how breakpoints are placed without corrupting the code, and what stepping costs per instruction.
- Jan 16, 2023 Compilation Budgets and Recompilation Policy How a runtime bounds the CPU it spends compiling, what triggers a second compilation of code that already compiled, and why unbounded recompilation is a denial-of-service on the application itself.
- Oct 13, 2022 Fault Isolation Between Tenants in One Address Space How software-based isolation keeps untrusted modules in a shared heap using reservations, per-tenant heaps, and checks, and why the hardware offers no help with cross-tenant reads.
- Sep 15, 2022 Native Callbacks Into Managed Code How a C library invokes a function pointer that lands in a garbage-collected runtime, why the trampoline cannot simply be the managed function, and what keeps the target alive.
- Sep 12, 2022 Escape Analysis and Scalar Replacement in Compiled Code How a JIT proves an allocation never leaves its method, why replacing an object with its fields is only safe while guards hold, and what makes the proof fail in practice.
- Jun 27, 2022 Interpreter Dispatch Overhead and the Cost That Justifies Compilation Why a bytecode interpreter spends most of its cycles on dispatch rather than on the program, and how that per-instruction cost sets the break-even point for compiling code at run time.
- Jun 19, 2022 Linearity and Aliasing as a Confinement Discipline How unique ownership, borrowing, and linear types let a compiler prove that a value crosses a boundary exactly once, and where the proof stops being able to say anything about authority.
- Dec 6, 2021 Fairness and Tail Latency in Task Schedulers Average latency hides the requests that wait behind a queue. How scheduler policy, queue discipline, and batching each move the tail, and why a fair scheduler can still produce an unfair system.