School Speakers and Topics
- Hartmut Ehrig (Technical University of Berlin): The Algebraic Approach
Graph transformation tutorial based on the book on Fundamentals of Algebraic Graph Transformation.
- Gregor Engels (University of Paderborn): Visual Contracts: Applying Graph Transformations within Service-Oriented Architectures
Service-oriented architectures promise to enable a highly dynamic
integration of existing and new software-systems by enabling a loose
coupling of clients and services. A service is called by a client according
to its public service specification. The mechanism to achieve the vision of
service-oriented architectures relies on two important assumptions. (1) A
service description meets the requirements of a client and (2) an
implementation of a service is correct according to its service description.
In this talk, we show how we can use Design by Contract concepts for service
descriptions on the model level. Therefore, we introduce the notion of
visual contracts. Visual contracts are an UML-based representation of graph
transformations. Visual contracts can be used for enabling a (1)
model-driven matching to compare the requirements of a client with existing
service descriptions. Additionally, a transformation of the visual contracts
into assertions on the code level allows for a (2) model-driven monitoring
of hand-coded programs during their execution.
- José Fiadeiro (University of Leicester): Algebraic semantics of modules in Service Component Architecture
We report on an algebraic framework being developed within SENSORIA – an IST-FET Integrated Project on Software Engineering for Service-Oriented Overlay Computers – for supporting service-oriented modelling at high levels of abstraction, i.e. independently of the hosting middleware and hardware platforms, and the languages in which services are programmed. More specifically, we propose a formal notion of module that supports the composition model of the SENSORIA Reference Modelling Language (SRML). Modules in SRML are inspired in concepts proposed in Service Component Architectures (SCA) and Web Services, as well as algebraic models as proposed by Ehrig and Orejas. They include interfaces for required (imported) and provided (exported) services, as well as a number of components (body) whose orchestrations ensure how given behavioural properties of the provided services are guaranteed assuming that the requested services satisfy required properties. Properties are formulated in a logic of interactions that includes primitives for modelling service conversations and orchestration.
- Jan Hendrik Hausmann (University of Paderborn): Semantics of Visual Modelling Techniques
Visual Modeling Techniques have been proven to be an adept tool for
communicating problems, ideas and system designs. But how can one be
sure that the information encoded in a model by the sender is
identical to what the receiver of the model understands from it? This
is the fundamental question on the semantics of a language.
As VMTs are rather "young" languages and pose additional problems in
comparison to, e.g., textual programming languages, there is not yet a
clear consensus on what the semantics of a VMT should be or how they
are to be expressed.
In this lecture you will learn about some classical problems of
semantics definition, the additional problems posed by VMT in general
and the UML in particular. We'll also demonstrate a
graph-transformation-based techniques which allows for a specification
of a VMT's semantics.
- Reiko Heckel (University of Leicester): Graph Transformation in a Nutshell
Graph transformation tutorial including a non-technical introduction into graph transformation.
- Stuart Kent (Microsoft): Domain Specific Development
Domain specific development is an approach to software development where you use domain specific languages to drive the development of parts of an application. This approach to software development depends on bringing down the cost of building domain specific tools. Microsoft's domain specific language tools are a first step in achieving this goal. In this talk I'll describe the concept of domain specific development, and illustrate it through a simple concrete sample that is shipped as part of Microsoft's DSL Tools. I'll show how the graphical designer and code generators used in that sample are constructed, in particular how little coding is involved. I'll also comment on some of the things that you have to consider, when your goal is to enable the construction of production quality tools. I'll conclude by identifying some unresolved technical challenges, in particular in the area of visualization, and by providing a brief look into the future, in particular the role that DSL Tools play in Microsoft's wider Software Factory vision.
- Hans-Jörg Kreowski (University of Bremen): Advanced Transformation Concepts
The application of rules to graphs yields graphs and specifies a binary
relation on graphs in this way. A system consisting of a set of rules, descriptions of initial and terminal graphs and of an additional control
condition (if one wants to cut down the usual nondeterminism of rule
application) provides the elementary ingredients of graph transformation.
Such a system may be called a transformation unit.
This basic concept can be extended in various ways to enhance the
usefulness of graph transformation as a modeling approach:
(1) Transformation units may import other units allowing a structured
design and the reuse of existing units.
(2) Further unit-building operations are the sequential and parallel
compositions. While the sequential composition is always defined if
the terminal graphs of the first component are initial graphs of the
second one, the parallel composition requires a corresponding composition of graphs.
(3) Another advanced concept of graph transformation is obtained if
one replaces the simple type of rule application and its sequential
composition by more general semantic features like parallel rule
application or autonomous control.
A true survey of the matter is beyond the scope of this presentation.
The talk will focus on the particular view and particular aspects of advanced transformation concepts studied and developed in Bremen.
- Tom Mens (University of Mons-Hainaut): Graph-Transformation-Based Support for Model Evolution
Model-driven software engineering primarily deals with manipulation and transformation of models. In the current state of research on MDE, however, there is an urgent need for more disciplined and more formal techniques to support a wide range of model evolution activities. These include model refactoring, model inconsistency management, model versioning and merging, co-evolution of models, incremental model analysis and verification, and many more. A desirable property of the enabling or supporting mechanisms for these activities is that they should remain, as much as possible, `agnostic' of the particular modeling language of interest. This makes them more robust to evolution of the modeling language, and allows them to be applicable to a wider variety of models.
In this talk, we report on some experiments we have carried out with graph transformation as an underlying theory and technology for model evolution. Due to its solid formal foundation, combined with the fact that models are frequently represented in a graph-based way, graph transformation seems to be a natural choice for supporting model evolution. We try to validate this claim by exploring how the technique of graph transformation can be used to support model refactoring and model inconsistency resolution. Based on our experiments, we discuss the limitations and challenges in the field of graph transformation, and point of some directions of future research in model-driven software engineering.
- Mark Minas (Universität der Bundeswehr München): Syntax Specification by Graph Grammars and Meta-Models
The design and implementation of any language for programming,
specification or for domain specific purposes requires a specification
of the language syntax. For textual languages, context-free grammars are
the established means for specifying syntax. For visual languages (VLs),
the situation is less easy as VLs offer more freedom than textual
ones. Hence, there are several approaches for syntax definition of
VLs. The lecture introduces into some of them.
Similar to textual languages, concrete syntax is distinguished from
abstract syntax for visual languages. Concrete syntax describes how
diagrams of a specific visual language (e.g., a specific statechart
diagram) are composed from their primitive diagram components like
arrows or circles, but also textual labels. Abstract syntax represents
the structure of diagrams in a way that is independent of the concrete
encoding and the physical representation.
Graphs are a popular means as an intermediate representation of the
concrete as well as the abstract syntax of diagrams. Different
approaches are known to specify concrete and abstract syntax of a
diagram language in terms of such graph representations. Graph grammars
as the prevailing approach is more and more replaced by meta-modelling
approaches. While the former is the more powerful approach, the latter
is easier to use and, hence, better accepted.
This lecture presents these approaches for syntax specification of
diagram languages and shows how they can be used to generate editors
from such specifications by the tools DiaGen and DiaMeta.
- Ugo Montanari (University of Pisa): Synchronized Hyperedge Replacement:
Synchronization Styles for Global Computing
This talk describes a framework for modelling several aspects of distributed computing based on Synchronised Hyperedge Replacement (SHR), a graph rewriting formalism. Components are represented as edges and they rewrite themselves by synchronising with neighbour components the productions that specify their behaviour. The SHR framework has been equipped with many formal devices for representing complex synchronisation mechanisms which can tackle mobility, heterogeneous synchronisations and non-functional aspects, key factors of Global Computing (GC). We propose the SHR family as suitable models for specifying GC systems. (Joint work with Gian Luigi Ferrari, Dan Hirsch, Ivan Lanese and Emilio Tuosto)
- Arend Rensink (University of Twente): Logics and model checking for Graph Transformation
In this lecture we recount the basic principles of model checking, and we show how they can be applied to transition systems derived from graph transformation rules. The advantages over traditional model checking are: a natural, uniform model for dynamic behaviour (including object allocation and method calling), and automatic symmetry reduction. We also show how graph properties can be included in the form of special rules, and we discuss future extensions.
- Grzegorz Rozenberg (Leiden University and University of Colorado at Boulder): Natural Computing and Graph Transformations
Natural Computing is defined as computing taking place in nature and
human-designed computing inspired by nature. Research in natural
computing is genuinly interdisciplinary and it is also using a wide
variety of formal techniques. Graph transformations play an important
role in this research. We will discuss the use of graph transformations
in two important areas of natural computing: foundations of
self-assembly and membrane computing. In our lecture we will demonstrate
that: (1) graph transformations are useful and "natural"(!) in research
on natural computing, and (2) research on natural computing leads to novel
and interesting questions/topics concerning graph transformations.
- Andy Schürr (Technical University of Darmstadt): From Model to Graph Transformations and Back Again
Model Driven Development (MDD) and Model Driven Architecture
(MDA) are the latest hot topics of the software engineering
community. Both MDD and MDA require powerful and precisely
defined model transformation approaches for the construction,
analysis, manipulation, and transformation of models and
architectures at variousl levels of detail.
This lecture starts with a summary of the basic concepts
of MDD and a survey of model transformation languages and
tools that have been developed for different purposes such
as model refactoring, model integration, and code generation.
It then presents MOFLON, a rule-based MDD tool that combines
the world of graph transformations (GTs) as offered by Fujaba
with the latest standard of the OMG for metamodeling
purposes. MOFLON/Fujaba offer regular GT concepts for the
manipulation of single graph instances as well as triple
graph grammars (TGGs) for the specification of bidirectional
graph translators. The lecture finally discusses the
differences between TGGs with their precise semantics
definition and QVT, OMG's proposal for a model transformation
- Gabriele Taentzer (Technical University of Berlin): Tools for Visual Modeling Techniques
In the first part of this session, an overview on existing tools for visual modeling techniques is given. In the wide
area of visual modeling techniques a large number of CASE and Meta-CASE tools have been developed to
define and work with visual modeling techniques. We concentrate on meta CASE tools for specifying visual
modeling techniques instead of specific solutions for concrete modeling techniques such as UML CASE tools.
Meta tools are used to define the concrete and abstract syntax, different kinds of semantics, and validation
techniques for visual modeling techniques.
Dealing with different modeling techniques, the transformation of models play a central role. Model transformation
is used e.g. to optimize models, to analyse them and to define a semantics by a different semantic domain. In the
second part of this session, School participants who are involved in tool development, present concrete tools for
visual modeling techniques. Most of them show tool support for model transformation.