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

The TFA 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

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.


Strategic Programming

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.


Program Optimization

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)
  • inlining
  • data-flow optimization (constant-propagation, dead code elimination, etc.)
  • vectorization
  • 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


Syntax Definition

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 page.

Revision: r1.11 - 17 Jun 2007 - 14:20 - EelcoVisser
EelcoVisser > ResearchInterests
Copyright © 2003-2017, Software Engineering Research Group, Delft University of Technology, The Netherlands