Printer-friendly version

This page gives you an overview of the various topics that are actively researched at the Software Languages Lab.
The topics often overlap with each other, and many researchers are active in more than one topic.

Distribution and Concurrency (DisCo)

DisCo is a group within the Software Languages Lab (SOFT) at the Vrije Universiteit Brussel (VUB) focused on programming languages and tooling for concurrent and distributed systems. In particular, we explore several research topics including debuggers, secure programming technology, and programming abstractions for distributed systems like replicated data types.

Reactive and Event-based Languages & Systems (REBLS)

REBLS focuses on research related to participatory sensing, ambient-oriented programming (AmOP) and reactive programming:
Participatory sensing provides the enabling technology to deploy so-called citizen observatories. Our research is centred around the notion of orchestrating participatory sensing campaigns, more specifically we want to provide configurable construction tools that enable domain experts (but non-ICT-experts) to specify campaigns.
In AmOP, programs operate in mobile environments where connection failure is the rule rather than the exception, e.g. smart phones or tablets connected over a wifi network. This requires new programming techniques to reference and discover remote entities, abstractions to coordinate and interact with remote parties over volatile connections and finally, replication techniques to increase data availability. Today, the REBLS group specialises in the cloud, research that is the result of an evolution from ambient-oriented programming to full-fledged web applications.
The reactive programming paradigm is a paradigm that is generally accepted as well suited for the development of event-driven and interactive applications. Our research in this field is threefold. First, we focus on making the reactive programming paradigm accessible for imperative, mainstream languages. Secondly, we investigate in radical new reactive progamming ideas such as logic reactive programming. Third, we examine how this reactive data can be distributed over multiple machines/hosts.

Big Data Processing (BDP)

The Big Data Processing (BDP) group focuses on the design and implementation of new programming languages for large systems. Large systems include multi- and many-core machines, clusters of small-scale hardware such as raspberry-pies, industry-scale cluster configurations, cloud infrastructure, etc. The Big Data Processing group puts together those involved in advancing the state of the art along the following axes:
Distributed reactive programming models: Applications nowadays have to work under the assumption that the dataset they are operating on is constantly evolving. Any newly arriving datapoint needs to be reactively reflected in the application's behaviour. For this we explore the design and implementation of new distributed push-based reactive programming models.
Multi-paradigm concurrency and distribution models: Over the years many programming models for concurrency and distribution have emerged. Application developers often require different models to implement the various components of their applications. Modern programming languages such as Scala and Clojure have recognised this trend and already integrate different concurrency models. However, currently, the integration does not always preserve the guarantees of each individual model. Therefore, we design and implement new multi-paradigm concurrency and distribution models that can be safely integrated.

Code Analysis and Manipulation (CAMP)

CAMP groups together people involved with the theory and practice of source code analysis and manipulation. Our research advances the state of the art along three main axes:
The first axis considers multi-language systems. Analyses need to consider the impact that annotations as well as embedded domain-specific languages have on the semantics of the host program. The second axis considers the analysis of highly dynamic languages such as Javascript and Scheme. Here, the semantics of higher-order procedures with side-effects have to be taken into account. The third axis considers multiple versions of code in an analysis. Here, the state of the art is challenged by the scale of version repositories and the complexity of the temporal relations between versions. Along these axes, our analyses provide a solid foundation for the validation, transformation and understanding of software systems. We support validation by identifying bug patterns and violations of architectural regularities in code. We apply software transformations to the problems ofAPI migration, automatic parallelization and multi-language refactoring. Finally, we provide support for the understanding of version repositories through advanced visualizations and dedicated query languages