Dirk Deridder

My research interests cover a wide range of topics in the domain of software and programming language engineering. In my current research I investigate an integral and integrated approach to master software variability from a technology perspective (i.e. how to support the implementation of software variability).

Software variability refers to the ability of a system to be efficiently extended, changed, customised, or configured for use in a particular context. Increasing the degree in which a system can cope with variability thus aims at increasing its reusability.

A key challenge in the technological realisation of software variability is to master complexity. The continuous introduction of new or changed functionality in an existing product quickly leads to design erosion, code tangling, constraint violations, etc. In an attempt to counter these problems, developers can rely on a number of existing variability realisation techniques. Some of these are extremely lightweight in terms of development overhead and complexity such as meta programming, parameterisation, inheritance, macro's, etc. In general these imply no profound impact on existing development practices, which means that they can be incrementally adopted. Other techniques have a more heavyweight character and require an overall modus operandi for the development process. Examples are the installation of a software productline or the application of a model driven architecture. Both however require additional infrastructure to govern the software variability (e.g., to verify the consistency of a configuration).

My research entails the creation of demonstrators and prototypical implementations for the software languages, techniques, tools and methodologies envisioned in the research. The variability realisation techniques that I investigate can range from simple framework-alike extensions in an existing general purpose programming language to a tailor-made domain-specific language that provides built-in support to address particular variation concerns. The topics covered include among others:

• Programming language abstractions
  (e.g., annotations, prototype-based extensions, first-class variability)
• Configuration and configuration languages
  (e.g., feature description interpreters, model-based parameterisation)
• Modularisation techniques
  (e.g., aspect-orientated software development, layering).
• Guidelines
  (e.g., best practices, patterns)
• Runtime support
  (e.g., reflective architectures, open implementations)
• Model driven approaches
  (e.g., model transformation, GUI generation)
• Variability management
  (e.g., consistency management, lifecycle management, versioning)