An Introduction to Program Transformation

Abstract: Transformation is a rewriting-based approach to software development and manipulation. A transformation system provides a set of primitives for explicitly controlling the application of rewrite rules to terms. This capability distinguishes transformation systems (also called Strategic programming systems) from pure rewriting systems. In this talk, I will describe transformation and its relationship to rewriting and equational reasoning. I will then give an overview of the HATS transformation system and briefly identify some dimensions along which Oberon programs can be transformed.

OberonDoc - A Preliminary Report

Abstract: Document generation for software systems can be informally understood as a process of summarizing and organizing the information present in the source code of the system. This implies that some information in the souce must be abstracted. For example, document generation systems typically omit the bodies of method declarations providing only the signature of methods. Organization of information can be achieved either by restructing elements of the original source code, or by providing a means to navigate between information that is somehow related.

In this talk, I describe some preliminary results in understanding and developing document generation for Oberon. Specifically, a prototype document generator for Oberon will be presented. The implementation of this prototype is largely transformation-based.

The Fathom System

Abstract: Fathom is a general-purpose document viewing framework. In this framework, one begins by decomposing a document into contents. A (document) view is then defined as a subset of the contents of a document. The set of views for a given document can be related through the sub-set operator. The resulting view-relation forms a lattice with the empty view as the bottom element and the view containing all the document contents as the top element. Transitioning along the edges of this view-lattice is conceptually similar to the zoom mechanism used when viewing electronic representations of maps.

Fathom is a framework based on the ideas described in the previous paragraph. Key challenges faced by Fathom include: (1) automatic decomposition of a document into semantically meaningful contents, (2) design of a suitable view abstraction accompanied by an abstract-to-concrete view generation function, and (3) automated support for navigating across the resulting view-lattice (e.g., transitioning between views) and browsing the resulting concrete views.

Higher-Order Transformation and the Distributed Data Problem
Abstract and Bio

Abstract: The control mechanisms offered by strategic programming have been successfully used to address a variety of problems relating to confluence and termination. However, the application of strategic programming to problems of increasing complexity has raised another issue, namely how auxiliary data fits within a strategic framework. The distributed data problem characterizes the problem posed by auxiliary data. This problem arises from a discord between the semantic association of terms within a specification and the structural association of terms resulting from the term language definition. My research is based on the premise that higher-order rewriting provides a mechanism for dealing with auxiliary data conforming to the tenets of rewriting. In a higher-order framework, the use of auxiliary data is expressed as a rule. Instantiation of such rules can be done using standard (albeit higher-order) mechanisms controlling rule application (e.g., traversal). Typically, a traversal-driven application of a higher-order rule will result in a number of instantiations. If left unstructured, these instantiations can be collectively seen as constituting a rule base whose creation takes place dynamically. However, such rule bases again encounter difficulties with respect to confluence and termination. In order to address this concern the notion of strategy construction is lifted to the higher-order as well. That is, instantiations result in rule bases that are structured to form strategies. Nevertheless, in many cases, simply lifting first-order control mechanisms to the higher-order does not permit the construction of strategies that are sufficiently refined. This difficulty is alleviated traditional control mechanisms enables a variety of instances of the distributed data problem to be elegantly solved in a higher-order setting. These ideas are formalized in a higher-order strategic programming language called TL.

Study of an API migration for two XML APIs
slides paper
Guest Speaker: Dr. Ralf Lämmel

Abstract: API migration refers to adapting an application such that its dependence on a given API (the source API) is eliminated in favor of depending on an alternative API (the target API), where both APIs serve the same domain. One may attempt to automate API migration by code transformation or wrapping of some sort. API migration is relatively well understood for the special case where source and target APIs are essentially different versions of the same API. API migration is much less understood for the general case where the two APIs have been developed more or less independently of each other. The present paper exercises a simple instance of the general case and develops engineering techniques towards the mastery of API migration. That is, we study wrapper-based migration between two prominent XML APIs for the Java platform. The migration follows an iterative and test-driven approach and allows us to identify, classify, and measure various differences between the studied APIs in a systematic way. The talk is based on a paper that has been presented at the 2nd International Conference on Software Language Engineering. Joint work with Thiago Tonelli Bartolomei, Krzysztof Czarnecki (both University of Waterloo), and Tijs van der Storm (CWI, Amsterdam)

Bio: Ralf Lämmel is Full Professor of Computer Science at the University of Koblenz-Landau since July 2007. He received his PhD in Computer Science from the University of Rostock in 1999. In the years 1999-2007, he has served on positions at the Dutch Centre of Mathematics and Computer Science, VU University Amsterdam, and Microsoft in Redmond. Ralf Lämmel's speciality is "software language engineering" and the combination of software engineering and programming languages. His research and teaching interests include program transformation, generative programming, programming languages, type systems, generic language technology, grammar-based methods, advanced separation of concerns, and automated software engineering. Ralf Lämmel is co-founder of the International Summer School Series Generative and Transformational Techniques on Software Engineering (GTTSE) and the International Conference on Software Language Engineering (SLE).