Language Runtimes · Cluster
Dynamic Typing
Inline caches, shapes, and hidden classes.
- 01 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.
- 02 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.
- 03 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.
- 04 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.
- 05 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.
- 06 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.
- 07 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.
- 08 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.
- 09 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.
- 10 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.