C++ in Practice: Type Erasure & JIT Compilation

The next C++ Meetup Berlin hosted by think-cell takes place on Monday, September 28.

Join us for an evening with the Berlin C++ community! This meetup is a chance to step away from your day-to-day work, meet other developers, exchange ideas, and have real conversations about modern C++ in a relaxed setting.
--------------------------------
📅 Date & Time: Monday, September 28, 2026 – 18:30–22:00
📍 Location: Techspace Kreuzberg (*The Annex*), Lobeckstraße 36-40 10969 Berlin

🕒 Agenda
18:30 – Doors open
19:00 – Talks + Q&A
20:45 – Food, Drinks and Networking
22:00 – Closing doors
--------------------------------

## Talks

### Speaker: Jan Wilczek

Bio: I'm a C++ developer, a conference speaker, and an online course creator from think-cell. My background is in audio plugin and app development. I work from home in Katowice, Poland.
Title: Using Type Erasure to Extend APIs You Don't Own: A Case Study From Audio Plugin Development
Description: Application developers sometimes hit a limitation of a 3rd-party library or framework. The Type Erasure design pattern can help us overcome such limitations without the need to change the 3rd-party API.
Type Erasure is a relatively complex design pattern that allows us to treat a set of unrelated classes as if they shared a common base class, while preserving value semantics. The downside is increased code bloat and code complexity as the pattern requires a significant amount of additional code.
There have been quite a few talks explaining HOW to implement Type Erasure, while the topic of WHEN has been rarely discussed. Should we always use type erasure instead of virtual polymorphism? And if not, then what are the criteria?
This talk will show a concrete example from the audio programming industry of how Type Erasure allowed adding new functionalities to the parameter class system of the JUCE C++ framework without changing its API. As such, the talk will be useful for application and library developers who use 3rd party libraries but need an extra degree of flexibility.
You will come out of the talk understanding

• what Type Erasure is,
• when to use it, and
• how to implement it.

You don't need to understand Type Erasure, audio development, or JUCE to attend the talk; the necessary minimum will be explained during the talk.

### Speaker: Lukas Schwerdtfeger

Bio: Lukas is a PhD student in the Database Systems and Information Management (DIMA) group at TU Berlin and at BIFOLD. His research focuses on concurrency in adaptive stream-processing engines. He works on NebulaStream, a next-generation data-management system designed for stream processing across the sensor–edge–cloud continuum.
Title: Just-in-Time Compilation in C++ with Nautilus
Description: Modern applications often depend on configuration and information that are only available at runtime. This flexibility can come at a cost: critical code paths must repeatedly interpret dynamic state rather than benefit from compile-time optimization.
In this talk, we will explore how just-in-time (JIT) compilation can bridge that gap. After introducing the fundamentals of JIT compilation, we will look at Nautilus, a lightweight tracing JIT compiler for C++. Nautilus traces ordinary C++ code, creates an intermediate representation, and compiles specialized versions for the current runtime context.
Nautilus powers query compilation in NebulaStream, an adaptive data management and stream processing system for the sensor–edge–cloud continuum. Using practical examples from both projects, the talk will demonstrate how JIT compilation can accelerate performance-critical parts of your own C++ applications when their behavior depends on dynamic runtime configuration.

--------------------------------

RSVP now to save your seat!