An Attempt to Catch Up with JIT Compilers

Original Article ↗ Hacker News Discussion ↗

JIT vs AoT: Performance and Broken Promises

  • Several commenters push back on the long-standing narrative that JITs will “overtake” AoT for raw performance, noting that C/C++/Rust are still chosen for performance‑critical work.
  • The supposed JIT advantage (“more runtime information”) is seen as largely unrealized in practice outside specific domains.
  • Others argue this framing is wrong: with full knowledge of the target, an AoT compiler can at least match any JIT; JIT’s real win is ergonomics and adaptability, not guaranteed higher peak speed.

Dynamic Languages and the Scope of the Paper

  • Multiple comments clarify the paper is about JIT vs AoT for JavaScript, i.e. a highly dynamic language that’s hard to analyze statically.
  • In this dynamic-language context, it’s considered reasonable that JIT can beat AoT, and the paper examines whether AoT + inline caches can close that gap.
  • Some see the paper’s initial “catch up with JITs” framing as misleading when generalized to all languages, since most AoT targets have type systems that avoid inline caches entirely.

Inline Caches, Profiling, and Why the Experiment May Have Failed

  • Practitioners stress that modern JS engines don’t just use inline caches to speed up property lookups; they use them as a key profiling signal feeding higher-tier optimizers.
  • Successful systems tie ICs to: polymorphic inline caches, deoptimization guards, global simplification of dominated code, and speculative specialization based on type shapes.
  • The experiment here largely tweaks a small part of existing monomorphic IC code (e.g., replacing an indirect load with an immediate), which commenters suspect is too minor to matter on modern CPUs.
  • Several argue the real wins in JIT VMs come from broader runtime design choices: object layout, tagging schemes, GC, devirtualization, inlining across call paths, and using ICs as a rich feedback channel.

JIT vs AoT Trade-offs and Use Cases

  • JITs are seen as especially valuable for dynamic languages and for scenarios with heavy virtual calls, dynamic dispatch, or hardware-dependent SIMD paths.
  • AoT with PGO is noted as extremely strong for static languages; some suggest hybrid AoT+selective runtime optimization as a promising direction.

Meta: Negative Results and Scientific Practice

  • There is strong appreciation that a negative result was published at all; commenters wish more research were preregistered and required to publish regardless of outcome.