Trane is a small class library, which provides an infrastructure to support experimenting
with transformations interactively. Transformations here mean algorithms,
which take software artefacts as input and output manipulated artefacts.
Trane supports combination of transformations available in different languages,
libraries and tools. Several combinations can be presented at the same time,
parameters can be visually changed, and results can be compared.
New transformations can be added easily.
Though it is not restricted to that, we want to use Trane especially for
transformations on language artefacts, such as grammars, semantic descriptions,
language processors possibly generated from those grammars. Transformations
will be mainly in the area of source to source transformation, such as refactoring.
The general idea is similar to graphics filter pipelines, such as Cantata
(Khoros), or
allseeingi (hosted here). The new aspect is the use of software as data,
especially the use
of grammars.
The current state is a first prototype, which enables combination of transformations, but
lacks of usability and a good type system. Moreover, certain keyconcepts from the scratch
pad are not yet implemented. (See some Screenshots).
This project is not thought as a high-quality production tool, though it might
become
usable (we hope). Rather, it is subject to research, and concepts might stand
in main focus,
which might be the draft for a larger real life project with more helpers. Maybe they would
then include our project team for experience and suggestions.
Implementation is based on .NET (Mono as well as the other) and Gtk#.
A published paper on Trane is available and will be referenced here, soon,
despite possible errors in it ;-)
Mission
What is the goal of this project?
Though language technology is about 50 years old,
there is still insufficient support for engineering language artefacts,
such as grammars. There are several tools available, which are focussed to some
domain or are restricted to a special format or tool.
This project aims to provide a facility to combine those tools, and to play
around with them, compare transformations defined on e.g. grammars, provide
converters between grammar formats.
What is the scope of this project?
- This is a project used to support research on source-to-source
transformations.
- It already provides basic functionality to define and combine
heterogeneous transformations interactively, which are defined by e.g. web-services, cmd-line,
foreign libraries. Integration of different kinds of transformation should be
improved even more.
- We want to provide an infrastructure and a basic set of examples/ usable
transformations and format converters, which other users might want to apply to
own projects.
- The implementation aims to stay lightweight.
What are high-level features you are sure to build?
- Support for easy integration of heterogenous transformations, especially in
the area of grammar engineering
- Support for interactive experiments with transformations
What are the high-level assumptions or ground rules for the project?
We use .NET 2.0, on Windows and Linux
- C# for the core
- arbitrary .NET languages for transformations
- arbitrary .NET languages and Webservices for wrapping existing
transformations into our model
- Will be artistic license
Related resources
- The underlying concept has already been used in a lot of programs,
especially in the field of graphics (Cantata in the Khoros system, MVE2,
allseeingi (hosted here))
- This implementation aims for software as data, especially language
artefacts, which has not been object in such tools before.
- This implementation tries to remain very lightweight, making it easier to
understand and integrate with other tools, or useful for own experiments.
-
Project members
- wlohmann - Wolfgang Lohmann
- ThomasZ -
