Joeri Exelmans

Welcome to my home page!

I'm a PhD student in the domain of software engineering and model-driven engineering, and I am specifically interested in solution spaces to old, new, and non-existent problems, where the following features come together:

versioning / evolution of arbitrary data and their schemas
immutable, content-addressed data (e.g., ERIS)
capability-based security
decentralized, local-first, and somewhat anarchistic technology (e.g., Scuttlebutt)

I'm currently affiliated with the University of Antwerp, Belgium.

Selected publications

Joeri Exelmans, Ciprian Teodorov, Hans Vangheluwe: Operation-based versioning as a foundation for live executable models. Softw. Syst. Model. 24(3): 721-739 (2025) [PDF]

Here we use graph versioning to record changes to both the model and its execution state (during interpretation). We allow the model and its execution state to be altered at any point in time. Since a model's execution state is merely a structural extension of the original model, we pretend that edit operations at runtime occur independently of the ongoing execution, and then merge everything back into the execution state. Edit operations that break the ongoing execution are simply detected as merge conflicts. The demo implementation (click on Live Modeling in the left pane) can still be accessed.
Joeri Exelmans, Jakob Pietron, Alexander Raschke, Hans Vangheluwe: A Virtual Global Monorepo of Immutable Linked Data. MoDELS (Companion) 2024: 1000-1004
[PDF] [slides]

A "vision" workshop paper suggesting a holy combo of content-addressed immutable data and capability-based security (using those hard-to-guess content-based IDs as access tokens) as a foundation for decentralized "model management" in Model-Based Systems Engineering.

PS: Looks like ERIS would be a suitable encoding scheme.
Joeri Exelmans, Jakob Pietron, Alexander Raschke, Hans Vangheluwe, Matthias Tichy: A new versioning approach for collaboration in blended modeling. J. Comput. Lang. 76: 101221 (2023). [PDF]

What if you want to bi-directionally synchronize graph-like data between two ends, while both ends change concurrently? We solve this problem by versioning each end separately, as well as maintaining a versioned correspondence model that "sits on top of" both ends. This keeps the complexities of concurrency and change propagation fully orthogonal to each other.

This differs from most bi-directional transformation approaches (e.g., Triple Graph Grammars) which mutate the correspondence model in-place, making merging and transforming concurrent changes very hard.

We apply our approach to the problem of "blended modeling", which is concurrently editing a model via multiple concrete syntaxes. There is a demo!

Software I wrote

StateBuddy

StateBuddy is a web-based tool for Statechart design, simulation, omniscient debugging and property checking.

It was intended as a little side project to teach university students Statecharts, but it turned out rather nicely. It could probably be developed further into an actual product.

FreeHand

FreeHand is a very minimal multi-touch, pressure sensitive sketching app that runs in the browser.

Links

If you are interested in versioning structured data, also check out:

Jonas Schuermann's website/blog
the work of Leo Olivier.
Jonathan Edwards' paper (and the rest of his blog).
Pijul, a versioning system for text files and directories (like git), but with proper theory behind it.
Eg-walker, a fast & lightweight text CRDT.

Generally interesting computer science stuff:

The kingdoms of objects and values, paper by Friedrich Steimann, 2021.
Understanding WASM, a series of 3 blogposts, answering the question "how does WASM differ from JVM?" aren't both "write once, run anywhere"? It dives into the history of both virtual machines, and goes quite deeply into the topic of virtualization. Very satisfying read.
Also check the related video The Birth & Death of JavaScript.
Capability Myths Demolished, on Capability-Based Security
NixOS, a Linux distro, package manager and build system, where packages and system configurations are immutable values like in a purely functional programming language. Reproducibility is taken seriously. Different versions of the system can exist next to each other without conflicting.