I did my PhD at the Software Languages Lab of Vrije Universiteit Brussel in Belgium. My research focused on the design of programming languages and techniques for multi-core processors. The ultimate goal is to come up with concepts that are easy to use, but can still exploit the performance of multi-core processors. Here, I’ll try to explain the topic of my PhD in a way that can hopefully be understood even without an academic background.

A red thread throughout the design of programming languages is finding a balance between two competing concerns: reducing complexity and increasing efficiency. A programming language should be easy to use: reducing the complexity of a language will make bugs less likely and increase the productivity of programmers. However, when programming languages become ‘too simple’, they often hide so much from the programmer that programs become less efficient. A good programming language should not prevent a programmer from writing efficient programs. Programming languages attempt to offer a good compromise between simplicity and efficiency.

Around 2005, the first “multi-core” processors became commonplace. These make it possible to run multiple activities at the same time; this is called concurrency. Concurrency is inherently complex, and often leads to difficult bugs. Programming languages should make it easy to introduce concurrency in a program, but without sacrificing efficiency. (Especially as often the whole point of running multiple things at the same time is increasing efficiency.)

This is why researchers came up with “concurrency models”. A concurrency model provides a way to introduce parallelism in a program. However, it also restricts the programmer. This is for the good: due to these restrictions, the concurrency model can provide certain guarantees. These guarantees make it easier for programmers to reason about their program and to avoid bugs. Concurrency models thus aim to find a balance between making efficient parallelism possible, but reducing its complexity.

Many concurrency models have been developed over the past decades. Each of these is suited to solve specific problems that occur in specific scenarios. I however believe that, in a modern and complex application, different problems occur for which different concurrency models are best suited. It is therefore necessary to combine multiple concurrency models.

Unfortunately, these concurrency models have largely been developed to be used in isolation. When different models are combined, the guarantees they normally provide suddenly no longer hold. Combining them is difficult. The goal of my PhD is to solve this: I developed a unified framework of multiple concurrency models that maintains their guarantees, called Chocola. Chocola should make it easier to introduce concurrency in a large and complex application without sacrificying efficiency.

▸ Go to the Chocola website

▸ Download my PhD dissertation