Volume

Dagstuhl Seminar Proceedings, Volume 5161

Publication Details

  • published at: 2006-03-07
  • Publisher: Schloss Dagstuhl – Leibniz-Zentrum für Informatik

Access Numbers

Documents

No documents found matching your filter selection.
Document
DOI: 10.4230/DagSemProc.05161.1
05161 Executive Summary – Transformation Techniques in Software Engineering

Authors: James R. Cordy, Ralf Lämmel, and Andreas Winter

Abstract
TrafoDagstuhl brought together representatives of the research communities in re-engineering, XML processing, model-driven architecture and other areas of software engineering that involve grammar- or schema-driven transformations. These various existing fields and application contexts involve widely varying transformation techniques – the tradeoffs of which are worth analysing. This seminar initiated a process of understanding each other's transformation techniques – their use cases, corresponding methods, tool support, best practises, and open problems. This process makes it possible to exchange knowledge and experience between these various communities. This effort should also help in transposing transformation concepts from established application fields to new fields. This executive summary reports on the conception of the seminar, the program, outcomes and future work. Most of the material from the seminar (including abstracts of all talks) as well as additional papers can be found on the dedicated web site: http://www.dagstuhl.de/05161/
Cite as

James R. Cordy, Ralf Lämmel, and Andreas Winter. 05161 Executive Summary – Transformation Techniques in Software Engineering. In Transformation Techniques in Software Engineering. Dagstuhl Seminar Proceedings, Volume 5161, pp. 1-24, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{cordy_et_al:DagSemProc.05161.1,
  author =	{Cordy, James R. and L\"{a}mmel, Ralf and Winter, Andreas},
  title =	{{05161 Executive Summary – Transformation Techniques in Software Engineering}},
  booktitle =	{Transformation Techniques in Software Engineering},
  pages =	{1--24},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5161},
  editor =	{James R. Cordy and Ralf L\"{a}mmel and Andreas Winter},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05161.1},
  URN =		{urn:nbn:de:0030-drops-4978},
  doi =		{10.4230/DagSemProc.05161.1},
  annote =	{Keywords: Program transformation, transformational programming, generative programming, generative language technology, automated software testing, engineering of metamodels, engineering for XML schemas, engineering of data models}
}
Document
DOI: 10.4230/DagSemProc.05161.2
CAViT: a Consistency Maintenance Framework based on Transformation Contracts

Authors: Pieter Van Gorp and Dirk Janssens

Abstract
Design by contract is a software correctness methodology for procedural and object-oriented software. It relies on logical assertions to detect implementation mistakes at run-time or to proof the absence thereof at compile-time. Design by contract has found a new application in model driven engineering, a methodology that aims to manage the complexity of frameworks by relying on models and transformations. A ``transformation contract'' is a pair of constraints that together describe the effect of a transformation rule on the set of models contained in its transformation definition: the postcondition describes the model consistency state that the rule can establish provided that its precondition is satisfied. A transformation contract of a rule can be maintained automatically by calling the rule (1) as soon as the invariant corresponding to its postcondition is violated and (2) provided that its precondition is satisfied. Domain specific visual languages can facilitate the implementation of the actual transformation rules since they hide the complexity of graph transformation algorithms and standards for tool interoperability. In this talk, we describe CAViT: a framework that integrates a visual model transformation tool with a design by contract tool by relying on OMG standards such as UML, OCL and MOF.
Cite as

Pieter Van Gorp and Dirk Janssens. CAViT: a Consistency Maintenance Framework based on Transformation Contracts. In Transformation Techniques in Software Engineering. Dagstuhl Seminar Proceedings, Volume 5161, pp. 1-27, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{vangorp_et_al:DagSemProc.05161.2,
  author =	{Van Gorp, Pieter and Janssens, Dirk},
  title =	{{CAViT: a Consistency Maintenance Framework based on Transformation Contracts}},
  booktitle =	{Transformation Techniques in Software Engineering},
  pages =	{1--27},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5161},
  editor =	{James R. Cordy and Ralf L\"{a}mmel and Andreas Winter},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05161.2},
  URN =		{urn:nbn:de:0030-drops-4294},
  doi =		{10.4230/DagSemProc.05161.2},
  annote =	{Keywords: Consistency maintenance, metamodeling, transformation, graph rewriting, UML, OCL, MOF}
}
Document
DOI: 10.4230/DagSemProc.05161.3
Experiences in Teaching Program Transformation for Software Reengineering

Authors: Mohammad El-Ramly

Abstract
Little attention is given to teaching the theory and practice of software evolution and change in software engineering curricula. Program transformation is no exception. This paper presents the author’s experience in teaching program transformation as a unit in a postgraduate module on software systems reengineering. It describes the teaching context of this unit and two different offerings of it, one using Turing eXtender Language (TXL) and the other using Legacy Computer Aided Reengineering Environment (Legacy-CARE or L-CARE) from ATX Software. From this experience, it was found that selecting the suitable material (that balances theory and practice) and the right tool(s) for the level of students and depth of coverage required is a non-trivial task. It was also found that teaching using toy exercises and assignments does not convey well the practical aspects of the subject. While, teaching with real, even small size, exercises and assignments, is almost non-feasible. Finding the right balance is very important but not easy. It was also found that students understanding and appreciation of the topic of program transformation increases when they are presented with real industrial case studies.
Cite as

Mohammad El-Ramly. Experiences in Teaching Program Transformation for Software Reengineering. In Transformation Techniques in Software Engineering. Dagstuhl Seminar Proceedings, Volume 5161, pp. 1-6, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{elramly:DagSemProc.05161.3,
  author =	{El-Ramly, Mohammad},
  title =	{{Experiences in Teaching Program Transformation for Software Reengineering}},
  booktitle =	{Transformation Techniques in Software Engineering},
  pages =	{1--6},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5161},
  editor =	{James R. Cordy and Ralf L\"{a}mmel and Andreas Winter},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05161.3},
  URN =		{urn:nbn:de:0030-drops-4230},
  doi =		{10.4230/DagSemProc.05161.3},
  annote =	{Keywords: Teaching Program Transformation, Reengineering, Source to Source Transformation, Software Engineering Education}
}
Document
DOI: 10.4230/DagSemProc.05161.4
g4re: Harnessing GCC to Reverse Engineer C++ Applications

Authors: Nicholas A. Kraft, Brian A. Malloy, and James F. Power

Abstract
In this paper, we describe g4re, our tool chain that exploits GENERIC, an intermediate format incorporated into the gcc C++ compiler, to facilitate analysis of real C++ applications. The gcc GENERIC representation is available through a file generated for each translation unit (TU), and g4re reads each TU file and constructs a corresponding Abstract Semantic Graph (ASG). Since TU files can be prohibitively large, ranging from 11 megabytes for a "hello world" program, to 18 gigabytes for a version of Mozilla Thunderbird, we describe our approach for reducing the size of the generated ASG.
Cite as

Nicholas A. Kraft, Brian A. Malloy, and James F. Power. g4re: Harnessing GCC to Reverse Engineer C++ Applications. In Transformation Techniques in Software Engineering. Dagstuhl Seminar Proceedings, Volume 5161, pp. 1-11, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{kraft_et_al:DagSemProc.05161.4,
  author =	{Kraft, Nicholas A. and Malloy, Brian A. and Power, James F.},
  title =	{{g4re: Harnessing GCC to Reverse Engineer C++ Applications}},
  booktitle =	{Transformation Techniques in Software Engineering},
  pages =	{1--11},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5161},
  editor =	{James R. Cordy and Ralf L\"{a}mmel and Andreas Winter},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05161.4},
  URN =		{urn:nbn:de:0030-drops-4244},
  doi =		{10.4230/DagSemProc.05161.4},
  annote =	{Keywords: Reverse engineering, schema, GXL}
}
Document
DOI: 10.4230/DagSemProc.05161.5
How to make a bridge between transformation and analysis technologies?

Authors: Jurgen Vinju and James R. Cordy

Abstract
At the Dagstuhl seminar on Transformation Techniques in Software Engineering we had an organized discussion on the intricacies of engineering practicle connections between software analysis and software transformation tools. This abstract summarizes it. This discussion contributes mainly by explicitly focussing on this subject from a general perspective, and providing a first sketch of a domain analysis. First we discuss the solution space in general, and then we compare the merits of two entirely di®erent designs: the monolithic versus the heterogeneous approach.
Cite as

Jurgen Vinju and James R. Cordy. How to make a bridge between transformation and analysis technologies?. In Transformation Techniques in Software Engineering. Dagstuhl Seminar Proceedings, Volume 5161, pp. 1-7, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{vinju_et_al:DagSemProc.05161.5,
  author =	{Vinju, Jurgen and Cordy, James R.},
  title =	{{How to make a bridge between transformation and analysis technologies?}},
  booktitle =	{Transformation Techniques in Software Engineering},
  pages =	{1--7},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5161},
  editor =	{James R. Cordy and Ralf L\"{a}mmel and Andreas Winter},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05161.5},
  URN =		{urn:nbn:de:0030-drops-4265},
  doi =		{10.4230/DagSemProc.05161.5},
  annote =	{Keywords: Transformation, analysis, fact extraction, middleware, source code representations}
}
Document
DOI: 10.4230/DagSemProc.05161.6
Megamodelling and Etymology

Authors: Jean-Marie Favre

Abstract
Is a model of a model, a metamodel? Is the relational model a metamodel? Is it a model? What is a component metamodel? Is it a model of a component model? The word MODEL is subject to a lot of debates in Model Driven Engineering. Add the notion of metamodel on top of it and you will just enter what some people call the Meta-muddle. Recently megamodels have been proposed to avoid the meta-muddle. This approach is very promising but it does not solve however the primary problem. That is, even a simple use of the word Model could lead to misunderstanding and confusion. This paper tackles this problem from its very source: the polysemic nature of the word MODEL. The evolution and semantic variations of the word MODEL are modelled from many different perspectives. This papers tells how the prefix MED in indo-european has lead, five millenniums after, to the acronym MDE, and this via the word MODEL. Based on an extensive study of encyclopedias, dictionaries, thesauri, and etymological sources, it is shown that the many senses of the word MODEL can be clustered into four groups, namely model-as-representation, model-as-example, model-as-type, and model-as-mold. All these groups are fundamental to understand the real nature of Model Driven Engineering. Megamodels and Etymology are indeed keys to avoid the Meta-muddle.on.
Cite as

Jean-Marie Favre. Megamodelling and Etymology. In Transformation Techniques in Software Engineering. Dagstuhl Seminar Proceedings, Volume 5161, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{favre:DagSemProc.05161.6,
  author =	{Favre, Jean-Marie},
  title =	{{Megamodelling and Etymology}},
  booktitle =	{Transformation Techniques in Software Engineering},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5161},
  editor =	{James R. Cordy and Ralf L\"{a}mmel and Andreas Winter},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05161.6},
  URN =		{urn:nbn:de:0030-drops-4276},
  doi =		{10.4230/DagSemProc.05161.6},
  annote =	{Keywords: MDE, MDD, MDA, Model Driven Architecture, Model, Metamodel, Etymology, Definition, Taxonomy}
}
Document
DOI: 10.4230/DagSemProc.05161.7
Proofs of Program Properties via Unfold/Fold Transformations of Constraint Logic Programs

Authors: Alberto Pettorossi, Maurizio Proietti, and Valerio Senni

Abstract
In the literature there are various papers which illustrate the relationship between the unfold/fold program transformation techniques and the proofs of program properties both in the case of logic programs and in the case of functional programs.In this paper we illustrate that relationship in the case of constraint logic programs. We build up on results already presented, i.e.,where we have considered logic programs with locally stratified negation. The constraint logic programming paradigm significantly extends the logic-programming paradigm by allowing some of the atoms to denote constraints in a suitably chosen constraint domain. By using those constraints it is often possible to get simple and direct formulations of problem solutions.
Cite as

Alberto Pettorossi, Maurizio Proietti, and Valerio Senni. Proofs of Program Properties via Unfold/Fold Transformations of Constraint Logic Programs. In Transformation Techniques in Software Engineering. Dagstuhl Seminar Proceedings, Volume 5161, p. 1, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{pettorossi_et_al:DagSemProc.05161.7,
  author =	{Pettorossi, Alberto and Proietti, Maurizio and Senni, Valerio},
  title =	{{Proofs of Program Properties via Unfold/Fold Transformations of Constraint Logic Programs}},
  booktitle =	{Transformation Techniques in Software Engineering},
  pages =	{1--1},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5161},
  editor =	{James R. Cordy and Ralf L\"{a}mmel and Andreas Winter},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05161.7},
  URN =		{urn:nbn:de:0030-drops-4225},
  doi =		{10.4230/DagSemProc.05161.7},
  annote =	{Keywords: Program properties, unfold/fold transformation, constraint logic programming}
}
Document
DOI: 10.4230/DagSemProc.05161.8
Tales of ER and RE Syntax and Semantics

Authors: Martin Gogolla

Abstract
This paper explains how four model transformations between database models work: (1) An ER (Entity-Relationship) database schema is transformed into a collection of ER database states, (2) a RE (Relational) database schema into a collection of RE database states, (3) an ER database schema into a RE database schema, and (4) a collection of ER database states into a collection of RE database states. These four separate transformations may be viewed as a single transformation between the ER datamodel and the RE datamodel. The schemas are regarded as determining the syntax of the datamodels, and the set of associated states is regarded as being the semantics of the datamodels, because the states associate meaning with the schemas. When one usually considers database models, one formally only treats syntactical aspects, i.e., schemas, and handles the semantics merely informally. Our approach allows to formally handle syntax and semantics of database models and their transformation within a single and uniform framework. The approach thus allows to precisely describe properties of the datamodels and properties of the transformation. The method behind our approach is to divide a language into a syntax and semantics part and to describe a transformation between two languages as a direction-neutral affair. Formal properties of the languages to be transformed and formal properties of the transformation are described uniformly. Transformation properties can be properties regarding syntax and semantics. The method can be applied not only to database languages but to transformations between common computer science languages.
Cite as

Martin Gogolla. Tales of ER and RE Syntax and Semantics. In Transformation Techniques in Software Engineering. Dagstuhl Seminar Proceedings, Volume 5161, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{gogolla:DagSemProc.05161.8,
  author =	{Gogolla, Martin},
  title =	{{Tales of ER and RE Syntax and Semantics}},
  booktitle =	{Transformation Techniques in Software Engineering},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5161},
  editor =	{James R. Cordy and Ralf L\"{a}mmel and Andreas Winter},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05161.8},
  URN =		{urn:nbn:de:0030-drops-4254},
  doi =		{10.4230/DagSemProc.05161.8},
  annote =	{Keywords: Datamodel transformation, ER datamodel, Relational datamodel, Syntax and semantics of datamodels, Syntax and semantics of transformations, Metamodel}
}
Document
DOI: 10.4230/DagSemProc.05161.9
Termination Criteria for Model Transformation

Authors: Hartmut Ehrig, Karsten Ehrig, Gabriele Taentzer, Juan de Lara, Dániel Varró, and Szilvia Varró-Gyapai

Abstract
Nowadays the usage of model transformations in software engineering has become widespread. Considering current trends in software development such as model driven development (MDD), there is an emerging need to develop model manipulations such as model evolution and optimisation, semantics definition, etc. If a model transformation is described in a precise way, it can be analysed lateron. Models, especially visual models, can be described best by graphs, due to their multi-dimensional extension. Graphs can be manipulated by graph transformation in a rule-based manner. Thus, we specify model transformation by graph transformation. This approach offers visual and formal techniques in such a way that model transformations can be subjects to analysis. Various results on graph transformation can be used to prove important properties of model transformations such as its functional behaviour, a basic property for computations. Moreover, certain kinds of syntactical and semantical consistency properties can be shown on this formal basis.
Cite as

Hartmut Ehrig, Karsten Ehrig, Gabriele Taentzer, Juan de Lara, Dániel Varró, and Szilvia Varró-Gyapai. Termination Criteria for Model Transformation. In Transformation Techniques in Software Engineering. Dagstuhl Seminar Proceedings, Volume 5161, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2006)

Copy BibTex To Clipboard

@InProceedings{ehrig_et_al:DagSemProc.05161.9,
  author =	{Ehrig, Hartmut and Ehrig, Karsten and Taentzer, Gabriele and de Lara, Juan and Varr\'{o}, D\'{a}niel and Varr\'{o}-Gyapai, Szilvia},
  title =	{{Termination Criteria for Model Transformation}},
  booktitle =	{Transformation Techniques in Software Engineering},
  series =	{Dagstuhl Seminar Proceedings (DagSemProc)},
  ISSN =	{1862-4405},
  year =	{2006},
  volume =	{5161},
  editor =	{James R. Cordy and Ralf L\"{a}mmel and Andreas Winter},
  publisher =	{Schloss Dagstuhl -- Leibniz-Zentrum f{\"u}r Informatik},
  address =	{Dagstuhl, Germany},
  URL =		{https://drops.dagstuhl.de/entities/document/10.4230/DagSemProc.05161.9},
  URN =		{urn:nbn:de:0030-drops-4280},
  doi =		{10.4230/DagSemProc.05161.9},
  annote =	{Keywords: Model transformation, graph transformation, consistency}
}

Filters

  • Authors
  • C
  • Cordy, James R.
  • D
  • de Lara, Juan
  • E
  • Ehrig, Hartmut
  • Ehrig, Karsten
  • El-Ramly, Mohammad
  • F
  • Favre, Jean-Marie
  • G
  • Gogolla, Martin
  • J
  • Janssens, Dirk
  • K
  • Kraft, Nicholas A.
  • L
  • Lämmel, Ralf
  • M
  • Malloy, Brian A.
  • P
  • Pettorossi, Alberto
  • Power, James F.
  • Proietti, Maurizio
  • S
  • Senni, Valerio
  • T
  • Taentzer, Gabriele
  • V
  • Van Gorp, Pieter
  • Varró-Gyapai, Szilvia
  • Varró, Dániel
  • Vinju, Jurgen
  • W
  • Winter, Andreas

Any Issues?
X

Feedback on the Current Page

CAPTCHA

Thanks for your feedback!

Feedback submitted to Dagstuhl Publishing

Could not send message

Please try again later or send an E-mail
© 2023-2025 Schloss Dagstuhl – LZI GmbH About DROPS Imprint Privacy Contact