MODELSWARD 2014 Abstracts


Area 1 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 2
Title:

Using the Base Semantics given by fUML for Verification

Authors:

Alessandro Gerlinger Romero, Klaus Schneider and Maurício Gonçalves Vieira Ferreira

Abstract: The lack of formal foundations of UML results in imprecise models since UML only defines graphical notations, but not their formal semantics. However, in safety-critical applications, formal semantics is a requirement for verification. Semantics for the key parts of activities and classes of UML is defined by the semantics of a foundational subset for executable UML models (fUML). Moreover, the base semantics given by fUML defines the formal semantics of UML. In this paper, we evaluate a subset of the base semantics given by fUML covering its formal definition and its use for verification. From the practical perspective, we show with a simple example how the base semantics can support formal verification through theorem proving. The initial results show that the base semantics, when mature, can play an important role in the formal verification of UML models.

Paper Nr: 7
Title:

An Industrial Case Study on using Language Workbench Technology for Realizing Model-Driven Engineering

Authors:

Xi Zhu, Congchi Phung, Lars Pareto, Staffan Ehnebom, Mikael Krekola, Magnus Christerson and Mats Helander

Abstract: Model Driven Engineering (MDE) is a proven approach to improve software development processes by automation. However, traditional development of MDE tooling requires a high upfront cost. Recent developments in language workbench technologies promise to significantly reduce these investment costs. By providing domain experts with targeted projections, the speed and quality of delivering customer value is improved. This paper provides results from an industrial case study in the telecommunications domain and compares the value of using a language workbench to traditional MDE technologies. Evaluation of the approach was based on qualitative research strategy which involved a proof of concept implementation and effort estimations by tooling experts. Our results, using the Intentional Domain Workbench, indicate that applying a language workbench promises significant improvements in several aspects of MDE based software development. Most notably in this paper: (1) improved speed in development of domain specific tooling and (2) improved speed in software development process re-engineering.

Paper Nr: 27
Title:

An EMF-based Toolkit for Creation of Domain-specific Data Services

Authors:

Andreas Bender, Stefan Bozic and Ivan Kondov

Abstract: Development of composite workflow applications in science and engineering is troublesome and costly due to high heterogeneity of data representations and data access interfaces of the underlying individual components. As an effective solution we present a generic toolkit enabling domain experts to develop data models and automatically generate a self-contained data access service. We defined a custom metamodel based on Ecore which can be readily used to create domain-specific data models. Using the generated data access service, instances of the modeled data residing on heterogeneous and distributed resources, such as databases and cloud data stores, are accessible from the individual application components via a language-independent Web service interface. We discuss the framework architecture, the toolkit implementation, the deployment process, as well as the performance of the data access service. Workflow designers as target users would benefit from the toolkit by using it for rapid and cost-efficient application integration.

Paper Nr: 28
Title:

A Graph-based Algorithm for Three-way Merging of Ordered Collections in EMF Models

Authors:

Felix Schwägerl, Sabrina Uhrig and Bernhard Westfechtel

Abstract: Version control for models is not yet supported in an adequate way. In this paper, we address three-way merging of model versions. Based on a common base version b, two alternative versions a1 and a2 were developed by copying and modifying the base version. To reconcile these changes, a merged version m is to be created as a common successor of a1 and a2. We present a graph algorithm to solve an important subproblem which occurs in three-way model merging: merging of (linearly) ordered collections. To create the merged version, a generalized topological sort is performed. Conflicts occur if the order of elements cannot be deduced automatically; these conflicts are resolved either interactively or by default rules. We have implemented the merge algorithm in our tool BTMerge, which performs a consistency-preserving merge of versions of EMF models being instances of arbitrary Ecore models. By taking arbitrary move operations into account, the algorithm considerably goes beyond the functionality of contemporary merge tools which are based on common subsequences and thus cannot adequately handle move operations.

Paper Nr: 33
Title:

Collaborative Editing of EMF/Ecore Meta-models and Models - Conflict Detection, Reconciliation, and Merging in DiCoMEF

Authors:

Amanuel Koshima and Vincent Englebert

Abstract: Despite the fact that Domain Specific Modeling tools become very powerful and more frequently used, the support for their cooperation has not reached its full strength and demand for model management is growing. In cooperative work, the decision agents are semi-autonomous and therefore a solution for reconciliating DSM after a concurrent evolution is needed. Conflict detection and reconciliation are important steps for merging of concurrently evolved (meta)models in order to ensure collaboration. In this work, we present a conflict detection, reconciliation and merging framework for concurrently evolved meta-models and models. Besides, we formally specify the EMF Ecore meta-model into set constructs that help to analyze the (meta)model and operations performed on it.

Paper Nr: 34
Title:

A Domain Specific Language for Stepwise Design of Software Architectures

Authors:

Fabian Gilson and Vincent Englebert

Abstract: Stakeholders have to face requirements in increasing number and complexity. Their translations to system functionalities are often diluted into the overall architecture so that it becomes tricky to undertake future changes. Since information systems are intended to evolve in terms of functionalities and underlying technologies, the link between requirements and design artifacts is primordial. Agile design methods and documentation techniques have emerged in the past years in order to deal with the amount of requirements and to trace the decision process and the rationale sustaining a software model. Also, it is not unusual that numerous technologies with similar purpose are confronted to each other during the design phase. In the present work, we propose an integrated framework combining system requirement definitions, a component-based modeling language and model transformations. Architecturally-significant requirements are explicitly linked to software architecture elements and iteratively refined or implemented by model transformations. Any transformation must be documented, even briefly, and the framework retains the transformations tree. This way, the iterative decision and design processes are completely documented for future reference or modification, i.e, designers can (i) see the mapping between a system requirement and its implementation in the architecture model, (ii) explore design alternatives or apply structural modifications without losing previous versions of the model, and finally (iii), depending on the level of documentation, at least understand partially the reasons why the model is how it is.

Paper Nr: 36
Title:

Specifying Trace Directives for UML Attributes and State Machines

Authors:

Hamoud Aljamaan, Timothy C. Lethbridge , Omar Badreddin, Geoffrey Guest and Andrew Forward

Abstract: Developers using model driven development (MDD) to develop systems lack the ability to specify traces that operate at the model level. This results in specification of traces at the generated code level. In this paper, we are proposing trace directives that operate at the model level to specify the tracing of UML attributes and state machines. Trace directives are implemented as part of the Umple textual modeling language, thus these directives can be expressed in a textual form. Trace code will be injected into system source code that corresponds to trace directives specified at the model level.

Paper Nr: 38
Title:

What are the used Activity Diagram Constructs? - A Survey

Authors:

Gianna Reggio, Maurizio Leotta, Filippo Ricca and Diego Clerissi

Abstract: UML Activity diagrams offer a very large set of constructs, however many of them seem scarcely used or even their existence is not known. Here, we present a precise view of the usage levels of these constructs by means of a survey, covering preliminarily books, courses, tutorials, and tools about UML. Results show that, among the 47 Activity diagrams constructs, a large majority of them seem to be scarcely used, while, only nine result widely used. This work is part of a larger project aimed at investigating the usage level of the UML diagrams and their constructs, also by means of a personal opinion survey intended for UML users. UML is really a huge notation, and as consequence, on one hand, it is difficult and time consuming to master it, and on the other hand, people tend, naturally, to consider only a part of it; by means of this empirical study we want to assess what are the most/less used UML diagrams/constructs.

Paper Nr: 41
Title:

Modeling of Tool Integration Resources with OSLC Support

Authors:

Weiqing Zhang and Birger Møller-pedersen

Abstract: This paper discusses a class modeling approach for managing tool integration. Model concepts like Artifact and Role are introduced as integration backbones. Artifacts represent real artifacts like model elements that are maintained by tools. Different kinds of tools require different kinds of Artifact classes. The Role classes capture integration scenario-specific properties for Artifacts. As the same Artifact may be involved in different scenarios, and as integration scenarios may come and go, Roles can be dynamically attached to Artifacts. It is also demonstrated the possibility to model with Artifacts and Roles alone, without any real model elements. OSLC Web services (and as part of that, OSLC resources) are generated from these class models, and it is demonstrated that class modeling of Artifacts are superior to plain OSLC specification of resources.

Paper Nr: 46
Title:

Typing and Subtyping of Metamodels

Authors:

Henning Berg and Birger Møller-pedersen

Abstract: In model-driven engineering, models are considered first-class entities. Model-driven engineering has been around for over a decade. Still, there has not been much work on how to type models or metamodels, which is important to realise true model-driven software development. In this paper, we discuss how a metamodel can be typed by means of an enclosing class whose state can be utilised by tools such as editors and interpreters. This allows using established object-oriented mechanisms on the metamodel level and supports specialisation of metamodels.

Area 2 - Applications and Software Development

Full Papers
Paper Nr: 47
Title:

The MDArte Experience - Organizational Aspects Acquired from a Successful Partnership between Government and Academia using Model-Driven Development

Authors:

Rodrigo Salvador Monteiro, Roque Elias Assumpção Pinel, Geraldo Zimbrão and Jano Moreira de Souza

Abstract: Developing and evolving critical information systems in order to cope with changes in regulations and laws is a constant worry for governments in the e-Government era. Due to the frequent challenges and some previous frustrating experiences, the Brazilian Government has searched for an alternative development method that could better fit its needs. At the same time, Brazilian Academia, represented in this case by the Computer Science Department of COPPE/UFRJ, has been researching how to bridge the gaps in order to harness the promise of Model-Driven Architecture in real life projects. A successful partnership between both started in 2005, which gave birth to a complete MDA development environment that would later be known as MDArte. The MDArte framework has been freely available since 2009 through the SPB portal (Brazilian Public Software Portal – www.softwarepublico.gov.br) and throughout its construction and evolution more than a dozen real projects have been built and maintained. During the development of such real life projects a lot of critical organizational aspects raised. The main contribution of this paper is to reveal and motivate the discussion on such organizational aspects that must be faced when deciding to adopt an MDA approach. In order to contextualize our perceptions, we present the MDArte experience, including its origin, evolution and current state. The major challenging and complex systems that have been developed with MDArte are presented as success cases along with an analysis of the benefits of using a Model Driven Development (MDD) approach.

Area 3 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 60
Title:

Signature Required - Making Simulink Data Flow and Interfaces Explicit

Authors:

Marc Bender, Karen Laurin, Mark Lawford, Jeff Ong, Steven Postma and Vera Pantelic

Abstract: Model comprehension and effective use and reuse of complex subsystems are problems currently encountered in the automotive industry. To address these problems we present a technique for extracting, presenting and making use of signatures for Simulink subsystems. The signature of a subsystem is defined to be a generalization of its interface, including the subsystem’s explicit ports, locally defined and inherited data stores, and scoped gotos/froms. We argue that the use of signatures has significant benefits for model comprehension and subsystem testing, and show how the incorporation of signatures into existing Simulink models is practical and useful by discussing various usage scenarios.

Paper Nr: 80
Title:

Short Seminars on MDE Technologies - International Experiences

Authors:

Miłosz Marek and Plechawska-Wojcik Malgorzata

Abstract: Model Driven Engineering (MDE) gives new insights into software engineering and software development. This approach is quite new and it still is the subject of discussion concerning its efficiency and usefulness. However, MDE approach becomes more and more popular among researchers and developers. That is why it is being introduced into curricula by many universities. MDE proposes a new way of software modelling. This causes a need for introduction of new ways of teaching and sharing knowledge. One of such method is short seminars dedicated to MDE technologies. The paper discusses their idea, describes three seminars conducted under three different frames and its usefulness. Some lessons learnt from this seminars are highlighted.

Area 4 - Methodologies, Processes and Platforms

Full Papers
Paper Nr: 87
Title:

Staged Model-Driven Generators - Shifting Responsibility for Code Emission to Embedded Metaprograms

Authors:

Yannis Lilis, Anthony Savidis and Yannis Valsamakis

Abstract: We focus on MDE tools generating source code, entire or partial, providing a basis for programmers to introduce custom system refinements and extensions. The latter may introduce two maintenance issues once code is freely edited: (i) if source tags are affected model reconstruction is broken; and (ii) code inserted without special tags is overwritten on regeneration. Additionally, little progress has been made in combining sources whose code originates from multiple generative tools. To address these issues we propose an alternative path. Instead of generating code MDE tools generate source fragments as abstract syntax trees (ASTs). Then, programmers deploy metaprogramming to manipulate, combine and insert code on-demand from ASTs with calls resembling macro invocations. The latter shifts responsibility for source code emission from MDE tools to embedded metaprograms and enables programmers control where the produced code is inserted and integrated. Moreover, it supports source regeneration and model reconstruction causing no maintenance issues since MDE tools produce non-editable ASTs. We validate our proposition with case studies involving a user-interface builder and a general purpose modeling tool.

Area 5 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 90
Title:

An Aspect-Oriented Model Transformation to Weave Security using CVL

Authors:

Jose-Miguel Horcas, Mónica Pinto and Lidia Fuentes

Abstract: In this paper, we combine the Common Variability Language (CVL) and the ATL Transformation Language to customize and incorporate a generic security model into any application that requires security. Security spans a large set of concerns such as integrity, encryption or authentication, among others, and each concern needs to be incorporated into the base application in a different way and at different points of the application. We propose a set of weaving patterns using model transformations in ATL to automatically weave the security concerns with the base application in an aspect-oriented way. Since different applications require different security requirements, the security model needs to be customized before its incorporation into the application. We resolve the variability of the security properties and implement the weaving process in CVL. We use an e-voting case study to illustrate our proposal using the CVL approach.

Short Papers
Paper Nr: 11
Title:

Towards a Systematic, Tool-Independent Methodology for Defining the Execution Semantics of UML Profiles with fUML

Authors:

Jérémie Tatibouët, Arnaud Cuccuru, Sébastien Gérard and François Terrier

Abstract: The purpose of UML profile mechanism is to design domain specific languages (DSL) based on UML. It exists a wide range of UML profiles: MARTE, ROOM, SysML. Current profile design methodology only considers the syntactic part of the language and keeps informal the execution semantics description. This impairs Model Driven Engineering (MDE) promises which advocates for executable models. This paper presents a systematic approach to formalize the execution semantics of UML profiles using foundational UML (normative specification) which defines a precise semantics for a subset of UML. This approach is integrated into the reference profile design methodology. It is illustrated on a small profile to support Turing machines. It demonstrates capability to execute resulting profiled models through the defined semantics.

Paper Nr: 14
Title:

Pattern-based Mapping of OCL Specifications to JML Contracts

Authors:

Ali Hamie

Abstract: OCL is a formal notation to specify constraints on UML models that cannot otherwise be expressed using diagrammatic notations such as class diagrams. The type of constraints that can be expressed using OCL include class invariants and operation preconditions and postconditions. However, since OCL constraints cannot be directly executed and checked at runtime by an implementation, constraints violations may not be detected or noticed causing many potential development and maintenance problems. This paper describes an approach for deriving a JML specification for a java implementation (a contract) from a specification written in UML and augmented with OCL constraints. This facilitates the checking of OCL constraints at runtime by translating them to JML executable assertions. The approach is based on the concept of constraint patterns that enable the reuse of commonly occurring constraints within a given context in software modelling. Each OCL constraint pattern would be mapped to a corresponding JML pattern that can be used in the translation process. The result is a library of JML constraint patterns that provides a seamless transition from UML/OCL designs to Java implementations.

Paper Nr: 15
Title:

A Case Study of Combining Compositional and Object-oriented Software Development

Authors:

Enn Tyugu, Mait Harf and Pavel Grigorenko

Abstract: We analyze an approach to software development where object-oriented and compositional software specifications are written in separate languages and are only loosely connected. It supports compositional design of software in a domain-specific language and automatic model-driven construction of code from classes written in Java. We justify our approach by giving examples of development of large simulation programs and services on large models. We present also an example of using our method in general purpose software development – this is bootstrapping the essential part of a software tool CoCoViLa, i.e. synthesizing CoCoViLa in CoCoViLa itself.

Paper Nr: 17
Title:

Model Composition for Biological Mathematical Systems

Authors:

Mandeep Gill, Steve McKeever and David Gavaghan

Abstract: Mathematical models are frequently used to model biological process, such as cardiac electrophysiological systems. In order to separate the models from the implementations, and to facilitate curation, domain specific languages (DSLs) have become a popular and effective means of specifying models (Lloyd et al., 2004; Hucka et al., 2004). In previous papers (Gill et al., 2012a; Gill et al., 2012b; McKeever et al., 2013) we have argued for including parameterised modules as part of such DSLs. We presented our prototype Ode language and showed how models could be created in a generic fashion. In this paper we extend our work with concrete examples and simulation results. We show how complex heart models can be constructed by aggregation, encapsulation and subtyping. Our use-case retraces the steps taken by (Niederer et al., 2009), which investigated the common history between cardiac models, and shows how they can be cast in our language to be reused and extended. Our DSL enables ‘physiological model engineering’ through the development of generic modules exploiting high cohesion and low coupling.

Paper Nr: 19
Title:

Enhanced Code Generation from UML Composite State Machines

Authors:

Omar Badreddin, Timothy C. Lethbridge, Andrew Forward, Maged Elaasar, Hamoud Aljamaan and Miguel A. Garzon

Abstract: UML modelling tools provide poor support for composite state machine code generation. Generated code is typically complex and large, especially for composite state machines. Existing approaches either do not handle this case at all or handle it by flattening the composite state machine into a simple one with a combinatorial explosion of states, and excessive generated code. This paper presents a new approach that transforms a composite state machine into an equivalent set of simple state machines before code generation. This avoids the combinatorial explosion and leads to more concise and scalable generated code. We implement our approach in Umple. We report on a case study, comparing our approach to others in terms of code size and scalability.

Paper Nr: 20
Title:

Defining Domain Specific Transformations in Human-Computer Interfaces Development

Authors:

Jean-Sébastien Sottet and Alain Vagner

Abstract: Early model-based approaches for Human-Computer Interaction (HCI) clearly depicted models and frameworks for generating User Interfaces (UI) but considered model transformations as black-boxes. In the 2000's, these approaches were criticized due to the poor quality of the produced UI. One of the main reasons of this poor quality can be easily observed in state of the art UI transformations: they are the heart of designers' know-how but are maintained by a minority of specialists. Meanwhile, mainstream UI design methods have shown a growing number of heterogeneous stakeholders that collaborate to produce modern and qualitative UI. We claim that these stakeholders must comprehend and interact with transformations and thus we need to make the transformation language affordable to these stakeholders. Indeed, such a simplification should hide transformations complexity and burden for any stakeholder, finally focusing on a specific part of the design domain: a Domain Specific Language (DSL) for transformations or Domain Specific Transformation Language (DSTL). We provide in this paper a method and a supporting tool for systematizing and finally executing DSTL for model-driven UI development. We depict that framework on a proof of concept implementation for an HCI-specific stakeholder: the usability expert.

Paper Nr: 21
Title:

A Novel Approach to Versioning and Merging Model and Code Uniformly

Authors:

Omar Badreddin, Timothy C. Lethbridge and Andrew Forward

Abstract: Model Driven Architecture (MDA) advocates the use of models, rather than code, as the main development artifact. Yet model versioning and merging tools still lag in capabilities, ease of use and adoption relative to source code versioning and merging tools. This forces many teams to avoid model-based collaboration and concurrent model modifications. In this paper, we highlight the main challenges behind the relatively small adoption of model merging approaches. We present a novel model-based programming technology that addresses many of those challenges. The approach treats code and models uniformly, effectively enabling modelers to version and merge models using existing text-based technologies.

Paper Nr: 24
Title:

Analysis and Validation of AUTOSAR Models

Authors:

Julian Kienberger, Pascal Minnerup, Stefan Kuntz and Bernhard Bauer

Abstract: As the rise of single-core processing power is exhausted due to technical limitations, the automotive branch is forced to migrate its control unit software to architectures that feature multiple Independent Execution Units (IEUs). This policy shift brings along new problems resulting from the tremendously increased complexity of such systems. Facing these challenges, software engineers have to cope with possible data inconsistencies caused by, e.g., race conditions or cycles. Being an important and standardized software architecture for electronic control units, the Automotive Open System Architecture (AUTOSAR) provides the basis for tools that support the complexity handling when migrating to architectures with multiple IEUs. Our concept is realized by a tool that executes data dependency analyses directly on AUTOSAR models, determines critical dependencies, automatically solves trivial problems and provides semi-automatic resolution of advanced conflicts. To support the actual parallelization of the system, the tool additionally determines groups of executable units that are suitable to run on a common IEU. This appreciably facilitates the validation of AUTOSAR models and the search for a good mapping of the processing tasks to IEUs.

Paper Nr: 25
Title:

A Framework for Model Recommenders - Requirements, Architecture and Tool Support

Authors:

Andrej Dyck, Andreas Ganser and Horst Lichter

Abstract: Content-assist systems and code completion are nicely accessible in integrated development environments (IDEs). Using multiple data sources and performing sophisticated completion in several editors is quite common. However, no such supporting system exists for modeling environments, e.g., a completion mechanism in class diagrams is only existent for textual items like names, if at all. We designed a framework to bolster model recommendation research and present the requirements, concepts, architecture, and the realization below. Last of which is easily extendable and adaptable to either new data recommendation strategies or new environments like editors. As additional tool support, we provide a simulation environment, which ease development as well as implementing recommendation algorithm. Accordingly, researchers get all the conceptual groundwork and a realized infrastructure that ease the initial burden to start recommendations in modeling environments.

Paper Nr: 26
Title:

On Designing Recommenders for Graphical Domain Modeling Environments

Authors:

Andrej Dyck, Andreas Ganser and Horst Lichter

Abstract: Recommender systems for source code artifacts are newly emerging and are now successfully supporting programmers. Their underlying knowledge bases, recommender algorithms, and user interfaces are well studied. Integrated into the development environment, they do a fairly good job in reducing complexity and development time. In contrast, research in recommender systems for domain modeling is widely missing. As a matter of fact, knowledge bases, studied as model libraries, are only a possible foundation but concerning recommender algorithms and user interface design research needs to be conducted. Hence, we provide some foundations for graphical user interface design by answering how domain model recommender systems should look and feel like in graphical environments. To do so, we conducted a three-phased survey relating to modeling of UML class diagrams. Most importantly, we found that various user interfaces are required to meet different user needs. Finally, several algorithms are desired for diverse knowledge bases and diagram types; hence, leading to a demand for a flexible recommender architecture.

Paper Nr: 31
Title:

A Bottom Up SPL Design Method

Authors:

Jihen Maâzoun, Nadia Bouassida and Hanêne Ben-abdallah

Abstract: Software Product Lines (SPL) can be constructed through either a top-down or bottom-up process. A top-down process begins by a domain analysis where variability is speci ed and then products are derived. It is especially interesting for the creation of new product lines. However, in practice, SPL are often set up after several similar product variants have been in use. This practical fact prompted the search for bottom-up processes that start from existing product variants to identify the product line. In general, the proposed bottom-up processes rely on extraction of feature model from source code. However, note that the information contained in the feature model is insucient for the understanding of SPL and also for their maintenance and future evolution. For these reasons, we propose in this paper a bottom-up approach that extracts from the source code of product variants, the SPL design enriched with information extracted from the feature model. This design is represented with a UML pro le. This enriched design could be used for the comprehension of the SPL and it could also be very useful in case of SPL evolution or restructuring.

Area 6 - Applications and Software Development

Short Papers
Paper Nr: 32
Title:

Supporting Concurrent Development of Requirements and Architecture - A Model-based Approach

Authors:

Andreas Vogelsang, Sebastian Eder, Georg Hackenberg, Maximilian Junker and Sabine Teufl

Abstract: A system’s requirements and its architecture are usually developed at least partly in parallel. This demands a continuous and automated assessment to confirm that the architecture conforms to its requirements. To enable such an assessment, the stepwise formalization of informal requirements has been proposed. However, there is no canonical set of artifacts and analysis techniques that has been evaluated for this task in practice yet. In this paper we propose an artifact model and a process that enables the continuous conformance assessment between requirements and architecture in a model-based context. We evaluate both in a development project with a group of students.

Area 7 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 37
Title:

A Formal Semantics for Sequence Diagrams and a Strategy for System Analysis

Authors:

Lucas Lima, Juliano Iyoda and Augusto Sampaio

Abstract: We propose a semantics for Sequence Diagrams based on the COMPASS Modelling Language (CML): a formal specification language to model systems of systems. A distinguishing feature of our semantics is that it is defined as part of a larger effort to define the semantics of several diagrams of SysML, a UML profile for systems engineering. We have defined a fairly comprehensive semantics for Sequence Diagrams, which comprises sequential and parallel constructors, loops, breaks, alternatives, synchronous and asynchronous messages. We illustrate our semantics with a scenario of a case study of a system of systems. We also discuss an analysis strategy which involves an integrated view of several diagrams.

Paper Nr: 39
Title:

A Language for Enabling Model-Driven Analysis of Business Processes

Authors:

Paolo Bocciarelli, Andrea D’Ambrogio and Emiliano Paglia

Abstract: The use of simulation-based approaches for the analysis of business processes enables the design-time prediction of the process behavior and/or the operation-time process reconfiguration. However, the effectiveness of BP simulation is still limited for several reasons (e.g., lack of simulation know-how of BP analysts, simulation model parameters that can be hard to gather, large semantic gap between the business process model and the simulation model). To overcome such limitations, this paper introduces a model-driven method to automatically build the executable simulation code of a business process from its abstract definition in BPMN, the standard language for specifying business processes. The simulation code is specified in eBPMN, a novel domain-specific language that has been designed and implemented according to the BPMN execution semantics.

Paper Nr: 42
Title:

Validating the Functional Design of Embedded Systems against Stakeholder Intentions

Authors:

Marian Daun, Thorsten Weyer and Klaus Pohl

Abstract: In the embedded systems industry, function-centered engineering is commonly applied to address the increasing number and complexity of system functions. During function-centered engineering, the functional design that is created based on the defined requirements for the system is the main artifact that serves as a basis for subsequent development activities. If stakeholder intentions change and modifications become necessary, they are frequently incorporated directly into the functional design without updating the behavioral requirements accordingly. As a consequence, the correctness of the interplay of system functions as defined in the functional design cannot be assessed by checking it against the defined requirements (since they are outdated) but needs to be checked against the current stakeholder intentions. More precisely, the requirements engineer has to validate the functional design against the stakeholder intentions because he is the expert concerning the stakeholder intentions and can communicate with the stakeholders regarding them, if necessary. However, the requirements engineer is typically not familiar with the functional design and its notation on the one hand, and, on the other hand, the overall behavior of the system is spread across various diagrams in the functional design. Therefore, the requirements engineer needs a more abstract and consolidated view of the functional design in order to be able to validate its correctness with regard to the current stakeholder intentions. In this paper, we present an approach which is based on a specific kind of review model that is automatically generated from the functional design and supports the requirements engineer in her task. The approach that is presented in this paper is subject of ongoing research.

Paper Nr: 48
Title:

Architectural Specification and Analysis with XCD - The Aegis Combat System Case Study

Authors:

Mert Ozkaya and Christos Kloukinas

Abstract: Despite promoting precise modelling and analysis, architecture description languages (ADLs) have not yet gained the expected momentum. Indeed, practitioners prefer using far less formal languages like UML, thus hindering formal verification of models. One of the main issues with ADLs derives from process algebras which practitioners view as having a steep learning curve. In this paper, we introduce a new ADL called XCD which enables designers to model their software architectures through a Design-by-Contract approach, as for example in the Java Modelling Language (JML). We illustrate how XCD can be used in architectural modelling and analysis using the Aegis combat software system.

Area 8 - Methodologies, Processes and Platforms

Short Papers
Paper Nr: 50
Title:

SWB Process - A Business Process Management System driven by Semantic Technologies

Authors:

Hasdai Pacheco, Karen Najera, Hugo Estrada and Javier Solis

Abstract: Constant changes in the market force enterprises to continuously define and redefine their business processes, and the technology that supports them, in order to fulfill the organizational objectives. Business Process Management Systems (BPMS) are intensively used in organizations as a useful tool to face those changes. However, as stated in literature and practice, a BPMS still has to cope with the agility to adapt to changes and the low degree of automation of the BPM life-cycle. These issues have been faced through the integration of BPM with Semantic Technologies. Some proposals are focused in conceptual approaches while others involve tools to cover part of the BPM life-cycle. Nevertheless, there are no works that have implemented a BPMS that exploits Semantic Technologies for covering the whole BPM life-cycle. In this paper we present SWB Process, an industrial and Open Source BPMS completely driven by Semantic Technologies that uses ontologies to agilely support constant changes in the processes of organizations, increasing the degree of automation of the BPM life-cycle. Moreover, we take advantage of ontologies to quickly adapt it to new BPM needs. SWB Process has been validated through real projects in several government agencies in Mexico.

Area 9 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 52
Title:

A New Flexible Method for Advising Metamodel Matching

Authors:

Lamine Lafi, Jamel Feki and Slimane Hammoudi

Abstract: One relevant issue in metamodel matching is how to select the most suitable matching technique to execute for a given couple of metamodels, and how to adjust parameters (e.g., threshold, F-measure, quality). In this paper, we present a flexible method for selecting the most appropriate metamodel matching technique for a given couple of metamodels. The proposed method assists the user to choose the most suitable matching technique that provides good quality of matches. This method relies on a new quality metric called Score and, on using a decision tree. In order to validate our method, we conduct experimental results on ten real-world metamodels and four recent matching techniques.

Paper Nr: 53
Title:

Automated Composition of Sequence Diagrams via Alloy

Authors:

Mohammed Alwanain, Behzad Bordbar and Juliana K. F. Bowles

Abstract: Design of large systems often involves the creation of models that describe partial specifications. Model composition is the process of combining partial models to create a single coherent model. This paper presents an automatic composition technique for creating a sequence diagram from partial specifications captured in multiple sequence diagrams with the help of Alloy. Our contribution is twofold: a novel true-concurrent semantics for sequence diagram composition, and a model-driven transformation of sequence diagrams onto Alloy that preserves the semantics of composition defined. We have created a tool called SD2Alloy that implements the automated technique and works as follows: two given sequence diagrams are transformed in two Alloy models, and then combined according to a set of logical constraints, determined by our compositional semantics, into a final composed Alloy model. The technique can also be used to detect problems and inconsistencies in the composition of diagrams.

Paper Nr: 56
Title:

Model-Driven GUI Generation and Navigation for Android BIS Apps

Authors:

Luís Pires da Silva and Fernando Brito e Abreu

Abstract: This paper presents our approach for producing graphical user interfaces (GUIs) for functionally rich business information system (BIS) prototypes, upon a mobile platform. Those prototypes are specified with annotated UML class diagrams. Navigation in the generated GUIs is allowed through the semantic links that match the associations and cardinalities among the conceptual domain entities, as expressed in the model. We start by reviewing the Android scaffolding for producing flexible GUIs for mobile devices. The latter can present rather different displays, in terms of size, orientation and resolution. Then we show how our model-based generative technique allows producing prototypes that match both the Android GUIs requirements, while implementing our model-driven approach for user navigation.

Area 10 - Methodologies, Processes and Platforms

Short Papers
Paper Nr: 59
Title:

A Model-based Tool for Generating Software Process Model Tailoring Transformations

Authors:

Luis Silvestre, María Cecilia Bastarrica and Sergio F. Ochoa

Abstract: Tailoring is the mechanism of adapting a software process to the needs of a project. Model-Driven Engineering (MDE) provides a formal basis and tools infrastructure for automatic software process tailoring. However, the use of a MDE approach can become awkward for most process engineers, because it requires knowledge of MDE concepts and formalisms to implement the required models and tailoring transformations. Proposals trying to address this problem should balance the formality required by MDE and the usability needed by the users. This paper presents a model-based tool and its associated procedure that allow process engineers to automatically generate tailoring transformation rules using a graphical user-interface, obtaining the desired balance. The proposal is illustrated with a running example.

Area 11 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 61
Title:

A Pattern Language for Use Case Modeling

Authors:

António Miguel Rosado da Cruz

Abstract: Use case driven software development typically starts with abstract problem domain descriptions of how the users see themselves using the system being developed, and entails a series of iterative refinement steps that incrementally detail the user stories/use case model, in order to bring those descriptions to the solution domain. This process tends to produce overcrowded detailed use case models that are difficult to read, but that are essential to maintain a use case driven approach, during software construction/coding activities. Business applications typically comprise a set of functions that the users can make on the system. When a use case driven approach is used to develop business applications those typical business applications’ functions pop-up as use case patterns. This paper presents a set of use case patterns that can be found in data-centered business applications, and proposes a use case pattern language that can be used together with standard UML use case language to facilitate the understanding of detailed use case models.

Paper Nr: 63
Title:

Compiling Graph Transformation Rules into a Procedural Language for Behavioral Modeling

Authors:

Sabine Winetzhammer and Bernhard Westfechtel

Abstract: Graph transformation rules provide an opportunity to specify model transformations in a declarative way at a high level of abstraction. So far, compilers have translated graph transformation rules into conventional programming languages such as Java, C, or C#. In contrast, we have developed a compiler which translates graph transformation rules into a procedural language for behavioral modeling (Xcore). The generated code is significantly more concise and readable than programming language code. Furthermore, the code is portable since it is completely programming language independent.

Area 12 - Methodologies, Processes and Platforms

Short Papers
Paper Nr: 64
Title:

Key Features for a Successful Model-Driven Development Tool

Authors:

Beatriz Marín, Andrés Salinas, Juan Morandé, Giovanni Giachetti and Jose De la Vara

Abstract: The main focus of Software Engineering discipline is to establishing methods and processes for the effective and efficient development of software projects. One of the most relevant paradigms for achieving this goal is Model-Driven Development (MDD). MDD uses models at different abstraction levels to automatically generate software products by means of model-transformations. However, one of the main issues related to the development of MDD technologies is the lack of standardization in terms of the features that need to be considered to support the current industry needs. This difficults the comparison of existing technologies since there are not a reference point for the creation of new MDD approaches with their corresponding supporting tools. This paper analyses these industry needs through an exploratory study. From the results obtained, it states the main features that must be supported by MDD tools. In addition, this paper presents an analysis about the presence or absence of these features in a set of industrial MDD tools.

Area 13 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 66
Title:

Survey of Graph Rewriting applied to Model Transformations

Authors:

Francisco de la Parra and Thomas Dean

Abstract: Model-based software development has become a mainstream approach for efficiently producing designs, test suites and program code. In this context, model-to-model transformations have become first-class entities and their classification, formalization and implementation are the subject of ongoing research. This work surveys the characteristics and properties of graph rewriting systems and their application to formalize and implement transformations of language-based software models. A model’s structure or behaviour can be abstracted into the definition of a given graph type. Its structural and behavioural changes can be represented by rule-based transformation of graphs.

Area 14 - Methodologies, Processes and Platforms

Short Papers
Paper Nr: 69
Title:

On the Support of Multi-perspective Process Models Variability for Smart Environments

Authors:

Aitor Murguzur, Xabier De Carlos, Salvador Trujillo and Goiuria Sagardui

Abstract: Cloud service-based applications are to be adapted to serve multiple platforms and stakeholders. Atop of such services, Smart Green Buildings are fostering a plethora of processes within their sustainability life-cycle. This introduces a number of challenges, as how to support multiple perspectives of domain-specific variability and how to deal with large collections of related process variants. To tackle this, there is a need to handle multiperspective variability for processes. This paper introduces an approach to manage multi-perspective process variability by means of a meta-model and a modeling methodology, representing separately people and things variability perspectives in smart environments. Initial experimental results are also described, which indicate encouraging results for managing highly complex variability models.

Area 15 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 76
Title:

Towards Co-evolution in Model-Driven Development Via Bidirectional Higher-Order Transformation

Authors:

Bernhard Hoisl, Zhenjiang Hu and Soichiro Hidaka

Abstract: In model-Driven development (MDD), metamodels, models, and model transformations are interdependent. A change in one artifact must be reflected in all other related artifacts. Regardless of their dependencies, (meta)models and transformations can evolve autonomously rendering referenced artifacts invalid. Coupling the evolution of models to their corresponding metamodels tries to prevent such mismatches, but is currently limited to one-way adaptations and does not take model transformations into account. To eliminate these shortcomings, we combine first-class transformation models with bidirectional transformations (BX). Our generic approach integrates BX into well-established Eclipse-based MDD tools, thereby neither being restricted to a specific modeling nor model transformation language.

Area 16 - Methodologies, Processes and Platforms

Short Papers
Paper Nr: 78
Title:

An Approach based on SysML and SystemC to Simulate Complex Systems

Authors:

Abbas Abdulhameed, Ahmed Hammad, Hassan Mountassir and Bruno Tatibouet

Abstract: The complexity of heterogeneous systems has been increased during last years. One challenge of designing these systems is to deal with the application of methodologies based on Model Driven Architecture (MDA). MDA is a development framework that enables the description of systems by means of different models with transformations. This is an important area of research and consists on developping methodologies to reduce cost and time spent during their development. In our case, SysML, targets system descriptions in a high level of abstraction and provide diagrams for requirements. SystemC language is chosen as an alternative to the traditional languages and its simulation kernel is an important aspect which allows the designer to evaluate the system behaviours through simulations. This paper proposes a combined approach based on MDA concepts and rules to transform SysML semi-formal model to SystemC. The transformations are ensured by ATL language. A traffic light system is taken as a reference case study and used to illustrate our practical application. It is implemented on TopCased platform.

Area 17 - Modeling Languages, Tools and Architectures

Short Papers
Paper Nr: 84
Title:

Runtime Assertion Checking and Theorem Proving for Concurrent and Distributed Systems

Authors:

Crystal Chang Din, Olaf Owe and Richard Bubel

Abstract: We investigate the usage of a history-based specification approach for concurrent and distributed systems. In particular, we compare two approaches on checking that those systems behave according to their specification. Concretely, we apply runtime assertion checking and static deductive verification on two small case studies to detect specification violations, respectively to ensure that the system follows its specifications. We evaluate and compare both approaches with respect to their scope and ease of application. We give recommendations on which approach is suitable for which purpose as well as the implied costs and benefits of each approach.

Paper Nr: 85
Title:

Extending UML Testing Profile Towards Non-functional Test Modeling

Authors:

Federico Toledo Rodríguez, Francesca Lonetti, Antonia Bertolino, Macario Polo Usaola and Beatriz Pérez Lamancha

Abstract: The research community has broadly recognized the importance of the validation of non-functional properties including performance and dependability requirements. However, the results of a systematic survey we carried out evidenced the lack of a standard notation for designing non-functional test cases. For some time, the greatest attention of Model-Based Testing (MBT) research has focused on functional aspects. The only exception is represented by the UML Testing Profile (UML-TP) that is a lightweight extension of UML to support the design of testing artifacts, but it only provides limited support for non-functional testing. In this paper we provide a first attempt to extend UML-TP for improving the design of non-functional tests. The proposed extension deals with some important concepts of non-functional testing such as the workload and the global verdicts. As a proof of concept we show how the extended UML-TP can be used for modeling non-functional test cases of an application example.

Posters
Paper Nr: 4
Title:

Parsing Abstract Syntax Graphs with ModelCC

Authors:

Luis Quesada, Fernando Berzal and Juan-Carlos Cubero

Abstract: The tight coupling between language design and language processing in traditional language processing tools is avoided by model-based parser generators such as ModelCC. By decoupling language specification from language processing, ModelCC avoids the limitations imposed by traditional parser generators, which constrain language designers to specific kinds of grammars. Apart from providing an alternative approach to language specification, ModelCC incorporates reference resolution within the parsing process. Instead of returning mere abstract syntax trees, ModelCC is able to obtain abstract syntax graphs from its input string. Moreover, such abstract syntax graphs are not restricted to directed acyclic graphs, since ModelCC supports anaphoric, cataphoric, and recursive references.

Paper Nr: 5
Title:

A Domain-Specific Language for Abstract Syntax Model to Concrete Syntax Model Mappings

Authors:

Luis Quesada, Fernando Berzal and Juan-Carlos Cubero

Abstract: Model-based parser generators such as ModelCC effectively decouple language design from language processing. ModelCC allows the specification of the abstract syntax model of a language as a set of language elements and their relationships. ModelCC provides the necessary mechanisms to specify the mapping from the abstract syntax model (ASM) to a concrete syntax model (CSM). This mapping can be specified as a set of metadata annotations on top of the abstract syntax model itself or by means of a domain-specific language (DSL). Using a domain-specific language to specify the mapping from abstract to concrete syntax models allows the definition of different concrete syntax models for the same abstract syntax model. In this paper, we describe the ModelCC domain-specific language for ASM-CSM mappings and we showcase its capabilities by using the ModelCC ASM-CSM DSL to define itself.

Paper Nr: 8
Title:

Model-Based Systems Engineering Tools - Devoloping the GUILTE System

Authors:

Ana Luísa Ramos and José Vasconcelos Ferreira

Abstract: The GUILTE (Guiding Urban InteLligent Traffic & Environment) system is part of a large, complex, interdisciplinary, socio-technical domain at the agenda of world leaders, local authorities, academia, and society-at-large. The main purposes of the system are to provide an integrated development framework for the municipalities, and to support the operations of the urban traffic through Intelligent Transportation Systems, highlighting two fundamental aspects: the evaluation of the related environmental impacts, and the dissemination of information to the citizens, endorsing their involvement and participation. The development process of the GUILTE system was supported by a novel Model-Based Systems Engineering methodology, the LITHE (Agile Systems Modelling Engineering), which aims to lightening the complexity and burdensome of the existing methodologies by emphasizing agile principles such as continuous communication, feedback, stakeholders involvement, short iterations and rapid response, and also by a graphical tool, the GRAPHITE matrices, developed to support model-based cooperative development environments.

Paper Nr: 9
Title:

Model Matching for Model Transformation - A Meta-heuristic Approach

Authors:

Hajer Saada, Marianne Huchard, Clémentine Nebut and Houari Sahraoui

Abstract: Model Transformation By Example (MTBE) is a recent approach that derives model transformation rules from a source model, a target model, and matching between models. Building a match between models may be a complex task especially when models have been created or edited manually. In this paper, we propose an automated approach to generate mapping between source and target models. The novetly of our approach consists in the production of many-to-many mapping between the elements of the two models.

Paper Nr: 16
Title:

Hardware In the Loop for VDM-Real Time Modeling of Embedded Systems

Authors:

José Antonio Esparza Isasa, Peter Würtz Vinther Jørgensen and Peter Gorm Larsen

Abstract: This paper introduces a generic solution for gradually moving from a model of an embedded system to include embedded hardware and software components into the simulation of the model. Our technique enables combined execution (co-execution) of system components models expressed in the VDM-RT formalism with actual hardware/software realizations through the application of Hardware In the Loop (HIL) simulation. Introducing such component realizations in the simulation increases the fidelity of the simulation outcome, thus enabling improved prediction of properties for the system realization.

Paper Nr: 18
Title:

A Test-Driven Approach for Developing Software Languages

Authors:

Omar Badreddin, Andrew Forward and Timothy C. Lethbridge

Abstract: Test-Driven Development (TDD) is the practice of attempting to use the software you intend to write, before you write it. The premise is straightforward, but the specifics of applying it in different domains can be complex. In this paper, we provide aTDD approach for language development. The essence is to apply TDD at each of four levels of language processing, hence we call our approach Multi-Level TDD, or MLTDD. MLTDD can be applied to programming languages, preprocessors, domain specific languages, and transformation engines. MLTDD was used to build Umple, a model-oriented programming language available for Java, Ruby, and PHP. We present two case studies where this approach was implemented to develop two other domain specific languages.

Paper Nr: 22
Title:

Investigation and Evaluation of UML Action Languages

Authors:

Omar Badreddin, Timothy C. Lethbridge and Andrew Forward

Abstract: We analyze the current direction of UML Action Language development and provide a classification of the proposed action language structure and statements. We also present a functioning implementation of an action language and discuss our platform for experimenting with Action Language based systems. We propose a novel approach that adopts a bottom-up technique to defining an action language. This approach embeds the action language into a textual environment that includes the UML modeling elements. Unlike current action languages that typically address class diagrams only, our proposal includes class and state machine modeling abstractions as part of the action language. We tackle the problem of modeling-in-text not by introducing yet another programming language, but instead by providing an increased level of abstraction to existing high level programming languages. Both, a textual representation of the model and its visual view represent the same underlying model but from different vantage points.

Paper Nr: 29
Title:

A Recipe for Tool Interoperability

Authors:

Andreas Baumgart and Christian Ellen

Abstract: Typical engineering and verification workflows for safety-relevant systems are performed with many different tools. For such workflows safety standards like the automotive ISO 26262 require traceability of all V\&V-related work products. Therefore, efficient tool-integration, while ensuring all traceability needs for functional safety, is a highly relevant topic for industrial domains. Recent research projects like CESAR have addressed this topic by reusing tools and methods for different workflows in the context of requirements and systems engineering as well as verification and validation. This reuse is done in a Reference Technology Platform (RTP) with common services and a common understanding of exchanged information based on an Interoperability Specification (IOS). Recently, OSLC is discussed for such an IOS. The open question is how tools are connected efficiently and how traceability is ensured. This document provides a guideline on how to use the IOS for engineering workflows performed with different tools based on OSLC. We call it recipe. The recipe was developed in the MBAT project. \note{ \proposal{This document provides a guideline on how to use the IOS for engineering workflows performed with different tools based on OSLC. We call it the "`recipe"'. The recipe was developed in the MBAT project."'} \done} It considers a systematic definition of semantic concepts for an IOS ensuring traceability and the level of granularity required to perform workflows with a set of tools.

Paper Nr: 43
Title:

Semantic Approach to Automatically Defined Model Transformation

Authors:

Tiexin Wang, Sebastien Truptil and Frederick Benaben

Abstract: Modelling and model transformation are regarded as two pillars of model-driven engineering; they have been used together to solve practical problems. For instance, since different models (e.g. data model) are used by heterogeneous partners involved in a specific collaborative situation, there is an urgent need for model transformations to exchange information among the heterogeneous partners. To quickly define model transformations, this paper presents an approach, which could replace the users’ effort in making mappings during the definition of a model transformation process. This approach is based on model transformation methodology, using syntax and semantic relationship among model elements. For this, a generic meta-meta-model and semantics checking methodology are proposed, before being illustrated by an example.

Paper Nr: 44
Title:

Verbalization of Business Rules - Application to OCL Constraints in the Utility Domain

Authors:

Rayhana Baghli and Bruno Traverson

Abstract: Business rules are defined, specified and validated by business experts but they are designed and implemented by technical implementers. Each of them uses languages adapted to their activity and skill. Verbalization of business rules permits to business experts to get a semi-natural expression of rules designed by technical implementers thus facilitating their task of validation. A transformation tool is proposed to automate verbalization and applied to OCL (Object Constraint Language) constraints in the Utility domain.

Paper Nr: 45
Title:

Natural-language Scenario Descriptions for Testing Core Language Models of Domain-Specific Languages

Authors:

Bernhard Hoisl, Stefan Sobernig and Mark Strembeck

Abstract: The core language model is a central artifact of domain-specific modeling languages (DSMLs) as it captures all relevant domain abstractions and their relations. Natural-language scenarios are a means to capture requirements in a way that can be understood by technical as well as non-technical stakeholders. In this paper, we use scenarios for the testing of structural properties of DSML core language models. In our approach, domain experts and DSML engineers specify requirements via structured natural-language scenarios. These scenario descriptions are then automatically transformed into executable test scenarios providing forward and backward traceability of domain requirements. To demonstrate the feasibility of our approach, we used Eclipse Xtext to implement a requirements language for the definition of semi-structured scenarios. Transformation specifications generate executable test scenarios that run in our test platform which is built on the Eclipse Modeling Framework and the Epsilon language family.

Paper Nr: 55
Title:

The Eclipse Java Metamodel - Scaffolding Software Engineering Research on Java Projects with MDE Techniques

Authors:

Pedro Janeiro Coimbra and Fernando Brito e Abreu

Abstract: Java on the Eclipse IDE is a frequent choice for software development nowadays. Software Engineering researchers have built program analysis tools in that environment for several purposes. However, that requires a deep understanding of Eclipse internals, such as the Java AST. This paper discusses the feasibility of a metamodel-driven approach to scaffold the construction of such tools. Its core is the Eclipse Java Metamodel (EJMM), obtained through reverse engineering. The latter is instantiated with meta-objects representing the constructs of a given Java program. We then use OCL to traverse programs very easily. To validate the feasibility of our metamodel-driven approach to program analysis, we developed an Eclipse plug-in based on it, to support the metamodel-driven measurement (M2DM) approach.

Paper Nr: 65
Title:

Transformation BPEL Processes to RECATNet for Analysing Web Services Compositions

Authors:

Ahmed Kheldoun and Malika Ioualalen

Abstract: One of the most important advantages of Web services technology is the possibility of combining existing services to create a new composite Web process according to the given requirements. BPEL is a promising language which describes web service composition in form of business processes. However, BPEL is an XML-based language and lack of a sound formal semantic, which hinders the formal analysis and verification of business processes specified in it. In this paper, we propose an approach based RECATNet to model and verify BPEL processes. We present some transformation rules of BPEL business processes into RECATNet. Since RECATNets semantics may be defined in terms of the conditional rewriting logic, Maude tools may be used for model-checking the correctness of BPEL processes. A case study is given to show the efficiency of our approach.

Paper Nr: 70
Title:

iArch - An IDE for Supporting Abstraction-aware Design Traceability

Authors:

Di Ai, Naoyasu Ubayashi, Peiyuan Li, Shintaro Hosoai and Yasutaka Kamei

Abstract: Abstraction has been an important issue in software engineering. However, it is not easy to design an architec- ture reflecting the intention of developers and implement the result of a design as a program while preserving an adequate abstraction level. To deal with this problem, we provide iArch, an IDE (Integrated Development Environment) for supporting abstraction-aware traceability between design and code. The iArch IDE is based on Archface, an architectural interface mechanism exposing a set of architectural points that should be shared between design and code. An abstraction level is determined by selecting architectural points.

Paper Nr: 71
Title:

An Approach to Class Diagram Design

Authors:

Chebanyuk Elena

Abstract: An approach to class diagram design is suggested in this paper. The approach is based on the analysis of behavioral software models represented by collaboration diagrams. An analytical form of collaboration diagrams representation is suggested. Rules that define relations between class diagram constituents by analyzing the analytical representation of collaboration diagrams are presented. An approach to defining the relations between class diagram constituents that is based on these rules is suggested. An example of class diagram design by analyzing collaboration diagrams according to the suggested approach is presented.

Paper Nr: 74
Title:

A Deployment-oriented Development Process based on Context Variability Modeling

Authors:

Ka Chun Anthony Lee, Maria-Teresa Segarra and Stephane Guelec

Abstract: and more complicated. In order to tackle the difficulty of achieving adaptive and distributed deployment, a deployment-oriented development process is presented in this paper. While existing deployment methodologies are lack of variability concern, the approach takes advantage of a variability model in order to define context variability at design time. With the usage of a transformation utility and a deployment system, deployment constraints that identified by software architects can be enforced from design time to deployment time. It facilitates the deployment tasks for software architects by automating the interpretation between abstract definitions and operation detail. The approach will be presented with a use case scenario and some model example in order to point out the research orientation and position.

Paper Nr: 75
Title:

Resourcebus - A New Substrate for Model-driven Creations

Authors:

Petr C. Smolik and Pavel Vitkovsky

Abstract: In this paper we present our on-going work on a framework we are building as a basis for construction of modeling and metamodeling environments. Resourcebus is basically a web-based resource-oriented computing environment for creation and execution of dynamic resources based on interpretation of models. Resourcebus adheres to the linked data principles and REST architectural style, and enables publishing models on the web using open standards. The framework includes built-in versioned storage, caching, access control, and set of various interpreters. We are developing Resourcebus primarily as a runtime environment for model storage, model interpretation, and code generation. Resourcebus itself knows nothing about metamodels and does not implement any particular meta-metamodel. It just provides an environment for creating them. We conclude this paper with a list of issues that still need to be resolved.

Area 18 - Methodologies, Processes and Platforms

Posters
Paper Nr: 81
Title:

Integrating Testing into Agile Software Development Processes

Authors:

R. van den Broek, M. M. Bonsangue, M. Chaudron and H. van Merode

Abstract: Although Agile methodologies have grown very popular, there is a limited amount of literature that combines Agile software methodologies and testing, especially on how testing is integrated with Scrum. In this paper we present an analysis of problem based on case study performed at the IT department of KLM regarding testing in a Scrum team. After having triangulated our results with several interviews with external topical experts and existing literature we propose a visual model that integrates testing activities in Scrum.

Area 19 - Modeling Languages, Tools and Architectures

Posters
Paper Nr: 83
Title:

Toward Evolution Models for Data Warehouses

Authors:

Saïd Taktak, Jamel Feki and Gilles Zurfluh

Abstract: A Data warehouse (DW) is characterized by a complex architecture, designed in order to integrate data derived from operational data sources (DS), hence providing advanced analytical tools of these data. The DW is highly dependent on its DS. Hence, evolutions of the DS schema need to be propagated to the DW schema and content. This paper presents a model-driven approach for the evolution of a multidimensional DW. It is based on two evolution models: a first evolution model for the DS and another for the DW. These two models concern the data structure aspects as well as the evolution operations. The transition between these two models is performed through specific transformation rules defined in QVT (Query\View\Transformation).

Paper Nr: 89
Title:

Domain-specific Languages as Tools for Teaching 3D Graphics

Authors:

Kęsik Jacek, Nowakowski Kamil and Żyła Kamil

Abstract: Model-driven engineering is constantly gaining importance, expanding to domains varying from the Web to the 3D graphics. Domain-specific languages besides contributing to the development process can be used in a didactic process conducted not only in schools. Thus this paper introduces new domain-specific language and discusses its usage in teaching construction of shaders and materials while working with 3D graphics. It presents the authors stance regarding the usefulness of domain-specific languages in education of 3D graphics development.