Powered by
Conference Publishing Consulting

2012 4th International Workshop on Modeling in Software Engineering (MiSE), June 2–3, 2012, Zurich, Switzerland

MiSE 2012 – Proceedings

Contents - Abstracts - Authors

4th International Workshop on Modeling in Software Engineering (MiSE)

Preface

Title Page

Foreword
The purpose of this 2-day workshop is to promote the use of models in the engineering of software systems. In particular, we are interested in the exchange of innovative technical ideas and experiences related to modeling. Engineers have used models to effectively manage complexity for centuries, and there is a growing body of work on the use of models to manage inherent problem and solution complexity in software development. The use of software models will become more prevalent as methodologies and tools that manipulate models at various levels of abstraction become available.

Model Analysis

A Rigorous Approach to Availability Modeling
Maximilian Junker and Philipp Neubeck
(TU Munich, Germany)
Modeling and analyzing the dependability of software systems is a key activity in the development of embedded systems. An important factor of dependability is availability. Current modeling methods that support availability modeling are not based on a rigorous modeling theory. Therefore, when the behavior of the system influences the availability, as it is the case for fault-tolerant systems, the resulting analysis is imprecise or relies on external information. Based on a probabilistic extension of the FOCUS theory, we present a modeling technique that allows specifiying availability with a clear semantics. This semantics is a transformation of the original behavior to one that includes failures. Our approach enables modeling and verifying availability properties in the same way as system behavior.
Article Search
Extent and Characteristics of Dependencies between Vehicle Functions in Automotive Software Systems
Andreas Vogelsang, Stefan Teuchert, and Jean-Francois Girard
(TU Munich, Germany; MAN Truck and Bus, Germany)
Functional dependencies and feature interactions are a major source of erroneous and unwanted behavior in software-intensive systems. To overcome these problems, many approaches exist that focus on modeling these functional dependencies in advance, i.e., in the specification or the design of a system. However, there is little empirical data on the amount of such interactions between system functions in realistic systems. In this paper, we analyze structural models of a modern realistic automotive vehicle system with the aim to assess the extent and characteristics of interactions between system functions. Our results show that at least 69% of the analyzed system functions depend on each other or influence each other. These dependencies stretch all over the system whereby single system functions have dependencies to up to 40% of all system functions. These results challenge the current development methods and processes that treat system functions more or less as independent units of functionality.
Article Search
Verifiable Architectural Interface for Supporting Model-Driven Development with Adequate Abstraction Level
Naoyasu Ubayashi and Yasutaka Kamei
(Kyushu University, Japan)
It is not easy to design software architecture reflecting the intention of developers and implement the result of design as a program while preserving the architectural correctness and adequate abstraction level. Archface, an architectural interface mechanism, plays a role as an ADL at the design phase and as a programming interface at the implementation phase. Design and code can co-evolve with Archface at the center of the development process. This paper proposes a verifiable architectural interface that can check the traceability between design and code. For this checking, we use an SMT (Satisfiability Modulo Theories) solver, a tool for deciding the satisfiability of logical formulas. Adopting our approach, we can construct MDD tools supporting adequate abstraction level when they generate code, recover a design model from code, and check the traceability between a design model and its code.
Article Search

Domain-Specific Languages

Creating Visual Domain-Specific Modeling Languages from End-User Demonstration
Hyun Cho, Jeff Gray, and Eugene Syriani
(University of Alabama, USA)
Domain-Specific Modeling Languages (DSMLs) have received recent interest due to their conciseness and rich expressiveness for modeling a specific domain. However, DSML adoption has several challenges because development of a new DSML requires both domain knowledge and language development expertise (e.g., defining abstract/concrete syntax and specifying semantics). Abstract syntax is generally defined in the form of a metamodel, with semantics associated to the metamodel. Thus, designing a metamodel is a core DSML development activity. Furthermore, DSMLs are often developed incrementally by iterating across complex language development tasks. An iterative and incremental approach is often preferred because the approach encourages end-user involvement to assist with verifying the DSML correctness and feedback on new requirements. However, if there is no tool support, iterative and incremental DSML development can be mundane and error-prone work. To resolve issues related to DSML development, we introduce a new approach to create DSMLs from a set of domain model examples provided by an end-user. The approach focuses on (1) the identification of concrete syntax, (2) inducing abstract syntax in the form of a metamodel, and (3) inferring static semantics from a set of domain model examples. In order to generate a DSML from user-supplied examples, our approach uses graph theory and metamodel design patterns.
Article Search
Community-Driven Language Development
Javier Luis Cánovas Izquierdo and Jordi Cabot
(École des Mines de Nantes, France; INRIA, France; LINA, France)
Software development processes are becoming more collaborative, trying to integrate end-users as much as possible. The idea is to advance towards a community-driven process where all actors (both technical and non- technical) work together to ensure that the system-to-be will satisfy all expectations. This seems specially appropriate in the field of Domain-Specific Languages (DSLs) typically designed to facilitate the development of software for a particular domain. DSLs offer constructs closer to the vocabulary of the domain which simplifies the adoption of the DSL by end-users. Interestingly enough, the development of DSLs is not a collaborative process itself. In this sense, the goal of this paper is to propose a collaborative infrastructure for the development of DSLs where end-users have a direct and active participation in the evolution of the language. This infrastructure is based on Collaboro, a DSL to represent change proposals, possible solutions and comments arisen during the development and evolution of a language.
Article Search

Poster Session

Avestan: A Declarative Modeling Language Based on SMT-LIB
Amirhossein Vakili and Nancy A. Day
(University of Waterloo, Canada)
Avestan is a declarative modelling language compatible with SMT-LIB. SMT-LIB is an standard input language that is supported by the state-of-the-art satisfiability modulo theory solvers (SMT solvers). The recent advances in SMT solvers have introduced them as efficient analysis tools; as a result, they are becoming more popular in the verification and certification of digital products. SMT-LIB was designed to be machine readable rather than human readable. In this paper, we present Avestan, a declarative modelling language that is intended to be analyzed by SMT solvers and readable by humans. An Avestan model is translated to an SMT-LIB model so that it can be analyzed by different SMT solvers. Avestan has relational constructs that are heavily inspired by Alloy; we added these constructs to increase the readability of an Avestan model.
Article Search
Modeling Social Media Collaborative Work
Bazil Stanley Solomon, David Duce, Rachel Harrison, and Kenneth Boness
(Oxford Brookes University, UK; University of Reading, UK)
This paper proposes an approach for modeling Social Media Collaborative Work (SMCW). We consider Social Media Collaborative Work to consist of multi-stakeholder viewpoints and human activity linked together by social media. SMCW has great potential within complex multifaceted domains such as healthcare. In this paper we describe how to model SMCW in a way which shows the multi-stakeholder intentions, concerns and priorities. We are conducting empirical studies to develop our approach for modeling SMCW. In particular we are using action research with a self-help community to develop and validate our SMCW modeling approach. In our approach we make use of the soft systems methodology in combination with i* modeling and social psychology.
Article Search
MODACLOUDS: A Model-Driven Approach for the Design and Execution of Applications on Multiple Clouds
Danilo Ardagna, Elisabetta Di Nitto, Giuliano Casale, Dana Petcu, Parastoo Mohagheghi, Sébastien Mosser, Peter Matthews, Anke Gericke, Cyril Ballagny, Francesco D'Andria, Cosmin-Septimiu Nechifor, and Craig Sheridan
(Politecnico di Milano, Italy; Imperial College London, UK; Institute e-Austria Timisoara, Romania; SINTEF, Norway; CA, Spain; BOC, Austria; SOFTEAM, France; ATOS, Spain; SIEMENS, Romania; Flexiant, UK)
Cloud computing is emerging as a major trend in the ICT industry. While most of the attention of the research community is focused on considering the perspective of the Cloud providers, offering mechanisms to support scaling of resources and interoperability and federation between Clouds, the perspective of developers and operators willing to choose the Cloud without being strictly bound to a specific solution is mostly neglected. We argue that Model-Driven Development can be helpful in this context as it would allow developers to design software systems in a cloud-agnostic way and to be supported by model transformation techniques into the process of instantiating the system into specific, possibly, multiple Clouds. The MODACLOUDS (MOdel-Driven Approach for the design and execution of applications on multiple Clouds) approach we present here is based on these principles and aims at supporting system developers and operators in exploiting multiple Clouds for the same system and in migrating (part of) their systems from Cloud to Cloud as needed. MODACLOUDS offers a quality-driven design, development and operation method and features a Decision Support System to enable risk analysis for the selection of Cloud providers and for the evaluation of the Cloud adoption impact on internal business processes. Furthermore, MODACLOUDS offers a run-time environment for observing the system under execution and for enabling a feedback loop with the design environment. This allows system developers to react to performance fluctuations and to re-deploy applications on different Clouds on the long term.
Article Search

Model Transformations

A Feature Model for Model-to-Text Transformation Languages
Louis M. Rose, Nicholas Matragkas, Dimitrios S. Kolovos, and Richard F. Paige
(University of York, UK)
Model-to-text (M2T) transformation is an important model management operation, as it is used to implement code and documentation generation; model serialisation (enabling model interchange); and model visualisation and exploration. Despite the creation of the MOF Model-To-Text Transformation Language (MOFM2T) in 2008, many very different M2T languages exist today. Because there is little interoperability between M2T languages and rewriting an existing M2T transformation in a new language is costly, developers face a difficult choice when selecting a M2T language. In this paper, we use domain analysis to identify a preliminary feature model for M2T languages. We demonstrate the appropriateness of the feature model by describing two different M2T languages, and discuss potential applications for a tool-supported and model-driven approach to describing the features of M2T languages.
Article Search
The Semantics of Partial Model Transformations
Michalis Famelis, Rick Salay, and Marsha Chechik
(University of Toronto, Canada)
Model transformations are traditionally designed to operate on models that do not contain uncertainty. In previous work, we have developed partial models, i.e., models that explicitly capture uncertainty. In this paper, we study the transformation of partial models. We define the notion of correct lifting of transformations so that they can be applied to partial models. For this, we encode transformations as em transfer predicates and describe the mechanics of applying transformations using logic. We demonstrate the approach using two example transformations (addition and deletion) and outline a method for testing the application of transformations using a SAT solver. Reflecting on these preliminary attempts, we discuss the main limitations and challenges and outline future steps for our research on partial model transformation.
Article Search
A Categorical Model of Model Merging and Weaving
Jonathan Y. Marchand, Benoit Combemale, and Benoit Baudry
(ENS Cachan, France; University of Rennes 1, France; IRISA, France; INRIA, France)
Model driven engineering advocates the separa- tion of concerns during the design time of a system, which leads to the creation of several different models, using several different syntaxes. However, to reason on the overall system, we need to compose these models. Unfortunately, composition of models is done in an ad hoc way, preventing comparison, capitalisation and reuse of the composition operators. In order to improve comprehension and allow comparison of merging and weaving operators, we use category theory to propose a unified framework to formally define merging and weaving of models. We successfully use this framework to compare them, both through the way they are transformed in the formalism, and through several properties, such as completeness or non- redundancy. Finally, we validate this framework by checking that it correctly identifies three tools as performing merging or weaving of models.
Article Search

Model Evolution, Adaptability, and Maintainability

Using UniMod for Maintenance Tasks: An Experimental Assessment in the Context of Model Driven Development
Filippo Ricca, Maurizio Leotta, Gianna Reggio, Alessandro Tiso, Giovanna Guerrini, and Marco Torchiano
(University of Genova, Italy; Politecnico di Torino, Italy)
One of the claimed advantages of Model-driven development is the improvement in maintainability. However, few studies consider this aspect from an empirical point of view. This paper reports the results of a controlled experiment with 21 bachelor students aimed at investigating the effectiveness of Model-driven development during software maintenance and evolution activities. The tool used in the experiment is UniMod, a specific implementation of executable UML. Preliminary results indicate a relevant shortening of time with no significant impact on correctness, gained through the use of UniMod instead of conventional programming (i.e., codecentric programming).
Article Search
A Feature-Based Approach to System Deployment and Adaptation
Sabine Moisan, Jean-Paul Rigault, and Mathieu Acher
(INRIA Sophia Antipolis Méditerranée, France; University of Namur, Belgium)
Building large scale systems involves many design decisions, both at specification and implementation levels. This is due to numerous variants in the description of the task to achieve and its execution context as well as in the assembly of software components. We have modeled variability for large scale systems using feature diagrams, a formalism well suited for modeling variablility. These models are built with a clear separation of concerns between specification and implementation aspects. They are used at design and deployment time as well as at execution time. Our test application domain is video surveillance systems, from a software engineering perspective. These are good candidates to put model driven engineering to the test, because of the huge variability in both the surveillance tasks and the video analysis algorithms. They are also dynamically adaptive systems, thus suitable for models at run time approaches. We propose techniques and tools to define the models, to operate on them, and to transform specification requirements into an effective implementation of a processing chain. We also define a run time architecture to integrate models into the adaptation loop.
Article Search
Business Process and Software Architecture Model Co-evolution Patterns
Pooyan Jamshidi and Claus Pahl
(Lero, Ireland; Dublin City University, Ireland)
Software systems are subject to change. To embrace change, the systems should be equipped with automated mechanisms. Business process and software architecture models are two artifacts that are subject to change in an interrelated manner that requires them co-evolve. As opposed to the traditional batch-based model transformation, we propose a comprehensive set of structural and behavioral evolution patterns that enable to incrementally reflect the impact of change of business processes to their associated architecture models by applying reusable patterns. A basis for automation is provided through a graph-based formalism.
Article Search

proc time: 0.13