Once you are done with your contribution for the Software Transformation Systems workshop in Portland (co-located with OOPSLA/GPCE), you should start thinking about your contribution to PEPM 2007, which I am chairing together with Ramalingam from IBM.

Last year PEPM broadened its mission from a narrow focus on partial evaluation techniques and applications, to all topics concerned with analysis and manipulation of programs. In particular, the aim is to attract work that applies such techniques to real languages and large code bases. That is, not just design of clever techniques, but also validation of these techniques in practice. The website provides extensive advice for authors of research and tool presentation papers.

  • Program and model manipulation techniques such as transformations driven by rules, patterns, or analyses, partial evaluation, specialization, slicing, symbolic execution, refactoring, aspect weaving, decompilation, and obfuscation.
  • Program analysis techniques that are used to drive program/model manipulation such as abstract interpretation, static analysis, binding-time analysis, dynamic analysis, constraint solving, and type systems.
  • Analysis and transformation for programs/models with advanced features such as objects, generics, ownership types, aspects, reflection, XML type systems, component frameworks, and middleware.
  • Techniques that treat programs/models as data objects including meta-programming, generative programming, staged computation, and model-driven program generation and transformation.
  • Application of the above techniques including experimental studies, engineering needed for scalability, and benchmarking. Examples of application domains include legacy program understanding and transformation, domain-specific language implementations, scientific computing, middleware frameworks and infrastructure needed for distributed and web-based applications, resource-limited computation, and security.

We especially encourage papers that break new ground including descriptions of how program/model manipulation tools can be integrated into realistic software development processes, descriptions of robust tools capable of effectively handling realistic applications, and new areas of application such as rapidly evolving systems, distributed and webbased programming including middleware manipulation, model-driven development, and on-the-fly program adaptation driven by run-time or sttistical analysis.

Yesterday, Brad Alexander from the University of Adelaide visited the Uithof and gave a talk in the Software Technology Colloquium with the title “From Natural Semantics to Stratego”. He explained how he was in the process of converting an implementation of an optimizer for a second-order functional language in natural semantics (using the Centaur system) to a Stratego program using rewrite rules and strategies. As a result of using Stratego, transformations that took hundreds of lines of code could be reduced to only a few.

The exciting thing about his presentation was that the basic Stratego techniques he used were quite unexiting. That is, using the basic ideas of separate rewrite rules and parametric strategies he could greatly simplify his optimizer. I hope to see more of his work in the future.

Brad was on his way to Estonia to deliver a talk at the AMAST 2006 conference.

brad-alexander

Last week I accepted a position as associate professor at the Software Engineering Group of Delft University of Technology. I will join forces there with Arie van Deursen who recently started at TUD as a full professor.

The ambition is to build a strong research group in the area of software engineering, based on our work in software evolution (Arie) and program transformation.

With NWO funding for a project on extensibility of transformation systems and one on model-driven software evolution my tenure at TUD can start full force. Of course, I will continue work on Stratego/XT and applications together with Martin Bravenboer, who will join me at TUD. I also hope to convince Eelco Dolstra to make the move to Delft. We are aiming at setting up a new buildfarm for supporting our own, but hopefully also other research projects.

CGN => mekelweg 4

We just got word from NWO, the dutch national research funding organization, that our project proposal on Model-Driven Software Evolution has been granted. This means that we will have funding to hire two PhD students, a postdoc, and an assistant professor.

The project is a collaboration between Arie van Deursen (principal investigator) and myself and is going to take place at Delft University of Technology, (where I’ll be moving; see next blog).

If you have an interest in program transformation and domain-specific languages, and the ambition to contribute to the state-of-the-art in these areas, then you might consider applying for one of these jobs. Official job adverts will be available later (we really just learned about acceptance), but in the mean time you can contact me if you have questions.

Here is the summary of the research proposal:

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 this project proposes to address.

The first fundamental premise of this proposal is that evolution should be a continuous process. Software development is a continuous search for recurring patterns, which can be captured using domain-specific modeling languages. After developing a number of systems using a particular meta-model, new patterns may be recognized that can be captured in a higher-level or richter meta-model. The second premise is that reengineering of legacy systems to the model-driven paradigm should be a special case of this continuous evolution, and should be performed incrementally.

The goal of this project is to develop a systematic approach to model-driven software evolution. This approach includes methods, techniques, and underlying tool support. We will develop a prototype programming environment that assists software engineers with the introduction, development, and maintenance of models and domain-specific languages.

Together with Magne Haveraaen, Jim Cordy, and Jan Heering, I am organizing the next Workshop on Software Transformation Systems (STS’06), which will be co-located with GPCE and OOPSLA in Portland, Oregon in October. If you are interested in the design, implementation, and use of transformation systems you should consider submitting an abstract. (Note that the webpage is being updated, so check back on details of submissions.) If it will be like last time, it promisses to be a lively day full of interesting discussions.