A collection of material that accumulated over time, mostly during my high
school and undergraduate studies can be found under
Archived Material.
Additionally, there are a couple of projects hosted here, which are not
directly integrated in this page:
-
Sep 17, 2024:
Instrumentation-based Profiling on JVMs is Broken!
Last year, we looked at how well sampling profilers work on top of the JVM.
Unfortunately, they suffer from issues such as safepoint bias and may not correctly attribute observed run time to the correct methods because of the complexities introduced by inlining and other compiler optimizations.
-
Jun 18, 2024:
5 Reasons Why Box Plots are the Better Default Choice for Visualizing Performance
Box Plots, Or Better!
-
Feb 23, 2024:
Why Are My Bytecode Interpreters Slow? Hunting Truffles with VTune
As part of our work on the AST vs. Bytecode Interpreters paper,
I briefly looked at how the native code of ahead-of-time-compiled bytecode loops looks
like, but except for finding much more code than what I expected,
I didn’t look too closely at what was going on.
-
Feb 13, 2024:
Rank 10 Language Implementations
Please rank 10 language implementations by their median performance, based on your best guess or estimate.
-
Nov 17, 2023:
The Changing “Guarantees” Given by Python's Global Interpreter Lock
In this blog post, I will look into the implementation details of CPython’s Global Interpreter Lock (GIL)
and how they changed between Python 3.9 and the current development branch that will become Python 3.13.
-
Oct 16, 2023:
Which Interpreters are Faster, AST or Bytecode?
This post is a brief overview of our new study of
abstract-syntax-tree and bytecode interpreters
on top of RPython and the GraalVM metacompilation systems,
which we are presenting next week at OOPSLA.
-
Sep 20, 2023:
Don't Blindly Trust Your Java Profiler!
How do we know on what to focus our attention
when trying to optimize the performance of a program?
I suspect at least some of us will reach for sampling profilers.
They keep the direct impact on the program execution low,
and collect stack traces every so often during the program execution.
This gives us an approximate view of where a program spends its time.
Though, this approximation as it turns out can be surprisingly unreliable.
-
Sep 11, 2023:
An Introduction to Interpreters and JIT Compilation
Last week, I gave two lectures at the Programming Language Implementation Summer School (PLISS).
PLISS was very well organized and the students
and other presenters made for a very enjoyable week
of new ideas, learning, and discussing.
-
Jun 6, 2023:
Squeezing a Little More Performance Out of Bytecode Interpreters
-
Nov 8, 2022:
How Effective are Classic Lookup Optimizations for Rails Apps?
We know
that Ruby and especially Rails applications can be very dynamic and pretty large.
Though, many of the optimizations interpreters and even just-in-time compilers
use have been invented in the 1980s and 1990s before Ruby and Rails even existed.
So, I was wondering: do these optimizations still have a chance of coping
with the millions of lines of Ruby code that
large Rails apps from Shopify, Stripe, or GitLab have?
Unfortunately, we don’t have access to such applications.
As the next best thing, we took the largest Ruby benchmarks we could get our
hands on, and analyzed those.
I am working at the
School of Computing
at the University of Kent. My work focuses on programming language
implementation techniques, complex concurrent systems, and tooling.