MODELSWARD 2013 Abstracts

Area 1 - Applications and Software Development
Full Papers Short Papers
Area 2 - Methodologies, Processes and Platforms
Full Papers Short Papers
Area 3 - Modeling Languages, Tools and Architectures
Full Papers Short Papers

Area 1 - Applications and Software Development

Full Papers
Paper Nr: 12
Title:

A Survey of Model Comparison Approaches and Applications
Authors:

Matthew Stephan and James R. Cordy
Abstract: This survey paper presents the current state of model comparison as it applies to Model-Driven Engineering. We look specifically at how model matching is accomplished, the application of the approaches, and the types of models that approaches are intended to work with. Our paper also indicates future trends and directions. We find that many of the latest model comparison techniques are geared towards facilitating arbitrary meta models and use similarity-based matching. Thus far, model versioning is the most prevalent application of model comparison. Recently, however, work on comparison for versioning has begun to stagnate, giving way to other applications. Lastly, there is wide variance among the tools in the amount of user effort required to perform model comparison, as some require more effort to facilitate more generality and expressive power.
Download
Short Papers
Paper Nr: 16
Title:

Translating Platform-independent Code into Natural Language Texts
Authors:

Håkan Burden and Rogardt Heldal
Abstract: Understanding software artifacts is not only time-consuming, without the proper training and experience it can be impossible. From a model-driven perspective there are two benefits from translating platform-independent models into natural language texts: First, the non-functional properties of the solution have already been omitted meaning that the translations focus on describing the functional behaviour of the system. Second, the platform-independent models are reusable across platforms and so are the translations generated from them. As a proof-of-concept a platform-independent Action language is translated into natural language texts through the framework of model transformations.
Download
Paper Nr: 40
Title:

UML Class Diagram Simplification - A Survey for Improving Reverse Engineered Class Diagram Comprehension
Authors:

Hafeez Osman, Arjan van Zadelhoff and Michel R. V. Chaudron
Abstract: Class diagrams may include an overwhelming amount of information. For a large and complex class diagrams there is a possibility that not all information in the class diagram is important for understanding the system. In this paper, we study how to identify essential and secondary information in class diagrams. To this end, we performed a survey with professionals, academics and students to enquire information in class diagrams that is considered important. In total, 25 complete responses were received with 76% of the respondents having average or above skills with class diagrams. As the results, we discovered that the metric that counts the number of public operations is the most important metric for indicating importance of a class in a diagram. Also, we discovered that class names and coupling were influencing factors when it comes to excluding classes from a class diagram.
Download
Paper Nr: 63
Title:

Why Do We Not Learn from Defects? - Towards Defect-Driven Software Process Improvement
Authors:

Niklas Mellegård, Miroslaw Staron and Fredrik Törner
Abstract: In this paper, we put forth the thesis that state-of-the-art defect classification schemes – such as ODC and IEEE Std. 1044 – have failed to meet their target; limited industrial adoption is taken as part of the evidence combined with published studies on model driven software development. Notwithstanding, a number of publications show that defect reports can provide valuable information about common, important, or dangerous problems with software products. In this paper, we present the synthesis of two industrial case studies that illustrate that even expert judgement can be deceptive; demonstrating the need for more objective evidence to allow project stakeholder to make informed decisions, and that defect classification is one effective means to that end. Finally, we propose a roadmap that will contribute to improving the defect classification approach, which in consequence will lead to a wider industrial adoption.
Download
Paper Nr: 18
Title:

Application of Model Comparison Techniques to Model Transformation Testing
Authors:

Matthew Stephan and James R. Cordy
Abstract: In this paper, we discuss model-to-model comparison techniques that can be used to assist with model-tomodel transformation testing. Using an existing real-world model transformation, we illustrate and qualitatively evaluate the comparison techniques, highlighting the associated strengths and weaknesses of each in the context of transformation testing.
Download
Paper Nr: 68
Title:

A Model-based Software Technology Proposal
Authors:

Vahur Kotkas, Jaan Penjam, Ahto Kalja and Enn Tyugu
Abstract: In this paper we propose a technology for model-based software development. The technology separates domain engineering and application engineering and automates the actual executable code generation. This approach has been used extensively for simulations and we believe it is also applicable for more general software development.
Download

Area 2 - Methodologies, Processes and Platforms

Full Papers
Paper Nr: 23
Title:

Challenges of Model-driven Modernization - An Agile Perspective
Authors:

Stavros Stavru, Iva Krasteva and Sylvia Ilieva
Abstract: Software organizations are nowadays facing increased demand for modernizing their legacy software systems using up-to-date technologies. The combination of Model-Driven Development and delivery models like Cloud and Software as a Service have become a very promising approach for software modernization that possesses a lot of advantages, including great deal of automation and reuse of system functionality. However, the use of such new and immature technologies is very challenging and requires a comprehensive methodology for their seamless application within the software modernization projects. When developing such methodology, questions on whether agile methods and techniques should be incorporated and what could be the benefits and implications from that become of particular interest. To help answering these questions, the paper evaluates the potential of agile methods and techniques to address the challenges of Model-Driven Modernization. The challenges are extracted through a systematic review of the existing body of literature on Model-Driven Development and Software Modernization, and the evaluation is conducted through the Delphi technique. As a result, a ranked list of applicable agile techniques is proposed and suggestions for their use in Model-Driven Modernization are made.
Download
Short Papers
Paper Nr: 31
Title:

Performability Modeling of Manual Resolution of Data Inconsistencies for Optimization of Data Synchronization Interval
Authors:

Kumiko Tadano, Jiangwen Xiang, Fumio Machida and Yoshiharu Maeno
Abstract: For disaster recovery, many database systems with valuable data have been designed with database synchronization between main and backup sites. The data synchronization interval affects the performability of system which is a combined measure of performance and availability. It is important to determine the optimal synchronization interval in terms of performability so as to satisfy customers' requirements. However, existing techniques to identify the optimal synchronization interval do not consider the performability impacts of time-consuming manual resolution task for inconsistent data. To address this issue, this paper proposes a method to identify the data synchronization interval which optimizes performability by solving a stochastic reward net model describing the manual and automatic failure-recovery behavior of a database system. Several numerical examples are given to demonstrate the proposed method and its potential practical applicability.
Download
Paper Nr: 53
Title:

A MDE Framework for Semi-automatic Development of Web Applications
Authors:

Javier Solis, Hasdai Pacheco, Karen Najera and Hugo Estrada
Abstract: One of the current trends in computer science is the use of ontologies in Software Engineering. In this context, several academic and industrial works have used ontologies as mechanism for system requirements representation and automatic code generation. However, most of current works propose generic development platforms regardless the reuse of components for a specific domain. In this paper, a Model-Driven Development Framework, called SemanticWebBuilder (SWB) is presented. SWB provides an agile development platform for the Web application domain, where system requirements are modeled through ontologies and from this knowledge representation, the infrastructure of the system is automatically generated. The resultant system can be extended by reusing of code, thus allowing to build complex systems in a short time. Moreover, system data is represented as RDF triples, making this data available in the Semantic Web. SWB has been widely used to develop Web applications for several government dependencies in Mexico.
Download
Paper Nr: 13
Title:

Model-driven Development of Interactive Web User Interfaces with HTML5
Authors:

Michael Huber and Philipp Brune
Abstract: Graphical user interfaces (GUI) of modern web applications offer a look-and-feel comparable to desktop applications, mainly by using JavaScript or other Rich internet Applications (RIA) technologies. With W3C's upcoming HTML5 standard, even more powerful concepts for browser-side GUI programming are introduced, e.g. the $<$canvas$>$-tag. Model-driven development of web applications and RIA has been studied for many years. However, all existing approaches for model-driven web and RIA development focus on entire web-pages. With the increasing complexity of modern web GUIs, the model-driven development of GUI components itself comes into focus. Therefore, in this paper a method is proposed for the model-driven development of interactive, JavaScript-based GUI components based on the $<$canvas$>$-tag. Using a metamodel based on an UML 2.0 profile, the approach is usable together with existing UML-based methods or standalone. The implementation is described and its feasibility and implications are examined by means of a proof-of-concept example.
Download
Paper Nr: 14
Title:

MDE for Enterprise Application Systems
Authors:

Alfonso Diez, Nga Nguyen, Fernando Díez and Enrique Chavarriaga
Abstract: Model Driven Engineering (MDE) has been widely researched as a solution for the complexity of software development over last decades. However, it is not widely adopted efficiently in industry. In this paper, we identify two main challenges prevent MDE from industrial adoption: the first one is capturing dynamic behaviours from real problems in human organization into formal models; the second one is the lack of an integrated development environment (IDE) which can have a fast and reliable model execution. In order to address these two challenges, we have worked during the last ten years in the area of Enterprise Application Systems based on Business Models formalisms. We have combined different technologies from the MDE context such as multilevel meta-modelling, domain specific model languages (DSML), state machines and model interpreters. The result is that we have created a large set of commercial products based on a common model based platform, which we are currently applying in many business areas. This paper describes the most representative concepts and contributions of our work to the development of MDE.
Download
Paper Nr: 37
Title:

A General Framework for the Development of MDD Projects
Authors:

Beatriz Marín, Javier Pereira, Giovanni Giachetti, Felipe Hermosilla and Estefanía Serral
Abstract: The main characteristic of the Model-Driven Development paradigm is that it allows the automatic (or semiautomatic) generation of software systems from the conceptual models that specify these systems. The successful application of MDD relies in the selection of appropriate diagrams and tools. However, software engineers do not have frameworks that help them to select the MDD tools that better fit to specific projects needs. To face this issue, in this paper we have analysed a set of models and tools that can be used to support MDD projects. From this analysis, a general framework is presented.
Download

Area 3 - Modeling Languages, Tools and Architectures

Full Papers
Paper Nr: 41
Title:

A Meta-model for Tests of Avionics Embedded Systems
Authors:

Alexandru-Robert Guduvan, Hélène Waeselynck, Virginie Wiels, Guy Durrieu, Yann Fusero and Michel Schieber
Abstract: Tests for avionics embedded systems are implemented using proprietary test languages. No standard has emerged and the set of existing test languages is heterogeneous. This is challenging for test solution providers, who have to accommodate the different habits of their clients. In addition, test exchange between aircraft manufacturers and equipment/system providers is hindered. To address these problems, we propose a model-driven approach for test implementation: test models are developed/maintained, with model-to-code transformations towards target executable test languages. This paper presents the test meta-model underlying the approach. It integrates the domain-specific concepts identified from an analysis of a sample of proprietary test languages. The test meta-model is the basis for building test model editors and template-based automatic code generators, as illustrated by a demonstrator we developed.
Download
Paper Nr: 42
Title:

Consistency of UML Class and Statechart Diagrams with State Invariants
Authors:

Ali Hanzala Khan, Irum Rauf and Ivan Porres
Abstract: We present an approach and a tool to analyze the consistency of UML class and statechart diagrams containing state invariants automatically. UML class diagrams describe the structure of a system as a collection of classes while UML statechart diagrams describe its behavior. State invariants relate the active state configuration of a statechart with object instances described in a class diagram. We consider a UML statechart inconsistent if it contains unsatisfiable state invariants, that is, there are no object instances that can make a given invariant evaluate to true. To detect such inconsistencies, we translate a UML model containing class and statechart diagrams into the Web Ontology Language (OWL 2), and then use OWL 2 reasoning tools to infer the consistency and satisfiability of the translated diagrams. The approach is supported by an automatic translation tool and existing OWL 2 reasoners. We demonstrate our approach with an example design and evaluate its performance using large UML models.
Download
Paper Nr: 45
Title:

Synthesizing Decentralized Components from a Variant of Live Sequence Charts
Authors:

Dirk Fahland and Amir Kantor
Abstract: Live sequence charts (LSC) is a visual, executable, language for the modeling of reactive systems. Each chart depicts an inter-object scenario arising in the modeled system, partitioned into two: a monitored prechart, and a main chart. Despite the intuitive use of the language, complications arise when one wants to implement an LSC specification with decentralized components. In this paper, we introduce a variant of LSC, called distributed LSC (dLSC), which is targeted for the modeling and synthesis of decentralized systems, composed of several interacting components. While LSCs are commonly interpreted in terms of an interleaved execution of the scenarios in a sequential run, dLSCs employ partially ordered runs. We investigate the expressive power of dLSC compared to an established model of concurrent systems, namely, Petri nets, and show that dLSCs are, computationally, strictly more expressive than low-level Petri nets and subsumed by higher-level Petri nets. Specifically, we present an algorithm that synthesizes, given a dLSC specification, an equivalent token history net, which can serve as an executable implementation of the specification. Most importantly, the implementation is decentralized --- components can be automatically extracted from the net. The synthesis of Petri-net components from a dLSC specification is supported by a tool.
Download
Paper Nr: 49
Title:

Making Sense to Modelers - Presenting UML Class Model Differences in Prose
Authors:

Harald Störrle
Abstract: Understanding the difference between two models, such as different versions of a design, can be difficult. It is a commonly held belief in the model differencing community that the best way of presenting a model difference is by using graph or tree-based visualizations. We disagree and present an alternative approach where sets of low-level model differences are abstracted into high-level model differences that lend themselves to being presented textually. This format is informed by an explorative survey to elicit the change descriptions modelers use themselves. Our approach is validated by a controlled experiment that tests three alternatives to presenting model differences. Our findings support our claim that the approach presented here is superior to EMF Compare.
Download
Paper Nr: 51
Title:

Higher-order Rewriting of Model-to-Text Templates for Integrating Domain-specific Modeling Languages
Authors:

Bernhard Hoisl, Stefan Sobernig and Mark Strembeck
Abstract: Domain-specific modeling languages (DSMLs) are commonly used in model-driven development projects. In this context, model-to-text (M2T) transformation templates generate source code from DSML models. When integrating two (or more) DSMLs, the reuse of such templates for the composed DSML would yield a number of benefits, such as, a reduced testing and maintenance effort. However, in order to reuse the original templates for an integrated DSML, potential syntactical mismatches between the templates and the integrated metamodel must be solved. This paper proposes a technology-independent approach to template rewriting based on higher-order model transformations to address such mismatches in an automated manner. By considering M2T generator templates as first-class models and by reusing transformation traces, our approach enables syntactical template rewriting. To demonstrate the feasibility of this rewriting technique, we built a prototype for Eclipse EMF and Epsilon.
Download
Paper Nr: 52
Title:

Incorporating Proofs in a Categorical Attributed Graph Transformation System for Software Modelling and Verification
Authors:

Bertrand Boisvert, Louis Féraud and Sergei Soloviev
Abstract: This paper deals with model transformations based on attributed graphs transformation. Our approach is based on the categorical approach called Single Pushout. The principal goal being to strengthen the attribute computation part, we generalize our earlier approach based on the use of typed lambda-terms with inductive types and recursion to represent attributes and computation functions. The generalized approach takes terms in variable context as attributes and partial proofs as computation functions that permit to combine computation with proof development and verification. The intended domains of application are the development of cerified software models and semantics models for interactive proof development and verification.
Download
Short Papers
Paper Nr: 2
Title:

Optimising Model-transformations using Design Patterns
Authors:

Kevin Lano and Shekoufeh Kolahdouz-Rahimi
Abstract: This paper identifies how metrics of model transformation complexity can be used to guide the choice and application of design patterns to improve the quality and efficiency of model transformation specifications. Heuristics for choosing design patterns based on the metrics are defined, and the process is applied to an example transformation.
Download
Paper Nr: 4
Title:

A Code Merger to Support Reverse Engineering Towards Model-driven Software Development
Authors:

Oliver Haase, Nikolaus Moll and Paul Zerr
Abstract: Model-driven engineering is a promising approach whose feasibility for commercial development is currently being validated. While most approaches discuss forward-engineering steps, only little research has been done on model-driven software migration. More precisely, it is unclear how to transform — or reverse engineer — existing code into generated and hand-crafted artifacts. We present an iterative approach to this problem. Assuming some evolving high-level representations of a software legacy system, code generators may produce a second version of the system to an extend where hand-crafted code is still necessary for completion. In this report we present a code merger that completes the generated code by reusing the implementation of the software legacy system.
Download
Paper Nr: 8
Title:

UML-based Design and Verification Method for Developing Dependable Context-aware Systems
Authors:

Naoyasu Ubayashi and Yasutaka Kamei
Abstract: This paper proposes a verification mechanism for designing dependable context-aware systems. In our approach, a UML-based design model and actual execution trace data are translated into a logical formula. The validity of a design model, the correspondence between the design and the execution, and the non-functional properties can be verified automatically. For this checking, we use an SMT solver.
Download
Paper Nr: 9
Title:

Modelling and Enterprises - The Past, the Present and the Future
Authors:

Vinay Kulkarni, Suman Roychoudhury, Sagar Sunkle, Tony Clark and Balbir Barn
Abstract: Industry has been practicing model-driven development in various flavours. In general it can be said that modelling and use of models have delivered on the promises of platform independence, enhanced productivity, and delivery certainty as regards development of software-intensive systems. Globalization market forces, increased regulatory compliance, ever-increasing penetration of internet, and rapid advance of technology are some of the key drivers leading to increased business dynamics. Increased number of factors impacting the decision and interdependency amongst the key drivers is leading to increased complexity in making business decisions. Also, enterprise software systems need to commensurately change to quickly support the business decisions. The paper presents synthesis of our experience over a decade and half in developing model-driven development technology and using it to deliver several business-critical software systems worldwide.
Download
Paper Nr: 10
Title:

Tool Support for the Evaluation of Matching Algorithms in the Eclipse Modeling Framework
Authors:

Sabrina Uhrig and Felix Schwägerl
Abstract: In the field of model-driven development, sophisticated support for comparing model versions is urgently needed. Unfortunately, algorithms for model matching have been rarely evaluated so far. This paper deals with two extensions to the Eclipse Modeling Framework (EMF) that facilitate the evaluation of matching algorithms for EMF models, with the goal to combine user involvement and automated testing in the evaluation process. First a tree editor is presented that allows for the manual and semi-automated creation of match models which formalize the intended matching result. Second a benchmarking procedure is implemented which – given the intended match and the actual results of matching algorithms – automatically derives the number of a and b errors in a target-performance comparison. These results are valuable for drawing conclusions about the specific qualities of matching algorithms or for finding an adequate set of parameters for a configurable algorithm.
Download
Paper Nr: 11
Title:

Towards a Meta-model of the Cloud Computing Resource Landscape
Authors:

Kleopatra Chatziprimou, Kevin Lano and Steffen Zschaler
Abstract: As Cloud Computing becomes more predominant, large scale datacenters are subject to an increasing demand for efficiency and flexibility. However, growing infrastructure management complexity and maintenance costs are becoming a hindrance to the advancement of the Cloud vision. In this paper we discuss how existing datacenter resource management approaches fail to provide infrastructure elasticity and suggest a resources provisioning architecture to fill this gap. As a first step towards implementing our targets, we present a metamodel to describe the characteristics of the Cloud landscape, emphasising on a provider’s perspective. With this meta-model we intend to introduce new modelling concepts towards facilitating the selection of optimal reconfigurations in a timely fashion.
Download
Paper Nr: 21
Title:

TStore: A Trace-Base Management System - Using Finite-state Transducer Approach for Trace Transformation
Authors:

Raafat Zarka, Pierre-Antoine Champin, Amélie Cordier, Elöd Egyed-Zsigmond, Luc Lamontagne and Alain Mille
Abstract: This paper presents TStore, a Trace-Base Management System (TBMS) handling storage, transformation and exploitation of traces collected by external applications. As the experiments reported in this paper demonstrate, TStore brings a solution to performances and storage issues usually encountered by TBMS. To exploit traces, transformations are used. TStore provides predefined transformation functions as well as a customized transformation based on Finite State Transducers (FST), which are also presented in this paper.
Download
Paper Nr: 24
Title:

Verification and Validation of Meta-model based Transformation from SysML to VHDL-AMS
Authors:

Jean-Marie Gauthier, Fabrice Bouquet, Ahmed Hammad and Fabien Peureux
Abstract: This paper proposes an approach to verify SysML models consistency and to validate the transformation of SysML models to VHDL-AMS code. This approach is based on two main solutions: the use of model-to-model transformation to verify SysML models consistency and writing unit tests to validate model transformations. The translation of SysML models into VHDL-AMS simulable code uses MMT (Model to Model Transformation) ATL Atlas Transformation Language and M2T (Model To Text) Acceleo tooling. The test validation of the model transformations is performed using EUNIT framework.
Download
Paper Nr: 26
Title:

Visualizing OCL Constraint Patterns with VOCL
Authors:

Ali Hamie
Abstract: A specification pattern is a generic constraint expression that can be instantiated to solve a class of specification problems. It captures and generalizes frequently used logical expressions in models. Specification patterns have been defined and represented in the Object Constraint Language OCL for UML/OCL modelling. The notation of visual OCL (VOCL) is a visualization of OCL and can be considered as an alternative solution to the textual OCL. This paper provides the visualization of some OCL constraint patterns in VOCL. For this purpose, we introduce constraint pattern templates in VOCL to represent constraint patterns in a diagrammatic form. The benefits of the visualization is that some patterns will be available in a intuitive diagrammatic notation that follows the UML notation.
Download
Paper Nr: 48
Title:

Engineering Model Recommender Foundations - From Class Completion to Model Recommendations
Authors:

Andreas Ganser and Horst Lichter
Abstract: Reuse has been widely carried out successfully, but not with models in Model Driven Engineering. Reasons seem manifold and conceptual issues and poor tool support are among them. A closer look at the tools available shows that models are often held in repositories which merely exceed versioning and indexing support. But model reuse requires mature approaches and tool support to become successful. We created a solid conceptual foundation and found recommendations as one solution, which in turn need appropriate data. We engineer these data subsequently and explain our design rationales. In a nutshell, we create a knowledge library comprising of elements which are connected on generic, semantic, and syntactic level. This knowledge library forms an enhanced knowledge graph enabling chain recommendations.
Download
Paper Nr: 50
Title:

Systematic Development of Control Designs via Formal Refinement
Authors:

Manoranjan Satpathy, Colin Snook, Silky Arora, S. Ramesh and Michael Butler
Abstract: The Simulink/Stateflow (SL/SF) modeling framework is widely used in industry for the development of control applications. However, such models are not amenable to formal reasoning. Controllers can also be designed using formal specification languages. Such designs can be formally verified, but the models do not explicitly represent control or data flow information. In this paper, we discuss RRM diagrams (RRMDs), a new modelling notation which incorporates the benefits of these two formalisms. RRMDs are graphical formal models and they also support incremental formal development. We have used synchronising state machines to encode RRMDs. We have also developed a prototype tool which translates RRMDs automatically to SL/SF designs.
Download
Paper Nr: 54
Title:

Composition of Domain Specific Modeling Languages - An Exploratory Study
Authors:

Edmilson Campos, Marília Freire, Uirá Kulesza, Adorilson Bezerra and Eduardo Aranha
Abstract: This paper presents an exploratory study in the context of composition of domain-specific modeling languages (DSMLs). It aims evaluating a composition method using Ecore-based DSMLs based on xText tool. The study was performed applying the method to modelling a composition of DSMLs from the domain of controlled experiments in software engineering. The study consists of four different DSMLs, whose ultimate goal is to generate executable workflows for each experiment subject. The study results present: (i) new adaptations that can be incorporated into the method in order to enable its application to the xText context; and (ii) a brief comparison of the method application using xText and XML based approaches.
Download
Paper Nr: 61
Title:

Static Analysis and Testing of Executable DSL Specification
Authors:

Qinan Lai and Andy Carpenter
Abstract: In model-driven software engineering, the syntax of a modelling language is defined as a meta-model, and its semantics is defined by some other formal languages. As the languages for defining syntax and semantics comes from different technology space, maintaining the correctness and consistency of a language specification is a challenging topic. Technologies on formal methods or sophisticated dynamic verification have been developed to verify a language specification. While these works are valuable, they can be hard to apply to a complex language in reality. In this paper, extended static checking and testing are used to maintain the correctness of a language specification, and the techniques are applied to a case study that formalises WS-BPEL to a model-based specification defined by OMG standard fUML and ALF. Several categories of different errors are identified which can happen during semantics development, and how our framework can simplify the checking on them by static checking and direct testing of executable models is discussed.
Download
Paper Nr: 62
Title:

A PIM-to-Code Requirements Engineering Framework
Authors:

Gayane Sedrakyan and Monique Snoeck
Abstract: The complexity of Model-driven engineering (MDE) leads to a limited adoption in practice. In this paper we argue that MDE offers "low hanging fruit" if creating executable UML models allowing core functionali-ty prototyping is targeted rather than developing full-fledged information systems. This paper describes an environment for designing and validating conceptual business models using the model-driven architecture (MDA). The deliverable of the proposed modelling environment is an executable platform independent model (EPIM) that is further tested and validated through an MDA-based simulation feature. The proposed environment addresses a set of challenges associated with 1. shortcomings of the UML for being technically too complex for conceptual modelling goals as well as for being imprecise for rapid prototyping; 2. difficulties of MDE adoption due to the large set of required skills to adopt the key MDA standards such as the UML, MOF and XMI. The paper aims to introduce the current work and identify the needs for future research.
Download
Paper Nr: 65
Title:

Do we Really Need to Write Documentation for a System? - CASE Tool Add-ons: Generator+Editor for a Precise Documentation
Authors:

Maria Spichkova, Xiuna Zhu and Dongyue Mou
Abstract: One of the common problems of system development projects is that the system documentation is often outdated and does not describe the latest version of the system. The situation is even more complicated if we are speaking not about a natural language description of the system, but about its formal specification. In this paper we discuss how the problem could be solved by updating the documentation automatically, by generating a new formal specification from the model if the model is frequently changed.
Download
Paper Nr: 1
Title:

A Model-driven Process for Data Transformation of Heterogeneous Data
Authors:

Haïfa Nakouri and Nadia Essoussi
Abstract: In this paper, a model-driven approach to transform data format is provided. Original data is extracted from heterogeneous sources and is initially presented in a generic format called the public view format. Our approach includes a complete process of data transformation starting with data in public view format and ending with generating different kinds of formats (Excel, XML, HTML, etc.). There are three main stages in the proposed model-driven process: the input file injection which inserts the public view’s data in their corresponding model, the model-to-model transformation to bridge between the public view’s model and the output file’s model and finally the output file extraction to extract the output file from its corresponding model. Experimental results show that a model-driven approach for data transformation outperforms a code-centric approach in terms of execution time and automation rate.
Download
Paper Nr: 20
Title:

Arrangements of Finite-state Machines - Semantics, Simulation, and Model Checking
Authors:

Vladimir Estivill-Castro and Rene Hexel
Abstract: We propose a contrasting approach to the main stream direction that UML and {\tt STATEMATE} have recently taken when using finite-state machines (FSMs) to model behaviour. That is, rather than the event-driven model that is currently dominant, we suggest to adopt a model of time, a synchronous model. We do support concurrency in our arrangements of FSMs but eliminate the sources of unpredictable threads of execution. Currently, such capacity of the dominant semantics actually results in the need to create many language constructs to regulate threads that, in many cases, even result in imprecise semantics, hampering their use for model-driven development (MDD). By allowing transitions to only be labeled by statements of logic and by executing the machines with an offline schedule, we obtain a simpler language, with less burden for the developer. This creates far reaching potential for accompanying tools, such as integrated development environments, simulators, and even formal verification through model-checking. Model-checking is of particular importance as MDD becomes ubiquitous. Model-checking is possible for our FSMs as we do not need to consider all possible combinations of progress of each of the many threads that the event-driven alternative requires.
Download
Paper Nr: 28
Title:

A Systematic Comparison of Semantic Integration Data Storage Architectures for Multidisciplinary Systems
Authors:

Estefanía Serral, Olga Kovalenko, Thomas Moser and Stefan Biffl
Abstract: Multidisciplinary projects typically rely on the contributions of various disciplines using heterogeneous engineering tools. This paper focuses on the challenge of querying across different disciplines, which may be influenced by the selection of a proper instance data storage architecture for storing the heterogeneous tool data. Specifically, we have identified three different architectures: ontology file stores, triple stores and relational database stores. This paper systematically compares these architectures using an industrial case study and analyses their selection according to important requirements such as performance and maintainability.
Download
Paper Nr: 38
Title:

Combining SysML and Modelica to Verify the Wireless Sensor Networks Energy Consumption
Authors:

Ahmed Hammad, Hassan Mountassir and Samir Chouali
Abstract: Wireless Sensor Networks (WSN) have large industrial applications. However, the modelisation is still a very complex task in view of the nature of these networks, namely because they are distributed, embedded and have strong interactions between the hardware and software parts. In addition, industrials use semi-formal methods to design their systems and validate behaviours by simulation. In this context, in order to improve the checking of the WSN properties, we propose a Model Driven Architecture (MDA) approach for modeling and checking of properties like energy consumption. This approach combines the advantages of SysML and Modelica languages and promotes the reusability and improves the development process. It is described mainly by two steps. In first, we offer a model transformation by taking into account static, dynamic and requirement diagrams of SysML in order to specify their corresponding Modelica model. In the second step, we carried out the virtual verification of WSN properties. This approach is implemented inside Topcased platform and illustrated through a crossroads monitoring system which aims the verification of energy consumption.
Download
Paper Nr: 46
Title:

Modular and Distributed Verification of SysML Activity Diagrams
Authors:

Messaoud Rahim, Hammad Ahmed and Ioualalen Malika
Abstract: Model-based development for complex system design has been used to support the increase of systems complexity. SysML is a modeling language that allows a system description with various integrated diagrams, but SysML lacks formality for the requirement verification. Translating SysML-based specification into Petri nets allows to enable rigorous system analysis. However, for complex systems, we have to deal with the state space explosion problem. In this paper, we propose new approach to allow a modular and distributed verification of SysML Activity Diagram basing on the derived Petri net.
Download
Paper Nr: 59
Title:

Improving Modeling with Layered UML Diagrams
Authors:

Harald Störrle
Abstract: Layered diagrams are diagrams whose elements are organized into sets of layers. Layered diagrams are routinely used in many branches of engineering, except Software Engineering. In this paper, we propose to add layered diagrams to UML modeling tools, and elaborate the concept by exploring usage scenarios. We validate the concept by implementation, lab assessments, and field testing. We conclude that layers enhance and complement conventional diagrams and model structuring techniques, are easy to add to existing modeling infrastructure, and are easy to apply by modelers.
Download
Paper Nr: 64
Title:

Model-based System Engineering for Fault Tree Generation and Analysis
Authors:

Nataliya Yakymets, Hadi Jaber and Agnes Lanusse
Abstract: In this paper, we focus on the integration of formal approaches for automatic FT generation within a MBSE workflow. We describe a safety modelling framework for FT generation that leverages features of SysML modelling language and includes facilities to make semantic connections with formal verification and FTA tools. MBSE methods and tools (meta-models, profiles, model transformation) are fully exploited to propose a seamless workflow customizable for safety engineers. We illustrate the FT generation and analysis flow associated with the proposed framework using the example of the train detection system and the AltaRica formal environment.
Download