[Jakumeit201441]
Edgar Jakumeit and Sebastian Buchwald and Dennis Wagelaar and Li Dan and Ábel Hegedüs and Markus Herrmannsdörfer and Tassilo Horn and Elina Kalnina and Christian Krause and Kevin Lano and Markus Lepper and Arend Rensink and Louis Rose and Sebastian Wätzoldt and Steffen Mazanek
A survey and comparison of transformation tools based on the
transformation tool contest
in: Science of Computer Programming, Nr.0, Vol.85 Part A, pg.41 - 99, The Web, 2014
ISSN 0167-6423
doi:http://dx.doi.org/10.1016/j.scico.2013.10.009",
http://www.sciencedirect.com/science/article/pii/S0167642313002803",
Special issue on Experimental Software Engineering in the Cloud(ESEiC)[abstract]
Abstract Model transformation is one of the key tasks in model-driven engineering and
relies on the efficient matching and modification of graph-based data structures; its
sibling graph rewriting has been used to successfully model problems in a variety of
domains. Over the last years, a wide range of graph and model transformation tools have
been developed – all of them with their own particular strengths and typical application
domains. In this paper, we give a survey and a comparison of the model and graph
transformation tools that participated at the Transformation Tool Contest 2011. The reader
gains an overview of the field and its tools, based on the illustrative solutions
submitted to a Hello World task, and a comparison alongside a detailed taxonomy. The
article is of interest to researchers in the field of model and graph transformation, as
well as to software engineers with a transformation task at hand who have to choose a tool
fitting to their needs. All solutions referenced in this article provide a \{SHARE\}
demo. It supported the peer-review process for the contest, and now allows the reader to
test the tools online. |
|
[TranconyWidemann2013e]
Trancón y Widemann, Baltasar und Lepper, Markus
Syntaxanalyse auf Wiedervorlage
in: Proceedings 17.\ Kolloquium Programmiersprachen (KPS 2013), Technical Report, Nr.2014/02, pg.151--154,
Picht, R und Zimmermann, W.(Hrsg.)
Institute of Computer Science, Martin-Luther-Universität Halle-Wittenberg, Halle, Wittenberg, 2013
http://wcms.itz.uni-halle.de/download.php?down=35800&elem=2813059
|
[TranconyWidemann2015d]
Trancón y Widemann, Baltasar and Lepper, Markus
Simple and Effective Relation-Based Approaches To XPath and XSLT Type Checking
in: Programmiersprachen und Rechenkonzepte, Arbeitsberichte Computersprachen,
Technische Universität Wien, Wien, 2015 (in press)[abstract]
XPath is a language for addressing parts of an XML document. We give
an abstract interpretation of XPath expressions in terms of
relations on document node types.
Node-set-related XPath
language constructs are mapped straightforwardly onto basic,
well-understood and easily computable relational operations. Hence
our interpretation gives both extremely concise type-level
denotational semantics and a practical analysis tool for the
node-set fragment of the XPath\,1.0 language. This method is part of
the TPath implementation of XPath.
XSL-T is a pure functional language for transforming XML documents.
For the most common case, the transformation into an XML document,
type checking of the transformation code is unfeasible in general, but strongly
required in practice. It turned out that the relational approach of TPath
can be carried over to check all fragments of the result language, which are
contained verbartim in the transformation code. This leads to a technique
called ``Fragmented Validation'' and is part of the txsl implementation of XSL-T. |
|
[calco2014]
Trancón y Widemann, Baltasar and Lepper, Markus
Towards (Co)Algebraic Semantics of the Object-Oriented
Rewriter Style Pattern
in: Calco Early Ideas, Selected Papers, pg.49--62,
Bartek Klin and Monika Seisenberger(edts.)
theWeb, 2014
http://www-compsci.swan.ac.uk/~csmona/CALCO-EI-Selected-Papers.pdf
[abstract]
Conventional object-oriented programming languages provide
expressive, declarative means for data abstraction, but they lack
similarly powerful counterparts for control abstraction. Style
patterns have been developed as informal solutions to the problem.
They fall short of real abstraction, because they mostly give no
criteria how to use imperative language elements in a disciplined
way for denotational semantics to be applied effectively. We
discuss the Rewriter pattern, an extension of the well-known Visitor
pattern, that expresses type-directed rewriting rules for arbitrary
object graphs in a relatively declarative style. We demonstrate how
to ground the Rewriter pattern in coalgebraic recursion theory, in
particular the course-of-argument coiteration scheme, based on a
formal model of object graphs as finite coalgebras. |
|
[d2dTut]
Markus Lepper and Baltasar Trancón y Widemann
D2d - Kreatives Schreiben von XML-codierten Texten
in: Informatik 2016 (GI Jahrestagung), pg.1935-1940,
C. Mayr and Martin Pinzge(edts.)
GI, Bonn, 2016
ISBN 978-3-88579-653-4
|
[isola2014]
Markus Lepper and Baltasar Trancòn y Widemann
Rewriting Object Models With Cycles and Nested Collections
in: Leveraging Applications of Formal Methods, Verification and Validation. Technologies for Mastering Change, LNCS, Vol.8802, pg.445-460,
Margaria, Tiziana and Steffen, Bernhard(edts.)
Springer, Berlin Heidelberg, 2014
ISBN 978-3-662-45233-2
doi:10.1007/978-3-662-45234-9_31
http://dx.doi.org/10.1007/978-3-662-45234-9_31
(Here are the slides.)[abstract]
Metaprogramming with classical compiler technology is similar to
model-based code generation. We discuss a particular tool,
umod, that generates complex data model implementations in
Java, and a particular aspect of its support for declarative
programming: The rewriting of data models in object-oriented
style, based on the visitor pattern, with support for arbitrary
reference graphs and nested collection-valued fields. We
demonstrate that concerns of both compiler theory and model-based
development apply, and that the distinction is overshadowed by a
general commitment to semantic rigour. |
|
[lljava2016]
Baltasar Trancón y Widemann and Markus Lepper
LLJava: Minimalist Structured Programming on the Java Virtual Machine
in: Proc. Principles and Practices of Programming on the Java Platform (PPPJ 2016),
ACM, New York, 2016
ISBN 978-1-4503-4135-6
doi:10.1145/2972206.2972218
http://bandm.eu/metatools/docs/papers/lljava-final.pdf
[abstract]
There is a wide gap in abstraction level between Java source code
and JVM bytecode. Many important software-related tasks, such as
specification and implementation of code synthesis procedures, code
inspection, software understanding and teaching, can benefit from an
adequate, intermediate level of abstraction. Available bytecode
assembly/disassembly tools are ad-hoc and fall short of the
requirements regarding compositionality and clarity. We report on
the design and implementation of the LLJava language that bridges
the gap, based on careful analysis of bytecode information and
rigorous design. |
|
[lt11a]
Lepper, Markus and Trancón y Widemann, Baltasar
Optimization of Visitor Performance by Reflection-Based Analysis
Springer, Berlin, Heidelberg, New York, 2011
ISBN 978-3-642-21731-9
Here are the
slides of ML's talk in Zürich
[abstract]
Visitors are a well-known and powerful design pattern
for processing regular data structures and for combining declarative and
imperative coding styles.
The authors' umod model generator
creates java data models from a concise and algebraic notation.
It is primarily used to model intermediate representations
of computer languages.
The user defines visitor code by
extending skeleton classes, which are generated according to
traversal annotations in the model.
Since the generated code on its own executes the pure traversal and
no semantic side-effects, traversals are redundant unless some
user-overridden method is eventually invoked. We present a
reflection-based control flow analysis to detect this situation and
prune the traversal transparently. With a well-stratified model,
this may lead to substantial increase in performance. |
|
[lt_ddd2013]
Lepper, Markus and Trancón y Widemann, Baltasar
D2d -- XML for Authors
in: Tagungsband des 36ten Jahrestreffens der
GI-Fachgruppe “Programmiersprachen und Rechenkonzepte”, IFI Reports,
University of Oslo, Oslo, 2019
|
[lt_keod2011]
Lepper, Markus and Trancón y Widemann, Baltasar
d2d --- a Robust Front-End for Prototyping, Authoring and Maintaining
XML Encoded Documents by Domain Experts
in: Proceedings of KEOD 2011 International Conference on
Knowledge Engieering and Ontology Design, pg.449-456,
Joaquim Filipe and Jan L.G. Diets(edts.)
SciTePress, Portugal, 2011
ISBN 978-989-8425-80-5
doi:10.5220/0003664904490456
http://bandm.eu/metatools/docs/papers/keod_paper90_lepper_trancon.pdf
This text has been presented as a
poster on the
KEOD 2011 conference.
[abstract]
In many cases, domain experts are used to write down their
knowledge in contiguous texts.
A standard way to facilitate the automated processing of
such texts is to add mark-up, for which
the family of XML-based standards is current best practice.
But the default textual appearance
of XML mark-up
is not suited to be typed, read and edited by humans.
The authors' d2d notation provides an alternative
which uses only one single escape character.
Its documents can be fluently typed, understood
and edited by humans almost in the same way as non-tagged text.
In the last years, the d2d language underwent a development guided by
practical experiences.
In practice, robustness turned out to be
highly desirable: This lead to revised semantics and a new algorithm
which realizes a total translation function,
This article gives the complete operational semantics of this algorithm
after a short sketch of its context. |
|
[lt_ttc2011]
Lepper, Markus and Trancón y Widemann, Baltasar
Solving the TTC 2011 Compiler Optimization Task with meta-tools
in: TTC 2011: Fifth Transformation Tool Contest, EPTCS, Vol.74,
Pieter Van Gorp and Steffen Mazanek and Louis Rose(edts.)
TTC 2011 group, (www), 2011
doi:10.4204/EPTCS.74
(The DOI link brings you to all texts of the EPTCS 74 journal)[abstract]
The authors' metatools are a collection of tools for generic
programming. This includes generating Java sources from mathematically well-founded
specifications, as well as the creation of strictly typed document object
models for XML encoded texts.
In this context, almost every computer-internal structure is
treated as a ``model'', and every computation is a kind of model transformation.
This concept differs significantly from ``classical model transformation'' executed
by specialized tools and languages.
Therefore it seemed promising to the organizers of the
TTC 2011 in Zürich, as well as to the authors, to apply meta-tools
to one of the challenges, namely to the "compiler optimization task",
This is a report on the resulting experiences. |
|
[lt_xslt13]
Lepper, Markus and Trancón y Widemann, Baltasar
Fragmented Validation --- A Simple and Efficient Contribution to XSLT
Checking (Extended Abstract)
in: Proc. ICMT 2013, Int. Conference on Theory and Practice of
Model Transformations, LNCS, Vol.7909,
Springer, Berlin, 2013
ISBN 9783642388835
[abstract]
XSLT 1.0 is a standardized functional programming language and widely
used for defining transformations on XML models and documents,
in many areas of industry and publishing.
The problem of \emph{XSLT type checking} is to verify that
a given transformation, when applied to an input which conforms to
a given structure definition, e.g. an XML DTD, will always produce an output which
adheres to a second structure definition. This problem is known to be
undecidable for the full range of XSLT and document structure definition languages.
Either one or both of them must be significantly restricted,
or only approximations can be calculated.
The algorithm presented here takes a different approach towards type
correct XSLT transformations.
It does not consider the input document at all.
Instead it parses the fragments of the output document contained
verbatim in the transformation code and
verifies that these can potentially appear in the result language,
as defined by a given DTD.
This is a kind of abstract interpretation,
which can be executed on the fly and in linear time when parsing
the XSLT program. Generated error messages are reasonable accurate.
To our practical
experience, this eliminates a considerable share of XSLT programming errors. |
|
[ltw01b]
Lepper, Markus and Trancón y Widemann, Baltasar and Wieland, Jacob
Minimze Mark-Up ! - Natural Writing Should Guide the Design of Textual Modeling
in: Conceptual Modeling -- ER2001, LNCS, Vol.2224,
Springer, Berlin, 2001
ISBN 3-540-42866-6
http://markuslepper.eu/papers/er2001.pdf
|
[paisleyAtps]
Trancón y Widemann, Baltasar and Lepper, Markus
Paisley: A Pattern Matching Library for Arbitrary Object Models
in: Proc. 6. Arbeitstagung Programmiersprachen (ATPS 2013), LNI, Vol.215, pg.171-186,
Stefan Wagner and Horst Lichter(edts.)
Gesellschaft für Informatik, Bonn, 2013
ISBN 978-3-88579-609-1
[abstract]
Professional development of software dealing with structured models
requires more systematic approach and semantic foundation than
standard practice in general-purpose programming languages affords.
One remedy is to integrate techniques from other programming
paradigms, as seamless as possible and without forcing programmers
to leave their comfort zone. Here we present a tool for the
implementation of pattern matching as fundamental means of
automated data extraction from models of arbitrary shape and
complexity in a general-purpose programming language. The interface
is simple but, thanks to elaborate and rigorous design, is also
light-weight, portable, non-invasive, type-safe, modular and
extensible. It is compatible with object-oriented data abstraction
and has full support for nondeterminism by backtracking. The tool
comes as a library consisting of two levels: elementary pattern
algebra (generic, highly reusable) and pattern bindings for
particular data models (specific, fairly reusable, user-definable).
Applications use the library code in a small number of idiomatic
ways, making pattern-matching code declarative in style, easily
writable, readable and maintainable. Library and idiom together
form a tightly embedded domain-specific language; no extension of
the host language is required. The current implementation is in
Java, but assumes only standard object-oriented features, and can
hence be ported to other mainstream languages. |
|
[paisleyControl]
Baltasar Trancón y Widemann and Markus Lepper
A Practical Study of Control in Objected-Oriented--Functional--Logic Programming with Paisley
in: Proc. Functional--Logic Programming (WFLP 2016), Vol.234,
EPTCS, world, 2016
http://eptcs.web.cse.unsw.edu.au/content.cgi?WFLP2016
[abstract]
Paisley is an extensible lightweight embedded domain-specific
language for nondeterministic pattern matching in Java. Using
simple APIs and programming idioms, it brings the power of
functional--logic processing of arbitrary data objects to the Java
platform, without constraining the underlying object-oriented
semantics. Here we present an extension to the Paisley framework
that adds pattern-based control flow. It exploits recent additions
to the Java language, namely functional interfaces and lambda
expressions, for an explicit and transparent continuation-passing
style approach to control. We evaluate the practical impact of the
novel features on a real-world case study that reengineers a
third-party open-source project to use Paisley in place of
conventional object-oriented data query idioms. We find the
approach viable for incremental refactoring of legacy code,
with significant qualitative improvements regarding separation of
concerns, clarity and intentionality, thus making for easier code
understanding, testing and debugging. |
|
[paisleyXpath]
Baltasar Trancón y Widemann and Markus Lepper
Interpreting XPath by Iterative Pattern Matching in Paisley
in: Proc. Functional--Logic Programming (WFLP 2014), Vol.234,
EPTCS, world, 2014
http://ceur-ws.org/Vol-1335/
[abstract]
The Ppaisley architecture is a light-weight EDSL for
non-deterministic pattern matching. It automates the querying of
arbitrary object-oriented data models in a general-purpose
programming language, using API, libraries and simple programming
patterns in a portable and non-invasive way. The core of Paisley
has been applied to real-world applications. Here we discuss the
extension of Paisley by pattern iteration, which
adds a Kleene algebra of pattern function composition to the
unrestricted use of the imperative host language, thus forming a
hybrid object-oriented--functional--logic framework. We subject it
to a classical practical problem and established benchmarks: the
node-set fragment of the XPath language for querying W3C XML
document object models. |
|
[rewriting2018]
Markus Lepper and Baltasar Trancón y Widemann
Rewriting for Parametrization
in: Tagungsband des 35ten Jahrestreffens der
GI-Fachgruppe “Programmiersprachen und Rechenkonzepte”, IFI Reports, Vol.482, pg.51-67,
University of Oslo, Oslo, 2018
ISBN 978-82-7368-447-9
ISSN 0806-3036
http://urn.nb.no/URN:NBN:no-65294
[abstract]
With a modular architectures of source text objects, a method
of free rewriting can be more adequate than pre-wired parameters: each
module import can be accompanied with a set of rewriting rules, mapping
references to expressions and thus adapting the imported definitions to
the needs of the importer. Such a mechanism is described in this paper;
it has been implemented in the d2d system applied to document types,
but seems applicable also for other architectures with a “glass box” view
to modules.
There are two fundamentally different use cases: rewriting (a) to alge-
braic semantics, e.g. for controlling a parsing process, and (b) reifying
the rewritten results, for documentation, statistics, automated user di-
alogue, etc. The second case needs much more effort than the first. For
both cases an algorithm is presented, which is designed for optimized per-
formance, and which reflects details rising from experiences in practical
applications.
The transfer to other languages is supported by a division of the second
algorithm into a generic and a specific part. |
|
[rta2015]
Markus Lepper and Baltasar Trancón y Widemann
A Simple and Efficient Step Towards Type-Correct XSLT Transformations
in: Proceedings 26th International Conference on Rewriting Techniques and Applications (RTA 2015), LIPICS, Vol.36, pg.350--364,
Dagstuhl Publishing, Saarbrücken/Wadern, 2015
doi:10.4230/LIPIcs.RTA.2015.350
ISBN 978-3-939897-85-9
[abstract]
XSLT 1.0 is a standardized functional programming language and widely
used for defining transformations on XML models and documents,
in many areas of industry and publishing.
The problem of XSLT type checking is to verify that
a given transformation, when applied to an input which conforms to
a given structure definition, e.g. an XML DTD, will always produce an output which
adheres to a second structure definition. This problem is known to be
undecidable for the full range of XSLT and document structure definition languages.
Either one or both of them must be significantly restricted,
or only approximations can be calculated.
The algorithm presented here takes a different approach towards type
correct XSLT transformations.
It does not consider the type of the input document at all.
Instead it parses the fragments of the result
document contained
verbatim in the transformation code and
verifies that these can potentially appear in the result language,
as defined by a given DTD.
This is a kind of abstract interpretation,
which can be executed on the fly and in linear time when parsing
the XSLT program. Generated error messages are located accurately to a
child subsequence of a single result element node.
Apparently the method eliminates a considerable
share of XSLT programming errors, on the same order of magnitude as a full fledged
global control-flow analysis. |
|
[tl_paisley]
Trancón y Widemann, Baltasar and Lepper, Markus
Paisley: Pattern matching a la carte
in: Theory and Practice of Model Transformations 5th. International
Conference, ICMT 2012, Praha, LNCS, Vol.7307,
Zhenjiang Hu and Juan de Lara(edts.)
Springer, Berlin, Heidelberg, New York, 2012
ISBN 978-3-642-30475-0
Here are the
slides of our talk on the
ICMT 2012 conference.
[abstract]
Professional development of software dealing with structured models
requires more systematic approach and semantic foundations than
standard practice in general-purpose programming languages affords.
One remedy is to move to domain-specific environments. Here,
instead, we present a tool for the implementation of pattern
matching as fundamental means of automated data extraction from
complex models in a general-purpose programming language. The
interface is simple but, thanks to elaborate and rigorous design, is
also light-weight, portable, non-invasive, type-safe, modular and
extensible. It is compatible with object-oriented data abstraction
and has full support for nondeterminism by backtracking. The tool
comes as a library consisting of two levels: elementary pattern
algebra (generic, highly reusable) and pattern bindings for
particular data models (specific, fairly reusable, user-definable).
Applications use the library code in a small number of idiomatic
ways, making pattern-matching code declarative in style, easily
writeable, readable and maintainable. Library and idiom together
form a tightly embedded domain-specific language; no extension of
the host language is required. The current implementation is in
Java, but assumes only standard object-oriented features, and can
hence be ported to other mainstream languages.
|
|
[tl_paisleyKdpd2013]
Trancón y Widemann, Baltasar and Lepper, Markus
Some Experiments on Light-Weight Object-Functional-Logic Programming in Java with Paisley
in: Declarative Programming and Knowledge Management, LNAI, Vol.8439, pg.218-233,
Springer International Publishing, Berlin, 2014
[abstract]
The Paisley library and embedded domain-specific language
provides light-weight nondeterministic pattern matching on the Java
platform. It fully respects the imperative semantics and data
abstraction of the object-oriented paradigm, while leveraging the
declarative styles of pattern-based querying and searching of
complex object models. Previous papers on Paisley have focused
on the functional paradigm and data flow issues. Here, we
illustrate its use under the logic paradigm. We discuss the
expressiveness and evaluate the performance of Paisley in terms
of the well-known combinatorial search problem ``send more money''
and its generalizations. |
|
[tl_paisleyWflp2013]
Trancón y Widemann, Baltasar and Lepper, Markus
Some Experiments on Light-Weight Object-Functional-Logic Programming in Java with Paisley
in: Kiel Declarative Programming Days 2013, Technische Berichte des Instituts für Informatik, Vol.1306, pg.32-46,
Christian-Albrechts-Universität zu Kiel, Kiel, 2013
ISSN 2192-6247
http://www.informatik.uni-kiel.de/uploads/tx_publication/tr-1306-bericht.pdf
[abstract]
The Paisley library and embedded domain-specific language
provides light-weight nondeterministic pattern matching on the Java
platform. It fully respects the imperative semantics and data
abstraction of the object-oriented paradigm, while leveraging the
declarative styles of pattern-based querying and searching of
complex object models. Previous papers on Paisley have focused
on the functional paradigm and data flow issues. Here, we
illustrate its use under the logic paradigm. We discuss the
expressiveness and evaluate the performance of Paisley in terms
of the well-known combinatorial search problem ``send more money''
and its generalizations. |
|
[tlw01a]
Trancón y Widemann, Baltasar and Lepper, Markus and Wieland, Jacob
Automated Generation of Abstract Syntrax Trees
Represented as Typed DOM XML
in: : Proceedings of XML and Software Engineering (XSE 2001), pg.20-23,
W. Emmerich and C. Mascolo(edts.)
University College London, London, 2001
http://markuslepper.eu/papers/xse2001.pdf
[abstract]
The XANTLR/TDOM project is an implementation of a typed
XML Document Object Model
initially used to represent abstract syntax trees in a compiler project.
Tree classes, SAX event receivers, visitor classes and DTD are automatically
derived from a sparsely annotated ANTLR grammar. Mapping tag values onto the type system of the target lang allows for the
compilation of syntax, mostly yielding large increases in computational performance.
Automized generation significantly decreases programming efforts and increases
maintainability. The currently supported target lang is JAVA. |
|
[tlw03]
Trancón y Widemann, Baltasar and Lepper, Markus and Wieland, Jacob
Automatic Construction of XML-based Tools seen as Meta-Programming
in: Automated Software Engineering, Vol.10, pg.23-38,
Mascolo and Emmerich and Finkelstein(edts.)
Kluwer Academic Press, Dordrecht, 2003
ISSN 0928-8910
http://markuslepper.eu/papers/asexse.pdf
[abstract]
This article presents XML-based tools for parser generation
and data binding generation. The underlying concept is that of
transformation between formal langs, which is a form of
meta-programming. We discuss the benefits of such a declarative
approach with well-defined semantics: productivity, maintainability,
verifiability, performance and safety.
Keywords: XML, SAX, DOM, TDOM, ANTLR, XANTLR,
compiler construction, meta-programming,parser generation, data binding generation |
|