Publications
These are the papers I've published:
(Or look at my Google Scholar profile or on dblp.)
-
This paper introduces zkStream: a framework that leverages signatures and Zero-Knowledge Proofs to add trust to streaming applications. It targets streaming applications that consist of sensors that are installed in the edge, of which the data is processed in an edge cloud by an untrusted party, and then sent to a consumer in the cloud. It guarantees that the data owner can keep their data confidential and that the consumer can rely on the provenance of the data and the computational integrity of the code that processed it. We also introduce two optimizations that make this architecture feasible for real-world applications.
-
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.
-
In my PhD thesis, I first examine and categorize existing concurrency models, and formally define the guarantees they offer. Next, I show that combining multiple models can lead to their guarantees being violated. We then examine futures, transactions, and actors to show which guarantees are violated in each pairwise combination, and how they can be fixed. This is then unified as Chocola, which is implemented and formalized. An evaluation shows how Chocola can improve the performance of three benchmark applications.
-
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.
-
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.
-
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.
-
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.
-
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.