MODELS 2010
is organized by
|
|
Silver Sponsors
Tutorials
NOTE
At this year’s conference, the tutorials will be open for all who have registered for satellite events (workshops, symposia, etc).Breaks
The following breaks will occur every day:
| 10:30‒11:00 | Coffee Break |
|---|---|
| 12:30‒14:00 | Lunch |
| 15:30‒16:00 | Coffee Break |
Tutorial Track: DSL 1 (Monday, Oct 4)
Morning Session (9:00‒12:30)
Auditoriet: Developing a Graphical DSL in under 3 Hours (half day)
Speaker: Prof. Dr. Marko Boger (Software Architecture and Software Engineering, HTWG Konstanz, Germany and Gentleware AG)Abstract
During this tutorial, the participants will develop a full-grown graphical DSL from scratch to a complete modeling environment on their own laptop in under 3 hours. The course is a hands-on practical course for using Poseidon for DSLs as a framework to build a graphical DSL from an EMF metamodel and 5 textual models as a step-by-step guided tour. The participants will start from an empty Eclipse installment and complete the development of an editor for Petri Net as example. The results can then readily be transfered to developing an individual DSL.Afternoon Session (14:00‒17:30)
Auditoriet: Model Driven Language Engineering (half day)
Speakers: Jean-Marc Jézéquel (IRISA (INRIA&Univ Rennes), France) and Franck Fleurey (SINTEF, Norway)Abstract
In many domains such as aerospace and automotive industries, engineers rely on Domain Specific Modeling Languages (DSML) to solve the complex issues of engineering safety critical software. Traditional language engineering starts with the grammar of a language to produce a variety of tools for processing programs expressed in this language. Recently, however, many new languages tend to be first defined through metamodels, i.e., models describing their abstract syntax. Relying on well tooled standards such as E-MOF, this approach makes it possible to readily benefit from a set of tools such as reflexive editors, or XML serialization of models. This tutorial aims at showing how Model Driven Engineering can easily complement these off-the-shelf tools to obtain a complete environment for such a language, including interpreter, compiler, pretty-printer and customizable editors. We illustrate the conceptual simplicity and elegance of this approach using the running example of the well known LOGO programming language, developed within the Kermeta environment.Tutorial Track: Methods and Tools (Monday, Oct 4)
Morning Session (9:00‒12:30)
"Torghjørnet": Bringing Life to Models (quarter day 9:00‒10:30)
Speakers: Dag Bøyesen and Knut Sagli (both from Esito as, Norway)Abstract
The tutorial will comprise generation of a runnable and running system based on UML and proprietary models created with Genova. Genova constitutes a user interface modeling and generator environment with supporting models and generators for providing data at a service level as well as a database level. In combination with runtime frameworks, the generated code produces sustainable and maintainable applications. This tutorial will show how models and code generators can be used to develop, build, run and test java enterprise applications."Torghjørnet": From Requirements to Code in a Snap (quarter day 11:00‒12:30)
Speaker: Michał Śmiałek (Warsaw University of Technology, Warsaw, Poland)Abstract
Model Driven Software Development promises to shorten the software development lifecycle. This promise is associated with the ability to define software models at one level of abstraction and then to automatically generate more detailed models (including code). In this tutorial we will show that this is possible even from the level of general-purpose requirements models. We will demonstrate how to write requirements specifications that are understandable by business experts in a wide range of domains and at the same time precise enough for automatic transformations. In this demonstration we will apply the Requirements Specification Language (RSL, developed by H. Kaindl and the speaker) that is defined with a strict meta-model. We will also demonstrate a novel tool that allows for specifying RSL-based models and then translating them into design models and code. We will show that from use-case based requirements, the whole code for the application logic can be produced automatically. Moreover, the domain logic code can be initiated from the requirements-level vocabulary and verb phrases. Based on these model-based mechanisms we will present a new approach to rapid evolutionary development of software systems with so-called "software cases".Afternoon Session (14:00‒17:30)
"Torghjørnet": UNICASE ― Tooling for Software Engineering Models (quarter day 14:00‒15:30)
Speakers: Nitesh Narayan, Maximilian Koegel, and Jonas Helming (all from Technische Universität München)[Link]
Abstract
UNICASE is a unified CASE-Tool and integrates models from the different development activities such as requirements, use cases, UML models, schedules, bug and feature models into a unified model. This unified model is not limited to the traditional system-modeling domain but also takes project management artifacts into consideration. Therefore it is by design highly traceable even across domain boundaries. In this tutorial we provide hands-on experience with UNICASE. We first give a short introduction to UNICASE from an abstract point of view, and then we start to use UNICASE in a concrete scenario to demonstrate its usage. In the scenario we cover selected aspects of modeling a system and of project management support that are unique for UNICASE. UNICASE is also meant as a platform to implement tool-support for arbitrary software engineering models. In the second part of the tutorial we show how to extend the model of UNICASE with a new model element including the implementation of a graphical visualization in a diagram."Torghjørnet": COPE ― Automating Model Migration in response to Metamodel Evolution (quarter day 16:00‒17:30)
Speakers: Markus Herrmannsdörfer (Technische Universität München)Abstract
Model-driven software development promises to increase productivity by offering modeling languages tailored to a problem domain. Consequently, an increasing number of modeling languages are built using metamodel-based language workbenches. In response to changing requirements and technologies, the modeling languages and thus their meta-models need to be adapted. Manual migration of existing models in response to metamodel adaptation is tedious and error-prone. In this tutorial, we present our tool COPE to automate the coupled evolution of metamodels and models. To not lose the intention behind the adaptation, COPE records the coupled evolution in an explicit history model. Based on this history model, COPE provides advanced tool support to inspect, refactor and recover the coupled evolution.Social Program
18:00 Viking Ship Reception
Tutorial Track: DSL 2 (Tuesday, Oct 5)
Morning Session (9:00‒12:30)
"Torghjørnet": Agile Development with Domain Specific Languages (half day)
Speakers: Bernhard Rumpe, Ingo Weisemoeller, Martin Schindler, and Steven Voelkel (all from RWTH Aachen University, Germany)[Presentation (password protected)]
Abstract
Generation of software from modeling languages such as UML and domain specific languages (DSLs) has become an important paradigm in software engineering. In this tutorial, we discuss topics around software development in a model based, generative manner based on home grown DSLs as well as the UML. This includes development of DSLs as well as development of models in these languages in order to generate executable code, test cases or models in their languages.The course about development of formal DSLs provides a brief overview of metamodels and grammars (syntax), context conditions (static analysis and quality assurance) as well as possibilities to define the semantics of a language. As a unique innovation we address the growing number and complexity of DSLs by concepts for the modular and compositional development of languages and their tools.
Special emphasis is put on the combination of DSL usage and agile methods, which allows for parallel evolution of a language and its instances. Based on the semantical and technical foundations for language definition, we describe an architecture for both language definition and usage, and integrate language and tool development with an agile model-based development process.
Afternoon Session (14:00‒17:30)
"Torghjørnet": Applying Model Driven Engineering Technologies in the Creation of Domain Specific Modeling Languages (half day)
Speakers: Bruce Trask and Angel Roman (both from MDE Systems Inc)[Presentation (password protected)]
Abstract
Model Driven Engineering (MDE) brings together multiple technologies and critical innovations and formalizes them into the next wave of software development methods. This tutorial will cover the basic patterns principles and practices of MDE. The three main MDE categories include the development of Domain Specific Languages (DSL), Domain Specific Editors (including Domain Specific Visual Languages), and Domain Specific Transformation Engines or Generators. Expressed in terms of language development technology, these mirror the development of the Abstract Syntax, Concrete Syntax and Semantics of a new Domain Specific Language. This tutorial will cover the basic effective patterns, principles and practices for developing these MDE software artifacts. The tutorial will show how to apply these concepts as effective means with which to both raise levels of abstraction and domain specificity and thus increase power and value of tools and languages that allow developers to tackle the complexities of today’s software systems. It will also show how to effectively leverage abstraction without sacrificing the ability to robustly and precisely refine these abstractions to solve complex real world problems. To show these patterns and principles in action, this tutorial will cover the exact details of how to leverage Language Workbenches and frameworks to support the development of these three areas.Tutorial Track: Eclipse/EMF (Tuesday, Oct 5)
Morning session (9:00‒12:30)
Auditoriet: Incremental Pattern Matching over EMF: a Tutorial on EMF-IncQuery (quarter day 9:00‒10:30)
Speakers: Gabor Bergmann, Akos Horvath, Istvan Rath, and Daniel Varro (all from Budapest University of Technology and Economics)Abstract
Model Driven Development platforms such as industry leader Eclipse Modeling Framework (EMF) greatly benefit from pattern matching, as it supports various goals including model validation, model transformation, code generation and domain specific behaviour simulation. Pattern matching is a search for model elements conforming to a given pattern that describes their arrangement and properties, e.g., finding a violation of a complex well-formedness constraint of the domain specific modeling language.Two major issues arise in pattern matching: (i) it can have significant impact on runtime performance and scalability; and (ii) it is often tedious and time consuming to (efficiently) implement manually on a case-by-case basis. The latter is typically addressed by a declarative query language (e.g., EMF Query, OCL) processed by a general-purpose pattern matching engine.
The current tutorial introduces a declarative model query framework over EMF called EMF-IncQuery, using the graph pattern formalism (from the theory of graph transformations) as its query language and relying on incremental pattern matching for improved performance. In case of incremental pattern matching, matches of a pattern are explicitly stored and incrementally maintained upon model manipulation. In many scenarios this technique provides significant speed-up at the cost of increased memory consumption.
Auditoriet: Storing and Versioning EMF Models with EMFStore (quarter day 11:00‒12:30)
Speakers: Maximilian Koegel, Jonas Helming, and Nitesh Narayan (all from Technische Universität München, Institut für Informatik)Abstract
Models need to be put under version control to facilitate collaboration and to control change. EMFStore is a Software Configuration Management framework and system tailored to the specific requirements for versioning models. To facilitate fine-grained versioning the EMFStore employs an operation-based approach. This tutorial will explain the abstract concepts of the EMFStore and provide hands-on experience how to use the EMFStore to store and version models and/or their instances and how to integrate the EMFStore in an application.Afternoon Session (14:00‒17:30)
Auditoriet: Building Model-Based Applications with the EMF Client Platform (quarter day 14:00‒15:30)
Speakers: Jonas Helming, Maximilian Koegel, and Nitesh Narayan (all from Technische Universität München)Abstract
The Eclipse Modeling Framework (EMF) allows generating the entity classes of an application based on a model. Such entity-centric applications follow a common template. They provide a tree-based view for navigation and for browsing all entities, a detailed editor for one entity of the model and a number of additional customized views. Additionally the entities have to be validated, persisted, versioned and shared among multiple clients. Building such applications in Eclipse usually requires the use of several frameworks additional to EMF. Therefore it is still a long way from an EMF model to a running application fulfilling basic requirements. This is especially true for developers inexperienced with Eclipse technology. They have to overcome a high entry barrier as they have to evaluate, select and comprehend a variety of existing frameworks and their interplay. Therefore the goal of the EMF Client Platform (ECP) is to provide a one-click start to the creation of an entity-centric EMF application. The resulting application is based on a selection of existing frameworks and already delivers basic features. It can be refined and adapted step by step. In this tutorial we demonstrate how to build a model-based application with ECP. Further we show how to customize and adapt this application step by step. The EMF Client Platform is currently in the proposal state to become an Eclipse project.Auditoriet: Language Development with EMFText and JaMoPP (quarter day 16:00‒17:30)
Speakers: Florian Heidenreich, Jendrik Johannes, Sven Karol, Mirko Seifert, and Christian Wende (all from Technische Universit at Dresden)Abstract
Textual Syntax (TS) as a form of model representation has made its way to the Model-Driven Software Development community and is considered a viable alternative to graphical representations. In this tutorial we present EMFText, an EMF/Eclipse-integrated tool for rapid textual syntax development, and JaMoPP, a tool for handling Java code as models and for integrating Java with modelling languages. In the tutorial we stepwise develop and extend a GUI DSL with EMFText and other Eclipse modelling tools. We integrate this DSL with Java using EMFText and JaMoPP. Participants will learn hands-on how to develop productive DSLs with EMFText and JaMoPP.
Last updated Wednesday, 06-Oct-2010 15:43:33 CEST by models2010@ifi.uio.no.
News
- January 24, 2011
The conference proceedings are now available online as Springer LNCS 6394 and 6395. - October 20, 2010
If you were unable to attend, the three keynote presentations are now available. - October 13, 2010
You can now admire the photographs taken during the conference.
Co-located events