![[logo MODELS'2008]](images/MODELS2008-50pc.jpg)
|
|
|
|
|
| Agenda | selected tutorials |
Aspects are concerns whose representation is scattered across multiple software artefacts. If not handled properly, they lead to the problems of concern scattering (a single concern is represented in many different places) and concern tangling (a single artefact represents multiple concerns). Aspects are now fairly well understood at the programming level but at the modeling level, despite a plethora of proposals, there is not yet any real consensus on the best approach.
This tutorial will survey the most promising approaches to aspect-oriented modeling and will therefore give attendees an ideal introduction into the world of aspect-oriented modeling. Rather than trying to cover all approaches, the tutorial will present representative examples of the major ideas that have influenced the field. The tutorial will, therefore, provide an immersive introduction into this exciting area in a way that succinctly characterizes the major achievements so far as well as the major challenges yet to be overcome.
The tutorial will be highly interactive and will be based on a variety of teaching methods, including lectures and hands-on exercises. In particular, one concrete example will be tackled by the participants using multiple approaches so that attendees get a very real sense of the advantages and disadvantages of the different methods.
Modeling technologies help design software systems by offering the possibility to represent their different parts (e.g., user interface, class structure) more adequately as models defined in Domain- Specific Languages (DSLs). This contrasts with the traditional way of encoding all the functionality of a large system using a single General Purpose Language like Java. However, for the system to actually run, code has to be generated from these higher-level models. Model-to-Model (M2M) transformation is one of the key techniques that are used to achieve this result. The ATL tools provided in the M2M Eclipse.org modeling project make it possible for developers to use this technique in practice. These tools are to model-to-model transformation what JDT (Java Development Tools) are to Java development.
This tutorial presents the ATL language and its toolbox, which consist of: an editor with syntax highlighting, and content assist; a speed-optimized execution engine; and a debugger. Three different transformation examples will be presented and implemented in ATL. The presentation will be performed by model-to-model transformation experts, among who is the architect of ATL, who designed the language and created the initial implementation (now further developed by contributors from the Eclipse.org community).
An important missing link in the model-based development of critical systems is finding a practical way to establish correspondence between a software design and its implementation. This tutorial presents work towards a solution to this problem for the case of crypto-based implementations in Java (such as crypto protocols).
Given a textual specification of a crypto-based system and its implementation, we show how one can construct a precise and compact specification using the security extension UMLsec of the Unified Modeling Language (UML), which is based on a formal semantics defined using Abstract State Machines (ASMs). This formal model can then be automatically and formally verified against the security goals using automated theorem provers for first-order logic. In a second step, one can then make sure that the implementation correctly implements the specification by making use of techniques such as model-checking, run-time verification, and security testing.
Our approach is supported by a tool available as open-source. As a running example for the tutorial, we use the open-source Java implementation Jessie of the SSL protocol. We will also explain how to apply the approach to the Java Secure Sockets Extension library recently made open-source by Sun.
A core activity in developing a Software Product-Line (SPL) is the documentation of product variability. Product variability dictates the rules governing how an application can be retargeted to different requirement sets. Typically, product variability is captured in models, such as feature models.
Once models are built that document SPL variability, tool support can be developed to help SPL engineers configure individual SPL variants. Often, complex automation may be needed to help choose good or optimal settings for the SPL’s points of variability. Developing these modeling tools and automation mechanisms is challenging.
This tutorial introduces Eclipse-based modeling technologies that can be used to help reduce the cost of building model-based SPL configuration tools. Furthermore, the tutorial covers different Eclipse frameworks that can be used to build constraint-based automation mechanisms into SPL modeling tools for Eclipse. Finally, the tutorial provides an introduction on how these automation mechanisms can be used to help derive optimal variants and product/application configurations for a requirement set.
Large-scale component-based systems usually require multiple years of development effort to realize a production system. Ensuring the production system meets its performance requirements is hard due to the serialized phasing development process – where functionally correct infrastructure and application components are developed in different phases but do not meet performance requirements when integrated with each other – and unforeseen software contention issues (e.g., performance anti-patterns) that arise when the system is deployed. System execution modeling tools play a vital role in addressing this challenge. Model-driven engineering (MDE) techniques coupled with SEM tools provide intuitive abstractions to system developers for expressing system structure and behavior. Emulation and analysis frameworks associated with SEM tools enable execution and evaluation of a system under development on the target architecture. For system developers, this capability can provide early understanding of system performance and locate performance problems before they become too hard to find. Moreover, the process can be applied continuously throughout the development lifecycle.
This tutorial will illustrate these features for component-based large-scale systems using the CUTS MDE-SEM tool suite. A number of case studies and short demonstrations will be used to illustrate the challenges and the solutions provided by continuous system integration using SEM tools.
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 real world problems. Additionally, this tutorial will cover the exact details of how to leverage the Eclipse Modeling Framework (EMF), the Eclipse Graphical Editor Framework (GEF), and the Eclipse Graphical Modeling Framework (GMF), to support the development of these three areas. These three frameworks provide a unique and integrated platform in which to learn the basics of Model Driven Engineering in full application not just in theory. Conversely, Model Driven Engineering provides an effective context in which to learn how to apply the power of these integrated Eclipse Frameworks developed to support MDE.
In many domains such as aerospace and automotive industries, engi- neers rely on Domain Speci c Modeling Languages (DSML) to solve the complex issues of engineering safety critical software. Traditional Lan- guage Engineering starts with the grammar of a language to produce a variety of tools for processing programs expressed in this language. Re- cently 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 on-the-shelf tools to obtain a complete environment for such a language, including interpreter, com- piler, pretty-printer and customizable editors. We illustrate the concep- tual simplicity and elegance of this approach using the running example of the well known LOGO programming language, developed within the Kermeta environment.
In this tutorial, we present the theorem proving environment HOL-OCL. The HOL-OCL system (http://www.brucker.ch/projects/hol-ocl/) is an interactive proof environment for UML/acsocl specifications that is integrated in a Model-driven Engineering (MDE) framework (see Figure 1). HOL-OCL allows to reason over UML class models annotated with OCL specifications. Thus, HOL-OCL strengthens a crucial part of the UML to an object-oriented formal method. HOL-OCL provides several derived proof calculi that allow for formal derivations of validity of UML/OCL formulae. These formulae arise naturally when checking the consistency of class models, when formally refining abstract models to more concrete ones or when discharging side-conditions from model-transformations.
Service-oriented architectures (SOA) are promoted as the final answer to the long standing demand to bridge the gap between business needs and IT-solutions. Like object-orientation has been advocated as the overall structuring principle in the 90s, service-orientation is nowadays discussed as the magic bullet to align business requirements with software applications. As it is typical for any hype approach, a commonly agreed understanding of the basic principles and notions for service-oriented concepts is still missing. This leads often to misunderstandings and communication problems in IT-projects and, thus, jeopardizes the success of migration projects where existing architectures are advanced towards service-oriented architectures.
The tutorial aims at clarifying the understanding of basic principles, notions, languages as well as methods of a service-oriented approach. In particular, it is explained how modelling languages like UML may be used within a structured development method for a service-oriented design of an application landscape. All introduced concepts are related to existing knowledge on software architectures, architectural styles, and architecture frameworks. Presented concrete methodical guidelines have been derived from successful industrial IT-projects and are related to Quasar Enterprise, the service-oriented development approach of sd&m AG, Munich (Germany).