Speaker
Abstract
We as a community have attempted, multiple times, to speed up languages such as Lua, Python, and Ruby by hand-writing JIT compilers. Sometimes we've had short-term success, but the size, and pace of change, of their standard implementations has proven difficult to keep up with over time.
What if, instead of hand-writing JIT compilers, we could automatically derive them from languages' standard implementations? Doing so would not only preserve the language's semantics but also allow the JIT compiler to evolve at the same pace as the language's implementation.
In this talk I'll show how we've made this a reality. I'll introduce an early-stage open-source system which takes existing C interpreters as input and automatically derives a JIT compiler. Early benchmarks already demonstrate substantial performance improvements, with results continuing to improve as the system matures. I'll walk through the core ideas with concrete examples, highlight some of the surprising technical challenges, and outline where this technology could go next.
Interview
I'll be looking at programming language performance, in particular the "awkward squad": dynamically typed languages. With the notable exception of JavaScript, most such languages (e.g. Lua, Python, Ruby) struggle to run programs at high speed. I'll show how a new technique can lessen the performance penalty these languages suffer from -- without undue effort on the language implementer's behalf, and without compromising compatibility.
More people are writing software than ever before, and, from data analysts to AI specialists, they're often using "slow" languages. If we can give people using these languages faster language implementations, they will be more productive, happy, colleagues!
Fear. We'll be looking at compilers in this session: the trade-offs of different designs, the complexity involved in implementing them, and our surprisingly poor understanding of the overall design space. The good news is that there's a lot less to fear than we think!
Topics
QCon London 2026 is a three day conference for senior software engineers, architects and team leads. An international program committee of working engineers selects every session. Patterns and practices, not products and pitches.
Part of the track
Modern Performance Optimization Hosted by Chaitanya Bhandari Distributed Systems Engineer @TigerBeetleFrom the same track
Wednesday 18 March
10:35 Windsor (5th Fl.) Session AI/ML Machine Learning at the Edge of Scale and Speed: Nanosecond Inference at the CERN Large Hadron Collider Thea Klaeboe Aarrestad Particle Physics and Real-Time ML @CERN @ETH Zürich The CERN Large Hadron Collider (LHC) produces O(10,000) exabytes of raw data annually from high-energy proton collisions. Handling this volume under strict compute and storage limits requires real-time event filtering capable of processing millions of collisions per second. 11:45 Windsor (5th Fl.) Session Data Systems Vector Search on Columnar Storage Peter Boncz Professor @CWI, Co-Creator of MonetDB, VectorWise and MotherDuck, Database Systems Researcher, and Entrepreneur Managing vector data entails storing, updating, and searching collections of large and multi-dimensional pieces of data. Some believe that this justifies the creation of a new class of data systems specialized for this. 13:35 Mountbatten (6th Fl.) Session architecture Not Just I/O: Using Async/Await for Computational Scheduling Orson Peters Senior Engineer of Query Execution @Polars, (Co-)Author of Stdlib Sort in Rust & Go In the past two years I have developed a new query execution engine for Polars, which not only tries to execute as much of your query in parallel as possible, but in a streaming fashion as well, such that you can process data sets which do not fit in memory. 14:45 Mountbatten (6th Fl.) Session Data Management Looking Under the Hood: Data Processing Systems Performance Tricks (and How to Apply Them to Your Code) Holger Pirk Associate Professor for Data Management Systems at Imperial College London and Avid Runner — Minimizing Cache Misses, Thread Divergence and Aerobic Decoupling Modern data processing systems—databases, analytics engines, vector stores, and stream processors—hide an extraordinary amount of performance engineering beneath their abstractions. 15:55 Windsor (5th Fl.) Session compilers Automatically Retrofitting JIT Compilers Laurence Tratt Shopify / Royal Academy of Engineering Research Chair in Language Engineering @King's College London We as a community have attempted, multiple times, to speed up languages such as Lua, Python, and Ruby by hand-writing JIT compilers. Sometimes we've had short-term success, but the size, and pace of change, of their standard implementations has proven difficult to keep up with over time.