GPCE Demonstrations

 

Tuesday, September 23

17:20 - 18:50

Demonstrations 1&2: Metamodeling

 

Wednesday, September 24

17:20 - 18:45

Demonstrations 3&4: Model-Driven Architecture

 

Thursday, September 25

15:30 - 17:00

Demonstrations 5&6: Generative Development

 

Demonstration Details

Demonstrations 1&2: Metamodeling

• MetaEdit+ metaCASE tool: Generation from high-abstraction models  ( BEST COMMERCIAL TOOL award )
  Juha-Pekka Tolvanen, MetaCase, Finland 
  
  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.
  
  

Demonstrations 3&4: Model-Driven Architecture

• 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, Germany 
  
  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.
  
  

Demonstrations 5&6: Generative Development

• 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 Programming (IP). 
  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.