I have a broad interest in all areas of software engineering.
My research is motivated by productivity tools for software engineers.
My research activities are concerned with different areas of software engineering:
Model-Driven Software Evolution
The promise of model-driven engineering (MDE) is that the development and maintenance effort can be reduced by working at the model instead of the code level. Models define what is variable in a system, and code generators produce the functionality that is common in the application domain.
The problem with model-driven engineering is that it can lead to a lock-in in the abstractions and generator technology adopted at project initiation. Software systems need to evolve, and systems built using model-driven approaches are no exception. What complicates model-driven engineering is that it requires multiple dimensions of evolution. In regular evolution, the modeling language is used to make the changes. In meta-model evolution, changes are required to the modeling notation. In platform evolution, the code generators and application framework change to reflect new requirements on the target platform. Finally, in abstraction evolution, new modeling languages are added to the set of (modeling) languages to reflect increased understanding of a technical or business domain. While MDE has been optimized for regular evolution, presently little or no support exists for metamodel, platform and abstraction evolution. It is this gap that the MoDSE
project proposes to address.
Language Extensibility: Transformations for Abstractions
project is about techniques at the intersection of two areas of software engineering. (1) In order to automate software engineering we would like to automate the process of producing programs by means of automatic transformations, thereby computing with programs as we do with other data. (2) In order to improve the expressivity of programming languages to the concepts and notations of specific application domains, we would would like to extend general-purpose languages with domain-specific abstractions. Combining these desiderata leads to the need to extend transformations for new domain-specific abstractions.
The goal of the TFA
project is to develop a systematic approach to the extension of general purpose languages with domain-specific abstractions, integrating those abstractions in the syntax and transformations of the programming environment.
Software Configuration and Deployment
Managing the variability in software systems is rapidly becoming an important factor in software development. Instead of developing and deploying a fixed one-of-a-kind system, it is now common to develop a family of systems whose members differ with respect to functionality or technical facilities offered.
In the TraCE
project we study the modeling and realization of variability in modern software systems with an emphasis on a more general and generic treatment of timing-issues for variant addition/removal and binding of variation points, the related effects and the opportunities for optimization. The vehicle for the research is the development of a framework for transparent configuration environments
which present a uniform interface to a variety of underlying configuration mechanisms, thus closing the current gap between variability at the conceptual and implementation levels.
Program transformation aims at increasing programmer productivity by automating programming tasks, thus enabling programming at a higher-level of abstraction, and increasing maintainability and re-usability.
Many systems for program transformation exist that are often specialized for a specific object language and/or kind of transformation. All these systems share many ideas about
program transformation and use similar techniques, but are often ad-hoc in many respects. The goal of my research in this area is to achieve a specification language or family of specification languages for the high-level specification of program transformation systems in which generic, language independent schemas of transformation can be captured, and which admits efficient implementation of those transformations that can scale up to large programs.
In the StrategoXT
project we are developing Stratego, a transformation language based on
the paradigm of term rewriting with programmable rewriting strategies, and the XT toolset,
supporting the syntactical infrastructure of transformation systems. The toolset includes
an optimizing compiler for Stratego programs.
Program transformation with rewrite rules under the control of programmable rewriting strategies has lead to the programming paradigm of strategic programming
Programming in this paradigm turns out to be useful for other tasks than program transformation.
Many other operations in which manipulation and exchange of structured data plays
a role can benefit.
Due to the highly generic nature of strategies, programs can be very concise.
Within the StrategoXT
project the strategic programming is explored in various
applications including component composition, package management, and web services.
The strategic program transformation techniques are being
applied in various application areas. One area of particular
interest sets out to validate the claim that
transformation strategies support concise implementation of compiler optimizations
This research has produced strategic idioms for many optimizations, including:
- simplification (of functional programs)
- data-flow optimization (constant-propagation, dead code elimination, etc.)
- instruction selection
These ideas are being applied and further explored in the context of several compilers or compiler components:
- Stratego Optimizer
- Tiger Compiler
- Helium Optimizer
- Warm fusion for Haskell Core
- Octave Compiler
- Optimizer for AutoBayes Intermediate Representation
Producing and maintaining parsers for large languages
requires a declarative syntax definition formalism from
which parsers can be generated. SDF2 is a modular syntax
definition formalism that integrates lexical and
context-free syntax and supports arbitrary context-free
grammars. Since the formalism is declarative, syntax
definitions can be used to generate other tools from, e.g.,
pretty-printers and data type definitions. I developed
SDF2 as part of my PhD
research at the University of Amsterdam.
The language and tools are maintained and further developed at
CWI. Some publications in this area:
More publications at the Syntax Definition