2026-08-11 –, Room 2
Debugging performance and memory issues in Julia often requires combining multiple tools and correlating their outputs. Participants will learn how to use a runtime-level instrumentation approach to analyze and resolve performance issues in real code, including cases that are difficult to diagnose using existing tools.
There are many reasons why a Julia application may run slower than expected, ranging from inefficient code patterns to more subtle issues such as dynamic dispatch, unexpected allocations, or inference failures.
While Julia offers several tools to analyze performance, correlating runtime behavior with source-level causes can still be challenging. This workshop focuses on a runtime instrumentation approach that provides detailed insight into what your program actually executed and how runtime behavior relates to your source code and can find performance and memory issues that are not directly visible in existing tools.
The workshop exists out:
Explain how compiler and runtime instrumentation can be used to understand performance & memory issues.
Walk through concrete workflows to find and fix common & advanced (hidden) issues.
Help participants apply these techniques to their own code or sample code.
The workshop will use CodeGlass, our implementation of this instrumentation approach, to provide hands-on experience. While the underlying instrumentation hooks are under active development for upstream integration into Julia, the implementation used in this session will be available to participants during the workshop.
Participants should bring a laptop. You are welcome to bring your own Julia code to analyze, and sample code will also be provided. Multiple instructors will be available during the hands-on portion.
I am a software engineer at CodeGlass. I mainly work on building profiling instrumentation layers for different programming languages, including Julia.
I like to work on:
- Complex and high performance software
- Low level applications
- Optimizing existing code
Software Architect in ASML working on Julia algorithms in the near real time system.
GitHub
I've been writing code since I was 11. Nearly two decades later, I'm still baffled by the fact that most developers spend only 32% of their time actually coding.
My professors used to say this was just the way things were. But instead of accepting it, I decided to push back. One step at a time.
Why? Because we can.
As developers, we build the tools that move entire industries forward. So why not turn that same energy inward and improve our own?
What I Love:
• Diving deep into complex codebases
• Sharing developer knowledge
• Building powerful tools (like CodeGlass)
• Exploring superconductors and the Meissner effect (hoverboards when?)
• I Like Trains
• Lizard Doggo