MetaEdit+ metaCASE tool:
Generation from high-abstraction models ( BEST COMMERCIAL TOOL award ) Juha-Pekka Tolvanen, MetaCase,
MetaEdit+ allows you to build your own CASE tool - without having to
write a single line of code. MetaEdit+ provides metamodelling language
and tool suite for designing your method. Using these tools you can
define the modelling concepts, their properties, associated rules,
symbols, checking reports and generators. The object-oriented
metamodelling makes CASE tool development fast and cost-effective.
As soon as you define a method, or even a partial prototype, your team
can start using it. For the method users, MetaEdit+ provides full CASE
tool functionality for multiple users, multiple projects, running on
all major platforms. Your team can immediately start to edit designs as
graphical diagrams, matrices or tables. You can browse designs with
filters, apply components, link your models to other designs, and check
your models and generate the desired output, like code, docs, testing
material, etc. You can have the tool you want because you are in charge!
GME: A Reflective Environment for
Domain-Specific Modeling Akos Ledeczi, Institute for Software Integrated Systems,
Vanderbilt University, USA
The Generic Modeling Environment (GME) is a metaprogrammable graphical
editor supporting the design, analysis and synthesis of complex,
software-intensive systems in diverse engineering fields. GME has a
component-based architecture using MS COM technology and is implemented
in C++. The Core component exposes the domain-specific language
specification through a set of COM interfaces. Another set of
interfaces provides bi-directional model access and also exposes all
the model modification events. All the other tool components, (diagram
editor, decorators, browser, event-based OCL constraint manager,
software generators, etc.) are built independently around the Core.
Model persistence is supported via standard database technology and XML
import/export functionality. The standard technologies applied
throughout the architecture (UML, OCL, COM, XML) make GME easily
applicable and extensible to a wide variety of domains. One such domain
is metamodeling, where UML class diagram based metamodels can be
created to configure GME itself.
A new horizon of MDA
tools: three degrees of freedom with the b+m Generator Framework Juergen Ruehle, b+m AG, Germany
Exchangeable templates - exchangeable generator meta model -
exchangeable input meta model.
The b+m Generator is a template-based generator framework designed for
architecture-centric software development according to OMG's Model
Driven Architecture (MDAT) approach. The b+m Generative Development
Process leads to the concept of an "application family" which contains
a runtime system, templates and its meta model implementation. However,
the application family should be considered not only as a set of
applications with a similar platform binding, but also as an
operational component of the development process. As an artifact, it
contains all components necessary for the use of the generator in order
to be able to transform architecture-centric models to implementation
frameworks. The flexible import interface of the generator can read
design models of virtually any UML tool exported to XMI. The
configurability of the meta model instantiation even enables processing
proprietary, XML-based formats. In addition to the application design,
the generator needs a Java implementation of the design language used -
the Java meta model to instantiate the design model. The resulting
instantiated Java meta model corresponds exactly to the application
design. Fundamentally, any diagram types such as activity diagrams,
sequence diagrams, and use-case diagrams can be supported. This means
that, in contrast to other tools, not only static but also dynamic
application aspects can be generated. The b+m generator is not
restricted to UML but can support any modeling language for which a
meta model and the corresponding instantiation rules can be created.
The source-code expansion is controlled by templates that are
dynamically linked to the classes of the meta model.
Building maintainable and
extensible model transformers and generators Michael Jungmann, Interactive Objects Software GmbH,
Model-Driven Architecture ® (MDA ® ) depends on the
availability of decent automatic code generators and model
transformers. While applying MDA has long been part of a solutions
catalog, particularly for environments targeting complex architectures,
the creation of generators and model transformers itself has long been
based on rather immature and ad-hoc technologies, such as large
collections of templates. This caused all kinds of problems that are
well-known from other fields of software engineering: Creating
transformations is expensive, the resulting generators/transformers are
hard to understand, therefore hard to reuse and extend and are of
comparably low quality.
The demonstration will show how the concepts and benefits of
object-oriented software design and development can be applied to the
creation of maintainable, tailorable and extensible generators /
transformers. This includes an inheritance concept for generators /
transformers and other OO patterns. Furthermore, the demonstration will
show how MDA can be applied to the specification of transformations
itself, allowing for the automatic generation of large portions of
generators / transformers from UML models.
The demonstration will cover basic samples and it will also share
experiences gained in construction of productized transformations for a
number of domains.
The HyperSensesTM Technology - Putting
Intentions Into Practice Cord Giese, Delta Software Technology GmbH, Germany
The HyperSenses technology, developed at Delta Software Technology
GmbH, describes a technical architecture which focuses on important
parts of the concepts of Generative Programming and Intentional
The goal of HyperSenses is to facilitate application development by
offering different levels of abstraction concerning the source code.
Therefore a source is represented by several renderings: Pure text is
just the simplest possibility, beneath semi-graphical and graphical
renderings. They are combined with intelligent behaviour:
Domain-specific patterns describe expansion semantics and code
properties, including insertion points and so-called annotations; meta
information enables language specific behaviour; application-specific
models control the process workflow. Together with checking
possibilities and context-sensitve editing features the sources become
active sources in the original sense of IP. Hence HyperSenses is much
more than a kind of editing support like e.g. the Microsoft(R)
IntelliSense(R) technology - this intention is expressed by its name.
A Model for On-line
Development Iain Falconer, Gentastic, England
e-GEN technology (www.gentastic.com) provides an approach that can
deliver managed support for off-shore development organization,
tele-development for geographically distributed teams, or simply to
reduce deployment costs within an single site organization. In each
case the model-driven generative approach provides a solid framework to
enforce consistent understanding, process and deliverables.
The demonstration will illustrate how a domain model coupled with a
configurable template-based generative capability can be used to
provide an Internet based Design Portal application capable of
supporting remote development. The approach centralizes the definition
of software architecture and design patterns, hiding the technology
complexities from designers, exposing only a custom-fit Design Portal
that guides designer through an accurate process of capturing
domain-specific design details, and generating software artifacts.
The Design Portal can also be integrated with development processes to
facilitate compilation, testing and deployment.