These are the papers I've published:

(Or look at my Google Scholar profile or on dblp.)

  • In TOPLAS,

    This is the most complete paper presenting all details of Chocola. We first describe the three constituent models of Chocola – futures, transactions, and actors – and their guarantees. Next, for each pairwise combination, we study which guarantees are broken in a naive combination and ‘fix’ these. This is then unified as Chocola. We briefly describe its implementation in Clojure, and we use three benchmark applications to demonstrate that Chocola can improve their performance for relatively little developer effort. The paper also contains a full formal description of Chocola's semantics and proofs of its guarantees.


    This is an earlier paper presenting Chocola; quite a bit shorter than the one above (and therefore maybe easier to get started with). It builds upon our previous work to unify futures, actors, and transactions in one framework. While naive combinations of these three models break the guarantees they normally provide, Chocola maintains these guarantees wherever possible. Using several benchmarks, we show that using Chocola developers can maximally exploit parallelism while certain bugs are prevented.

  • In SEPS at SPLASH,

    This paper introduces transactional actors, a combination of the actor model with Software Transactional Memory. By using transactions in an actor, memory can be shared safely between actors. By using the actor model in a transaction, transactions can communicate. Hence, transactional actors combine transactions and actors while maintaining their properties.

  • In DLS at SPLASH,

    This paper explores a novel idea in the realm of object-oriented programming languages that support multiple inheritance. Mechanisms for multiple inheritance have previously been classified as explicit or implicit, and static or dynamic. This paper introduces just-in-time inheritance, the first dynamic and implicit multiple inheritance mechanism. Just-in-time inheritance appears to be applicable to model an “is-a OR is-a”-relation between superclasses rather than the more traditional “is-a AND is-a”-relation.

  • In ECOOP,

    This paper introduces transactional tasks: a construct that allows futures to be created in a transaction. They make it possible to exploit the parallelism inside a transaction, while providing safe access to the state of their encapsulating transaction. Transactional tasks have several useful properties: they are coordinated, they maintain serializability, and they do not introduce non-determinism. We also demonstrate that introducing transactional tasks in programs with transactions can improve performance.


    This paper is a case study of the combinations of concurrency models in Clojure. Clojure is a programming language that supports six concurrency models. We study all pairwise combinations of these models, noting which ones compose without issues, and which don’t.


    This paper, based on my Master’s thesis, introduces Cloud PARTE, a scalable and elastic event processing system that supports dynamic load balancing. It implements the Rete algorithm and uses the actor model to distribute this algorithm over several machines. By moving the actors between machines, load is balanced at run time. We evaluated this system using a suite of benchmarks, and conclude that Cloud PARTE implements a distributed and elastic system for complex event processing.

  • Master’s thesis, VUB,

    In my Master’s thesis, I developed a scalable, distributed pattern recognition system. It uses Rete, an algorithm to efficiently process events using rules. PARTE, developed at the Software Languages Lab by another Master’s student, parallelized Rete using the actor model. I developed Cloud PARTE, a distributed version of PARTE that spreads the work over multiple machines. It supports dynamic load balancing: the actors become ‘mobile’ and can move from busy to idle machines. We evaluated this system using a suite of benchmarks, and conclude that Cloud PARTE implements a scalable and elastic rule-based pattern recognition system.