Models in Software Engineering

This report summarizes the results and discussions from the 11th Workshop on Aspect-Oriented Modeling (AOM). The workshop was held in conjunction with the International Conference on Model-Driven Engineering, Languages, and Systems (MODELS), which was located in Nashville, Tennes-see, on September 30, 2007. Over 20 researchers and practitioners attended the workshop with various backgrounds in aspect-oriented software development and software model engineering. The workshop provided a forum for discuss-ing the state of the art in modeling crosscutting concerns at different stages of the software development process: requirements elicitation and analysis, soft-ware architecture, detailed design, and mapping to aspect-oriented programm-ing constructs. This workshop summary provides an overview of the accepted submissions and summarizes the results of the different discussion groups. Papers, presentation slides, and photos from the workshop are available at http://www.aspect-modeling.org/.

Analyzing and modelling a software system with separate views is a good practice to deal with complexity and maintainability. When adopting such a modular approach for modelling, it is necessary to have the ability to automatically compose models to build a global view of the system. In this paper we propose a generic framework for composition that is independent from a modelling language. We define a process for adapting this framework to particular modelling language (defined with a metamodel) and illustrate how the generic composition has been specialized for class diagrams.

This paper describes MATA (Modeling Aspects Using a Transfor-mation Approach), a UML aspect-oriented modeling tool that uses graph transformations to specify and compose aspects. Graph transformations provide a unified approach for aspect modeling. The methods presented here can be applied to any modeling language with a well-defined metamodel. This paper, however, focuses on UML class diagrams, sequence diagrams and state diagrams. MATA takes a different approach to aspect-oriented modeling since there are no explicit join points. Rather, any model element can be a join point and composition is a special case of model transformation. We illustrate MATA on structural and behavioral models for a cell phone example.

Following the great success of previous editions, ATEM2007 is the 4

th

edition of the ATEM workshop series. The first two editions were held with WCRE in 2003 and 2004, while the 3

rd

one was held with MoDELS 2006. ATEM has always been focused on engineering of language descriptions. In order to cover as many aspects of language descriptions important for greater success and adoption of model-driven engineering, ATEM has been evolving so as its scope:

The first edition was about

metamodels

and

schemas.

The second about was

metamodels, schemas

and

grammars.

The third edition was about

metamodels, schemas, grammars

and

ontologies.

Language libraries

extend regular libraries with domain-specific notation. More precisely, a language library is a combination of a domain-specific language

embedded

in the general-purpose host language, a regular library implementing the underlying functionality, and an

assimilation

transformation that maps embedded DSL fragments to host language code. While the basic architecture for realizing language libraries is the same for all applications, there are many design choices to be made in the design of a particular combination of library, guest language syntax, host language, and assimilation. In this paper, we give an overview of the design space for syntax embeddings and assimilations for the realization of language libraries.

Domain specific languages are of increasing importance for today’s software development processes. Their area of application ranges from process modeling over architecture description and system design to behavioral specification and simulation. There are numerous approaches for the definition and implementation of DSLs. Among others, the OMG offers UML profiles as a lightweight extension of a predefined multi-purpose language and MOF as a metamodeling language, which can be used to define DSLs from scratch. This contribution investigates various approaches to define DSLs, focusing on architectural description languages as an example. Besides the usage of UML profiles and the definition of an entirely new language with MOF, the adaption of the UML based on a metamodel extension is also considered. As a consequence of the shortcomings depicted for the different approaches, we suggest to combine UML profiles and metamodeling in order to compensate their weaknesses and take advantage of their benefits.

The workshop

Model Driven Development of Advanced User Interfaces

(

MDDAUI

) aims at integrating results from the area of human-computer interaction and user interface modeling with the concepts of model-driven engineering. This paper provides a summary on the third edition of MDDAUI held as part of the MoDELS 2007 conference in Nashville, USA. In particular, it presents the results of the two group discussions of the workshop.

Novel interactive systems such as Augmented Reality are promising tools considering the possibilities they offer, but no real development methods exist at the moment to help designers in their work. We present in this paper a design method for tightly coupling early interaction design choices and software design solutions. Based on an existing model used for abstract UI design, our work introduces a second model dedicated to the software UI specification and the model-based process used to derive one from the other. To achieve this, we present here a framework based on domain-specific models and transformations to link them and thus support the development process.

User-interface design is still a time consuming and expensive task to do, but recent advances allow generating them from interaction design models. We present a model-driven approach for generating user interfaces out of interaction design models. Our interaction design models are discourse models, more precisely models of classes of dialogues. They are based on theories of human communication and should, therefore, be more understandable to humans than programs implementing user interfaces. Our discourse models also contain enough semantics to transform them automatically into user interfaces for multiple devices and modalities. This paper presents a two-step transformation approach with an intermediate user interface model. By showing specific transformation rules, we concentrate on a major part of the first step, transforming discourse models to structural user interface models.

This paper reports on the Model Size Metrics (MSM) workshop held as satellite event of the MODELS 2007 conference. The focus of the workshop is to develop metrics for use in model-centric software development. As a starting point for discussion we focused on size. The workshop aim was to bring together researchers in this area, share experiences and discuss future directions. This paper summarizes the presentations that were given and the highlights of the discussion that followed and summarizes open issues for future work.

The knowledge of size of models can be very useful to perform many kinds of estimations such as effort, cost, and productivity in software development. However, to the best of our knowledge there is no universally accepted model size measure available to date. In this paper we investigate the usefulness of class-count as a size measure of models (represented with the UML). Using empirical data collected from two student experiments we validate this measure by assessing its correlation with effort spent in modeling. The results show that merely using class-count might not provide sufficient and accurate estimation of modeling effort. Furthermore, we identify some factors that hinder class-count as a good estimate of modeling effort.

In model driven development (MDD), models are transformed automatically into other models. This leads to transformation chains. The goal of MDD is to set up efficient transformation chains, i.e. adding semantics first and platform detail later. When the platform is changed, only the later, platform specific models have to be replaced. This paper constructs metrics for measuring and comparing the models obtained through transformations in MDD processes, in order to help to set up the more efficient transformation chains.

The objective of the MOTHIS workshop was to discuss model-based methods for the design of Health Information Systems (HIS) offering a revolutionary new way for the interaction between medical patients and Health Care Providers. Although healthcare, like other information-intensive industries, has developed and deployed standards-based, secure information infrastructures it is still dependent upon paper records and fragmented, error-prone approaches to service delivery. The primary concern is that security and privacy need to be organically integrated into HIS architectures. The workshop brought together computer scientists, medical experts, and legal policy experts to discuss research results in the development and application of model-based methods for representing, analyzing and integrating, architectures, privacy and security policies, computer security mechanisms, web authentication, and human factors engineering.

This paper describes our experiences in defining the processes associated with preparing and administrating chemotherapy and then using those process definitions as the basis for analyses aimed at finding and correcting defects. The work is a collaboration between medical professionals from a major regional cancer center and computer science researchers. The work uses the Little-JIL language to create precise process definitions, the

Propel

system to specify precise process requirements, and the FLAVERS system to verify that the process definitions adhere to the requirement specifications. The paper describes how these technologies were applied to successfully identify defects in the chemotherapy process. Although this work is still ongoing, early experiences suggest that this approach can help reduce medical errors and improve patient safety. The work has also helped us to learn about the desiderata for process definition and analysis technologies, both of which are expected to be broadly applicable to other domains.

This contribution gives an overview of various access control strategies in use in healthcare scenarios and shows how a variety of policies can be modeled based on a single security policy model for usage control, UCON. The core of this contribution consists of the specialization of the

Sectet

-Framework for Model Driven Security for complex healthcare scenarios based on UCON. The resulting Domain Architecture comprises a Domain Specific Language for the modeling of policies with advanced security requirements, a target architecture for the enforcement of these policies and model-to-code transformations.

Model Driven Engineering (MDE) approaches extensively use models and automatic model transformations to handle complex software development. A plethora of software artifacts, tools, environments and modeling languages need to be developed to make MDE a reality. Consequently, there is a crucial need for effective V&V techniques in the context of MDE. Moreover, the novelty of MDE gives rise to questions concerning its impact on traditional V&V techniques, and how they can leverage this new paradigm.

In this paper, we deal with model-based automatic test generation. We show how to use UML state machines, UML class diagrams, and OCL expressions to automatically derive partitions of input parameter value ranges for boundary testing. We present a test generation algorithm and describe an implementation of this algorithm. Finally, we discuss our approach and compare it to commercial tools.

Late identification of performance problems can lead to significant additional development costs. Hence, it is necessary to address performance in several development phases by performing a performance engineering process. We show that Model-Driven Engineering (MDE) specifics can be utilised for performance engineering. Therefore, we propose a process combining MDE and performance engineering called Model-Driven Performance Engineering (MDPE).

Additionally we present our first experiences in application of MDPE concepts.

This year’s OCL workshop at the MODELS conference looked out to usages of OCL outside the direct context of UML or beyond the capabilities of standard OCL. It was a very interesting and successful workshop, which apart from the presentation of 10 papers a lively discussion on various topics surround current usage of OCL was held. Six main topics recurred throughout the discussions: (1) Means and uses of transformation to other languages, (2) Support for side-effects and executability, (3) Continuing need for OCL, (4) Providing extensions to the standard, (5) Platform independence of the language, (6) Formality of the language. This summary report presents the results of the workshop and the discussions.

OCL 2.0 specifies a standard library of predefined types and associated operations. A model-level representation of the library is required to reference its elements within the abstract syntax model created by an OCL parser. Existing OCL engines build this model in the implementation code which severely limits reusability, flexibility and maintainability. To address these problems, we show how a common pivot model with explicit support for template types can help to externalize the definition of the standard library and integrate it with instances of arbitrary domain-specific modeling languages. We exemplify the feasibility of our approach with a prototypical implementation for the Dresden OCL2 Toolkit and present a tailored EMF editor for modeling the OCL types and operations. We limit our discussion to the model level, i.e., we do not consider an implementation of the standard library for an execution engine.

OCL is used to add rigour to UML/MOF models, and in particular can be used to express behavioural details (e.g., operation pre- and postconditions, class invariants) of such models. The applicability and utility of OCL can be assessed by applying it to realistic applications and by investigating its capabilities both in terms of language characteristics and tool support. With this in mind, in this paper we model functional requirements for the Mondex Smart Card Application using UML Diagrams, demonstrate how system invariants as well as operation pre- and post-conditions are specified in OCL, and explore the degree to which OCL tool support can be used to create and validate these models. Moreover, we discuss how these pre- and post-conditions can be validated, in part by discussing how test cases can be selected from the OCL specifications created.

The second edition of the workshop Models@run.time was co-located with the ACM/IEEE 10th International Conference on Model Driven Engineering Languages and Systems. The workshop took place in the lively city of Nashville, USA, on the 2nd of October, 2007. The workshop was organised by Nelly Bencomo, Robert France, and Gordon Blair and was attended by at least 25 people from 7 countries. This summary gives an overview of the presentations and lively discussions that took place during the workshop.

Increasingly, software must dynamically adapt its behavior in response to changes in the supporting computing, communication infrastructure, and in the surrounding physical environment. Assurance that the adaptive software correctly satisfies its requirements is crucial if the software is to be used in high assurance systems, such as command and control or critical infrastructure protection systems. Adaptive software development for these systems must be grounded upon formalism and rigorous software engineering methodology to gain assurance. In this paper, we briefly describe

AMOebA-RT

, a run-time monitoring and verification technique that provides assurance that dynamically adaptive software satisfies its requirements.

The reliability of high-volume products, such as consumer electronic devices, is threatened by the combination of increasing complexity, decreasing time-to-market, and strong cost constraints. As an approach to maintain a high level of reliability and to avoid customer complaints, we present a run-time awareness concept. Part of this concept is the use of models for run-time error detection. We have implemented a general awareness framework in which an application and a model of its desired behaviour can be inserted. It allows both time-based and event-based error detection at run time. This method, coupled to local recovery techniques, aims to minimize any user exposure to product-internal technical errors, thereby improving user-perceived reliability.

The comprehensive use of models in design has created a set of challenges beyond that of supporting one isolated design task. In particular, the need to combine, couple, and integrate models at different levels of abstraction and in different formalisms is posing a set of specific problems that the field of Computer Automated Multi-Paradigm Modeling (CAMPaM) is aiming to address. This paper summarizes the results of the 2nd Workshop on Multi-Paradigm Modeling: Concepts and Tools.

We present ModHel’X, an approach to multi-formalism modeling which addresses two important issues in this field: (a) providing support for the specification of the semantics of a modeling formalism, and (b) allowing the specification of the interactions between parts of a model described using different modeling formalisms. ModHel’X is based on the concept of Model of Computation and focuses on the execution of models, considered as the computation of one possible behavior of the model. The structural elements of a modeling language are described by specializing the meta-model of ModHel’X whereas its semantics, i.e. the corresponding model of computation, is described by specializing the predefined stages of a generic execution model. Using the same mechanisms, designers can specify the semantic adaptation that is suitable at each interface between heterogeneous parts of their model. Finally, ModHel’X comes with an execution engine which is able to interpret heterogeneous models for simulation.

Today, integrated development environments such as

Eclipse

allow users to write programs quickly by presenting a set of recommendations for code completion. Similarly, word processing tools such as

Microsoft Word

present corrections for grammatical errors in sentences. Both of these existing systems use a set of constraints expressed in the form of a grammar to restrict/correct the user. Taking this idea further, in this paper we present an integrated software system capable of generating recommendations for model completion of partial models built in arbitrary domain specific model editors. We synthesize the model editor equipped with automatic completion from a modelling language’s declarative specification consisting of a meta-model and constraints on it along with a visual syntax. The automatic completion feature is powered by a

Prolog

engine whose input is a constraint logic program derived from some models. The input logic program is obtained by a model transformation from models in multiple languages: the meta-model (as a class diagram), constraints on it (as constraint logic clauses), and a partial model (in the domain specific language). The

Prolog

engine solves the generated logic program and the solution(if there is one) is returned to the model editor as a set of recommendations for properties of the partial model. We incorporate automatic completion in the generative tool

AToM

3

and use

SWI-Prolog

for constraint representation and satisfaction. We present examples using an illustrative visual language of

Finite State Machines

.

Introduction of Model Driven Development (MDD) raises new challenges in software quality management related to shifting the focus to models from text documents and code. The goal of this workshop was to gather researchers and practitioners interested in the emerging issues of quality in the context of MDD and to provide a forum for discussions of emerging issues related to software quality in MDD. An intended outcome of the workshop was an initial elaboration of a unified quality model for models. The paper reports activities performed in the workshop and the main results achieved throughout the workshop as well as during the follow-up activities. The workshop was divided into two parts: presentation part, where paper contributions were presented and discussed, and working part, where a guided discussion was conducted aimed at elaboration of a common quality model. The working part was preceded by an introductory presentation setting up a frame for the discussion, followed by concise position statements of the participants, and discussion towards formulation of a common quality model. As a follow-up activity, the contributions from the working part were combined into a common quality model published as a technical research report and highlighted in the paper. Future research directions and planned activities are also outlined.

This paper presents some related work on quality frameworks and requirements for evaluating them. It also discusses characteristics of model-driven engineering that are important when building a quality framework, such as its use of models in several stages of development and maintenance, generation of other artifacts from models and its multi-abstraction level approach that requires consistency and traceability. We present a 7-step process on how to define a quality framework that is adapted to model-driven engineering, and which integrates quality engineering with quality evaluation. As an example, the framework is applied on transformation quality. We maintain that the transformation process and transformation mapping should be discussed separately, as they require different approaches, and suggest quality goals, quality-carrying properties to achieve the quality goals and methods for evaluating these properties.

The MoDELS 2007 Doctoral Symposium provided a forum for Ph.D. students, conducting research in model-driven software engineering, to discuss their goals, methodology and results at an early stage in their research, in a critical but supportive and constructive environment. The symposium offered an opportunity for the eight student participants to interact with other students at a similar stage in their careers and with the mentoring board composed of five experts in the software modeling field. The students received practical guidance for the completion of the dissertation research and motivation for a research career. This summary offers an overview of the activities that occurred at the Symposium.

For a widespread success of the model-driven paradigm, appropriate tools such as “Version Control Systems” (VCS) allowing for consistency maintenance between concurrently edited model versions are required to adequately support a model-based development process. Initial attempts for graph-based versioning of model artifacts are either tightly coupled to the modeling environment, not flexible with respect to the used modeling language or cannot interpret the model’s semantics. On basis of those characteristics, the goal of the outlined thesis presented in this paper is to provide mechanisms to detect conflicting modifications between parallel edited model versions more accurately. By reducing falsely indicated conflicts and by finding additional semantic conflicts, the resolution process can be simplified by means of appropriate techniques for comparison, conflict detection, conflict resolution and merge.

Technologies based on aspects and applied at the early stages of software development allow requirements engineers to better encapsulate crosscutting concerns in requirements models. The Aspect-oriented User Requirements Notation (AoURN) extends the User Requirements Notation (URN) with aspects and thus unifies goal-oriented, scenario-based, and aspect-oriented concepts in one framework. Minimal changes to URN ensure that requirements engineers can continue working with goal and scenario models expressed in a familiar notation. At the same time, concerns in goal and scenario models, regardless of whether these concerns crosscut or not, can be managed across model types. Typical concerns in URN are non-functional requirements (NFRs), use cases, and stakeholder goals. As AoURN expresses concern composition rules with URN itself, it is possible to describe rules in a highly flexible way that is not restricted by any specific composition language. Aspects can improve the modularity, reusability, scalability, and maintainability of URN models. Considering the strong overlap between NFRs and crosscutting concerns, aspects can help bridge the gap between goals and scenarios. On the other hand, Early Aspects (EA) research can benefit from a standardized way of modeling concerns with AoURN.

Models are an integral part of every engineering discipline, as they become in software engineering. Modeling can be done in many ways and with different levels of formality. Teaching modeling is as important as the modeling itself since it educates the future engineers in good modeling practices. Without proper education in modeling software engineering cannot evolve into mature engineering discipline. This year’s symposium was devoted to invited talks by practitioners and researchers who teach modeling and cooperate with industry. This document summarizes the symposium and the main discussion points. It also outlines the main future research directions in education in modeling.