Generative and Transformational Techniques in Software Engineering

As an emerging solution to the handling of complex and evolving software systems, Model Driven Engineering (MDE) is still very much in evolution. The industrial demand is quite high while the research answer for a sound set of foundation principles is still far from being stabilized. Therefore it is important to provide a current state of the art in MDE, describing what its origins are, what its present state is, and where it seems to be presently leading. One important question is how MDE relates to other contemporary technologies. This tutorial proposes the ”technical space” concept to this purpose. The two main objectives are to present first the basic MDE principles and second how these principles may be mapped onto modern platform support. Other issues that will be discussed are the applicability of these ideas, concepts, and tools to solve current practical problems. Various organizations and companies (OMG, IBM, Microsoft, etc.) are currently proposing several environments claiming to support MDE. Among these, the OMG MDA^TM(Model Driven Architecture) has a special place since it was historically one of the original proposals in this area. This work focuses on the identification of basic MDE principles, practical characteristics of MDE (direct representation, automation, and open standards), original MDE scenarios, and discussions of suitable tools and methods.

A meta-programming technique known as reflection can be regarded as a sophisticated programming interface for program transformation. It allows software developers to implement various useful program transformation without serious efforts. Although the range of program transformation enabled by reflection is quite restricted, it covers a large number of interesting applications. In particular, several non-functional concerns found in web-application software, such as distribution and persistence, can be implemented with program transformation by reflection. Furthermore, a recently emerging technology known as aspect-oriented programming (AOP) provides better and easier programming interface than program transformation does. One of the roots of AOP is reflection and thus this technology can be regarded as an advanced version of reflection. In this tutorial, we will discuss basic concepts of reflection, such as compile-time reflection and runtime reflection, and its implementation techniques. The tutorial will also cover connection between reflection and aspect-oriented programming.

In the database engineering realm, the merits of transformational approaches, that can produce in a systematic way correct, compilable and efficient database structures from abstract models, has long be recognized. Transformations that are proved to preserve the correctness of the source specifications have been proposed in virtually all the activities related to data structure engineering: schema normalization, logical design, schema integration, view derivation, schema equivalence, data conversion, reverse engineering, schema optimization, wrapper generation and others. This paper addresses both fundamental and practical aspects of database transformation techniques. The concept of transformation is developed, together with its properties of semantics-preservation (or reversibility). Major database engineering activities are redefined in terms of transformation techniques, and the impact on CASE technology is discussed. These principles are applied to database logical design and database reverse engineering. They are illustrated by the use of DB-MAIN, a programmable CASE environment that provides a large transformational toolkit.

The world of program optimization and transformation takes on a new fascination when viewed through the lens of program calculation. Unlike the traditional fold/unfold approach to program transformation on arbitrary programs, the calculational approach imposes restrictions on program structures, resulting in some suitable calculational forms such as homomorphisms and mutumorphisms that enjoy a collection of generic algebraic laws for program manipulation. In this tutorial, we will explain the basic idea of program calculation, demonstrate that many program optimizations and transformations, such as the optimization technique known as loop fusion and the parallelization transformation, can be concisely reformalized in calculational form, and show that program transformation in calculational forms is of higher modularity and more suitable for efficient implementation.

Whatever programming paradigm for data processing we choose, data has the tendency to live on the other side or to eventually end up there. The major paradigms for data processing are Cobol, object, relational and XML; each paradigm offers many facets and many versions; each paradigm provides specific forms of data models (object models, relational schemas, XML schemas, etc.). Each data-processing application depends on a horde of interrelated data models and artifacts that are derived from data models (such as data-access layers). Such conglomerations of data models are challenging due to paradigmatic impedance mismatches, performance requirements, loose-coupling requirements, and others. This ubiquitous problem calls for a good understanding of techniques for mappings between data models, actual data, and operations on data. This tutorial lists and discusses mapping scenarios, mapping techniques, impedance mismatches and research challenges regarding mappings.

Model-driven software engineering promotes the use of models and transformations as primary artifacts. Several formalisms can be used for the specification of model transformations. We propose to represent models as graphs, and model transformations as graph transformations. In particular, we focus on the activity of model refactoring, and show how graph transformation theory can provide formal support for this activity. We also show how such support can be implemented in state-of-the-art graph transformation tools such as AGG and Fujaba, and provide two concrete experiments. Critical pair analysis in AGG enables the analysis of dependencies between model refactorings. The round-trip engineering facility of Fujaba enables the automatic generation of code for model refactorings.

Forms2Net is an ATX Software commercial reengineering tool that automatically converts Oracle Forms applications to the equivalent .NET (C#) ones, with approximately 75% rate of automatic conversion. From the reengineering and transformation theoretical viewpoint, Forms2Net falls in the general category of language-platform conversion tools. As theory and practice indicate, for such tools to be effective, there are two major issues that must be handled: (a) the resolution of the semantic gap between the pair of source-target languages and (b) the resolution of the dependencies (e.g., API dependencies) on functionalities provided by default by the source platform or on programming idiosyncrasies of the source platform (in this case Oracle Forms). This paper presents the important practical aspects of Forms2Net and the underlying technology. We discuss the semantic gap between Oracle Forms and .NET forms and the design principles and solution strategies used to bridge this gap.

Generic language technology research focuses on the development of fundamental techniques for language processing. The Asf+Sdf Meta-Environment, an interactive development environment for the automatic generation of interactive systems, is an example of research in this field. The Meta-Environment has been applied in various projects in order to enable the development of high quality tools for the analysis and transformation of large software systems written in languages such as C, Java, Cobol, and PL/I. The Meta-Environment offers the interactive construction of language definitions and the generation of tools given these definitions. Over the years, this system has been used in a variety of academic and industrial projects ranging from formal program manipulation to conversion of industrial Cobol systems.

General-purpose programming languages provide limited facilities for expressing domain-specific concepts in a natural manner. All domain concepts need to be captured using the same generic syntactic and semantic constructs. Generative programming methods and program transformation techniques can be used to overcome this lack of abstraction in general-purpose languages.

In this tutorial we describe the MetaBorg method for embedding domain-specific languages, tailored syntactically and semantically to the application domain at hand, in a general-purpose language. MetaBorg is based on Stratego/XT, a language and toolset for the implementation of program transformation systems, which is used for the definition of syntactic embeddings and assimilation of the embedded constructs into the surrounding code.

Syntactic analysis lies at the heart of many transformation tools. Grammars are used to provide a structure to guide the application of transformations. Agile parsing is a technique in which grammars are adapted on a transformation by transformation basis to simplify transformation tasks. This paper gives an overview of agile parsing techniques, and how they may be applied to Web Applications. We give examples from several transformations that have been used in the Web application domain.

Data quality problems arise in different application contexts and require appropriate handling so that information becomes reliable. Examples of data anomalies are: missing values, the existence of duplicates, misspellings, data inconsistencies and wrong data formats. Current technologies handle data quality problems through: (i) software programs written in a programming language (e.g., C or Java) or an RDBMS programming language, (ii) the integrity constraints mechanisms offered by relational database management systems; or (iii) using a commercial data quality tool. None of these approaches is appropriate when handling non-conventional data applications dealing with large amounts of information. In fact, the existing technology is not able to support the design of a data flow graph that effectively and efficiently produce clean data.

AJAX is a data cleaning and transformation tool that overcomes these aspects. In this paper, we present an overview of the entire set of functionalities supported by the AJAX system. First, we explain the logical and physical levels of the AJAX framework, and the advantages brought in terms of specification and optimization of data cleaning programs. Second, the set of logical data cleaning and transformation operators is described and exemplified, using the declarative language proposed. Third, we illustrate the purpose of the debugging facility and how it is supported by the exception mechanism offered by logical operators. Finally, the architecture of the AJAX system is presented and experimental validation of the prototype is briefly referred.

Fujaba is an UML [21] based CASE tool with an emphasis on code generation from graphical behavior specifications. The Fujaba tool is accompanied by the Fujaba process, a systematic approach to use Fujaba for system development [5]. To improve the tool support for the Fujaba process, we have developed the XProM plug-in. This paper exemplifies how the XProM plug-in supports the tool developer in following the Fujaba Process. Main parts of this paper are a tutorial to XProM users. However, the paper is also useful for other CASE tool developers as a guide how developers could be supported. Therefore, we also give some hints, how such a support may be realized. As a running example we use the development of model transformations for a simple statechart editor.

Program analyses and transformations are means to support program evolution and bridge architectural mismatches in component composition. The Program Structures Group at the University of Karlsruhe und the FZI Karlsruhe, that we are or have been members of, have developed a suite of program analysis and transformation tools to attack these problems.

The basic tool Recoder offers sophisticated source code analyses and a library of common transformations in the form of Java meta programs to perform necessary component and interaction adapations. This library can be extended by the Recoder framework that offers means for implementing custom transformations. A transformation can also be a generator to produce glue code, for example.

Inject/J uses Recoder and offers a comfortable scripting language for implementing transformations. The scripting language combines declarative specifications of the program points, where the transformation should be applied, with imperative specifications of the transformation itself.

COMPASS is focused on bridging interaction mismatches among software components. It introduces architectural elements like components, ports and aspect-oriented connectors as source code transformations based on the Recoder framework.

COMPOST defines the general model of invasive software composition, where the ports of the COMPASS model are just one kind of hooks. Hooks are join points, i.e. part of a component that may be extended or replaced.

This article gives an overview of a transformation system called HATS – a freely available platform independent IDE facilitating experimentation in transformation-oriented software development. Examples are discussed highlighting how the transformational abstractions provided by HATS can be used to solve various problems.

Feature Models are used in different stages of software development and are recognized to be an important asset in model transformation techniques and software product line development. The automated analysis of feature models is being recognized as one of the key challenges for automated software development in the context of Software Product Lines. In our previous work we explained how a feature model can be transformed into a constraint satisfaction problem. However cardinalities were not considered. In this paper we present how a cardinality-based feature model can be also translated into a constraint satisfaction problem. In that connection, it is possible to use off-the-shelf tools to automatically accomplish several tasks such as calculating the number of possible feature configurations and detecting possible conflicts. In addition, we present a performance test between two off-the-shelf Java constraint solvers. To the best of our knowledge, this is the first time a performance test is presented using solvers for feature modelling proposes

The paper adresses the problem of consistency preservation in data intensive applications evolution. When the database structure evolves, the application programs must be changed to interface with the new schema. The latter modification can prove very complex, error prone and time consuming. We describe a comprehensive transformation/generative approach according to which automated program transformation can be derived from schema transformation. The proposal is illustrated in the particular context of database reengineering, for which a specific methodology and a prototype tool are presented. Some results of two case studies are described.

Name analysis for Java is challenging with its complex visibility rules involving nested scopes, inheritance, qualified access, and syntactic ambiguities. We show how Java name analysis including ambiguities related to names of variables, fields, and packages, can be implemented in a declarative and modular manner using the JastAdd compiler construction system.

Declarative attributes and context-dependent rewrites enable the implementation to be modularized in the same way as the informal Java language specification. The individual rules in the specification transfer directly to equations in the implementation. Rewrites are used to define new concepts in terms of existing concepts in an iterative manner in the same way as the informal language specification. This enables equations to use both context-free and context-dependent concepts and leads to improved separation of concerns. A full Java 1.4 compiler has been implemented to validate the technique.

This paper presents an exercise to facilitate refactoring techniques not only on generated code, but also on generator templates by reusing existing refactoring techniques from the target language. Refactoring is particularly useful if not only the generated classes but also the template defining the result of the code generator can be adapted in a uniform treatment. We describe a simple demonstration prototype that illustrates our approach. The demonstration is based on the idea to define the templates for code generation themselves as compilable and therefore refactorable source code. However, this limits the directives embedded in the template used for code generation, as we have to embed those as comments. We explore how far this approach carries and where its limits are.

One important field of application for embedded real-time systems is in the telecommunications industry. In the first phase of the E-CARES reengineering project, we regarded the architecture modeling and the reverse engineering of telecommunication systems. Current work concerns the restructuring of such systems including their re-design and re-implementation. The aim is to provide concepts, languages, methods, and tools to improve the architecture and the real-time performance of the software system. Our reengineering prototype is based on a graph rewriting system by which the underlying application logic is generated.

Separation of concerns and collaboration based design is usually a suitable concept for library implementation: it results in easily scalable and maintainable code. After specifying and implementing orthogonal features, we aim to easily assemble library components. In real life, components can be used only after appropriate refinement steps, progressively adding features in each step. Therefore the specific solution for a particular task can be produced by composing a set of refined components. Unfortunately, a subtype anomaly occurs in object-oriented languages between such composite components that have different numbers of features from different refinement stages. In this article we analyse this anomaly that we named chevron-shape inheritance and present a framework based on standard C++ template metaprogramming.