Carl Friedrich Bolz-Tereick

I am a researcher interested in the efficient implementation of dynamic programming languages, currently on sabbatical. I live in Duisburg. I used to work with Laurence Tratt as a member of the Software Development Team at King's College London from 2013-2016. Before, I was at Hasso-Plattner-Institute Potsdam with Robert Hirschfeld and Heinrich-Heine-Universität Düsseldorf with Michael Leuschel. I received my PhD from HHU Düsseldorf in 2013.

My main research interests are techniques for the efficient implementation of dynamic programming languages. I am interested in tracing JITs, optimizations, partial evaluation, particularly at runtime. I am a member of the Python Software Foundation.

Contact

Projects

I am mainly involved in the PyPy project, as well as projects around it:

  • RPython and its JIT: RPython is a project that tries to make implementing dynamic languages a lot easier by providing a toolchain that helps with various things such as garbage collection and most importantly, a good JIT compiler. The long-term vision of PyPy is to realize the vision of really efficient dynamic programming languages without too much implementation effort on the side of the language implementors. I work on many aspects of core RPython development, most importantly its meta-tracing JIT compiler. (mercurial)
  • PyPy: The most important application of RPython is PyPy, a fast and compatible Python interpreter written in RPython. I have been a core developer in the PyPy project since 2005 and have worked on almost all aspects of the interpreter.
  • Pyrolog: Pyrolog is a Prolog implementation in RPython that I wrote for my Bachelor's thesis. The execution engine and many ISO builtins are implemented. David Schneider and I improved on it in 2010 so that it works with PyPy's JIT generator. This makes it a lot faster (but not quite as fast as good C-based VMs). (mercurial)
  • Pycket: Pycket is an implementation of Racket in RPython. (git)
  • RSQueak (formerly called the SPy VM): RSQueak is an implementation of a Smalltalk VM in RPython that tries to be compatible with Squeak images. I was at the SPy sprint in 2007 that started the project and have helped out on various aspects since then. (git)
  • JitPL: JitPL is a dynamic (i.e. just-in-time) partial evaluator for Prolog that I wrote for my Master's thesis. It has no relation with PyPy on the code level. However, it served to prototype some ideas for the PyPy JIT generator and continues to do so in its newer incarnations. (svn)

Publications

A list of my publications (they can also be found on my Google Scholar page):

2016

Fine-grained Language Composition: A Case Study Edd Barrett, Carl Friedrich Bolz, Lukas Diekmann, Laurence Tratt ECOOP 2016, July 2016
Making an Embedded DBMS JIT-friendly Carl Friedrich Bolz, Darya Kurilova, Laurence Tratt ECOOP 2016, July 2016
Adaptive Just-in-time Value Class Optimization for Lowering Memory Consumption and Improving Execution Time Performance Tobias Pape, Carl Friedrich Bolz, Robert Hirschfeld To appear, Science of Computer Programming, June 2016
Virtual Machine Warmup Blows Hot and Cold Edd Barrett, Carl Friedrich Bolz, Rebecca Killick, Vincent Knight, Sarah Mount, Laurence Tratt Draft, February 2016

2015

Language-independent Storage Strategies for Tracing-JIT-based Virtual Machines Tobias Pape, Tim Felgentreff, Robert Hirschfeld, Anton Gulenko, Carl Friedrich Bolz DLS 2015, August 2015
Pycket: A Tracing JIT For a Functional Language Spenser Baumann, Carl Friedrich Bolz, Robert Hirschfeld, Vasily Kirilichev, Tobias Pape, Jeremy Siek, Sam Tobin-Hochstadt ICFP 2015, August 2015
Adaptive Just-in-time Value Class Optimization Carl Friedrich Bolz, Robert Hirschfeld, Tobias Pape Object Oriented Programming Languages and Systems (OOPS), ACM SAC, April 2015
Approaches to Interpreter Composition Edd Barrett, Carl Friedrich Bolz, Laurence Tratt Computer Languages, Systems, and Structures, March 2015
The Impact of Meta-tracing on VM Design and Implementation Carl Friedrich Bolz, Laurence Tratt Science of Computer Programming, 98(3):408-421, February 2015

2014

Meta-tracing Makes a Fast Racket Carl Friedrich Bolz, Tobias Pape, Jeremy Siek, Sam Tobin-Hochstadt Dynamic Languages and Applications (Dyla), June 2014

2013

Storage Strategies for Collections in Dynamically Typed Languages Carl Friedrich Bolz, Lukas Diekmann, Laurence Tratt Object-Oriented Programming, Systems, Languages & Applications (OOPSLA), pages 167-182, October 2013
Unipycation: A Case Study in Cross-language Tracing Edd Barrett, Carl Friedrich Bolz, Laurence Tratt Virtual Machines and Intermediate Languages (VMIL), October 2013

2012

Loop-Aware Optimizations in PyPy’s Tracing JIT Håkan Ardö, Carl Friedrich Bolz, Maciej Fijałkowski Proc. Dynamic Languages Symosium (DLS), October 2012
The Efficient Handling of Guards in the Design of RPython’s Tracing JIT David Schneider, Carl Friedrich Bolz Proc. Workshop on Virtual Machines and Intermediate Languages (VMIL), October 2012
The Functional Programming Language R and the Paradigm of Dynamic Scientific Programming Baltasar Trancón y Widemann, Carl Friedrich Bolz, Clemens Grelck Trends in Functional Programming, June 2012

2011

Runtime Feedback in a Meta-Tracing JIT for Efficient Dynamic Languages Carl Friedrich Bolz, Antonio Cuni, Maciej Fijałkowski, Michael Leuschel, Samuele Pedroni, Armin Rigo Proc. Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS), July 2011
Allocation Removal by Partial Evaluation in a Tracing JIT Carl Friedrich Bolz, Antonio Cuni, Maciej Fijałkowski, Michael Leuschel, Samuele Pedroni, Armin Rigo Proc. Partial Evaluation and Program Manipulation (PEPM), January 2011

2010

Towards a Jitting VM for Prolog Execution Carl Friedrich Bolz, Michael Leuschel, David Schneider Proc. Principle and Practice of Declarative Programming (PPDP), July 2010
Jitting Prolog for Fun and Profit David Schneider, Carl Friedrich Bolz, Michael Leuschel Proc. Dynamic Languages and Applications (DYLA), June 2010

2009

Towards Just-in-time Partial Evaluation of Prolog Carl Friedrich Bolz, Michael Leuschel, Armin Rigo Proc. Logic-Based Program Synthesis and Transformation (LOPSTR), September 2009
Tracing the Meta-Level: PyPy's Tracing JIT Compiler Carl Friedrich Bolz, Antonio Cuni, Maciej Fijałkowski, Armin Rigo Proc. Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS), July 2009

2008

Back to the Future in One Week — Implementing a Smalltalk VM in PyPy Carl Friedrich Bolz, Adrian Lienhard, Adrian Lienhard, Nicholas Matsakis, Oscar Nierstrasz, Lukas Diekmann, Armin Rigo, Toon Verwaest Self-Sustaining Systems, May 2008

2007

How to not write a Virtual Machine Carl Friedrich Bolz, Armin Rigo Proc. Dynamic Languages and Applications (DYLA), July 2007

Academic Service

Teaching

In the winter semester 2008/2009 I designed and taught "Dynamic Programming Languages" as part of the Master's in Computer Science together with Armin Rigo. I taught the course a second time in the summer semester 2010, and again in winter semester 2011.

Various

I play the bassoon and sing in a choir.

I sometimes post articles at the PyPy status blog.

Carl Friedrich Bolz

Twitter: