ICSE 2013 - May 18-26, 2013, San Francisco, CA, USA
Powered by
Conference Publishing Consulting

2013 5th International Workshop on Modeling in Software Engineering (MiSE), May 18-19, 2013, San Francisco, CA, USA

MiSE 2013 – Proceedings

Contents - Abstracts - Authors

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


Title Page

We welcome you to the 5th Workshop on Models in Software Engineering—MiSE’013! The purpose of this workshop is to study and advance the effective use of models in the engineering of software systems. In particular, we are interested in the exchange of experiences, challenges and promising technologies related to modeling. The goals of the software modeling community are to improve the productivity of software developers and to improve the quality of the resulting software products. Models are useful in all phases and activities surrounding software development and deployment. Thus, workshop topics range from requirements modeling, to run-time models, to models for assessing software quality, and to the pragmatics of how to manage large collections of models.

Model Representation

Issues in Representing Domain-Specific Concerns in Model-Driven Engineering
Lionel Montrieux, Yijun Yu, Michel Wermelinger, and Zhenjiang Hu
(Open University, UK; National Institute of Informatics, Japan)
The integration of domain-specific concepts in a model-driven engineering (MDE) approach raises a number of interesting research questions. There are two possibilities to represent these concepts. The first one focuses on models that contain domain-specific concepts only, i.e. domain-specific modelling languages (DSML). The second one advocates the integration of domain-specific concepts in general-purpose models, using what we will refer to in this paper as domain-specific modelling annotation languages (DSMAL). In this position paper, we argue that each approach is particularly suited for specific activities and specific actors, and show how they can be developed and used together. We also highlight the challenges created by the use of two representations, such as the evaluation of models OCL constraints and the synchronisation between the two representations. As an illustration, we present rbacUML, our approach for integrating role-based access control (RBAC) concepts into an MDE approach.
Article Search
MAV-Vis: A Notation for Model Uncertainty
Michalis Famelis and Stephanie Santosa
(University of Toronto, Canada)
We apply the "Physics of Notations" theory to design MAV-Vis, a concrete syntax for partial models, i.e., models where design uncertainty is explicitly captured. To validate our implementation of this theory in creating MAV-Vis, we designed and executed an empirical user study comparing the cognitive effectiveness of MAV-Vis with the existing, ad-hoc notation, MAV-Text. We measured the ease, speed, and accuracy of each notation for reading and writing partial models.
Article Search
Modes, Features, and State-Based Modeling for Clarity and Flexibility
Anitha Murugesan, Sanjai Rayadurgam, and Mats P. E. Heimdahl
(University of Minnesota, USA)
The behavior of a complex system is frequently defined in terms of operational modes---mutually exclusive sets of the system behaviors. Within the operational modes, collections of features define the behavior of the system. Lucent and understandable modeling of operational modes and features using common state-based notations such as Statecharts or Stateflow can be challenging. In this paper we share some of our experiences from modeling modes and features in the medical device domain. We discuss the challenges and present a generic approach to structuring the modes and features of a generic Patient-Controlled Analgesia infusion pump.
Article Search

Model Analysis and Development Support

Lightweight Analysis of Software Design Models at the Whiteboard
Alfredo Motta, Nicolas Mangano, and André van der Hoek
(Politecnico di Milano, Italy; UC Irvine, USA)
While many software design tools exist and are in use daily, when faced with a design problem, developers will more often then not turn to the whiteboard to work on potential solutions. It has been observed that the sketches that software engineers create in this process transition from quite informal, rough sketches to sketches that reflect design notations like UML diagrams or user interfaces with quite precise layout and content. This behavior leads to an interesting opportunity: what if, during this refinement phase, it becomes possible for a whiteboard sketching tool to insert lightweight analyses that provide the developer with feedback about their design at hand? This paper investigates this opportunity, particularly focusing on exploring whether it might be possible to add a lightweight analysis and feedback mechanism to one sketching tool, Calico, that gives the designer insight into the perceived performance of their application.
Article Search
Complementing Model-Driven Development for the Detection of Software Architecture Erosion
Sebastian Herold and Andreas Rausch
(TU Clausthal, Germany)
Detecting software architecture erosion is an important task during the development and maintenance of software systems. Even in model-driven approaches in which consistency between artifacts can partially be established by construction and consistency issues have been intensively investigated, the intended architecture and its realization may diverge with negative effects on software quality. In this article, we describe an approach to flexible architecture erosion detection for model-driven development approaches. Consistency constraints expressed by architectural aspects called architectural rules are specified as formulas on a common ontology, and models are mapped to instances of that ontology. A knowledge representation and reasoning system is then utilized to check whether these architectural rules are satisfied for a given set of models. We describe three case studies in which this approach has been used to detect architecture erosion flexibly and argue that the negative effects of architecture erosion can be minimized effectively.
Article Search
Enhancing Version Control with Domain-Specific Semantics
Matthieu Foucault, Sébastien Barbier, and David Lugato
(CESTA, France)
As Domain-Specific Modeling Languages (DSML) become more widespread, it is now possible for non-computer scientists to design complex systems. Not only do DSMLs make modeling more accessible to domain experts, they also improve their efficiency. Using such models, the problem of their maintenance and evolution arises, with common software engineering issues, such as reversibility and traceability of developments. In this article we present the integration of a collaborative edition process into a model-driven engineering (MDE) simulation platform defining its own DSML, which includes a serialization procedure. Our novel approach defines a collaborative work and version control process. This process uses the concrete textual syntax defined by this DSML, which allows us to use the features of existing Version Control Systems (VCS) to work with serialized models, and helps calculate the differences between two versions of a model, merge versions of these models, and detect merge conflicts.
Article Search

Applications of Modeling

Model Based Control for Multi-cloud Applications
Marco Miglierina, Giovanni P. Gibilisco, Danilo Ardagna, and Elisabetta Di Nitto
(Politecnico di Milano, Italy)
The advent of cloud computing has offered to developers a new appealing paradigm to deploy their applications without capital investments. Resources can now be acquired on-demand in a flexible, scalable and rapid way. However, cloud providers lack of native mechanisms to guarantee the Quality of Service required by specific application domains. High availability can be achieved by replication of critical components. Since outages could affect the entire cloud provider, replication can be effective only by using multiple providers. In this paper we tackle the above problem and present an approach to guarantee availability requirements of cloud-based applications by exploiting replication on multiple clouds to reduce unavailability, still limiting costs. More precisely, we propose: i) an approach to model, at design time, the application, its availability requirements and the characteristics of the used clouds, and ii) a self-adaptive technique responsible, at runtime, of both in-cloud scaling policies and traffic routing among different cloud providers, by means of a control-theoretical approach. We integrated the modeling approach in the Palladio Bench IDE and developed a runtime self-adaptation controller in Matlab. The controller has been evaluated against different workload conditions, costs variations and service failures in simulated scenarios. The controller has been able to provide the desired availability minimizing costs.
Article Search
Design Module: A Modularity Vision Beyond Code: Not Only Program Code But Also a Design Model Is a Module
Naoyasu Ubayashi and Yasutaka Kamei
(Kyushu University, Japan)
We propose a new modularity vision to integrate design modeling with programming. A system consists of not only program code but also design models. However, design models such as UML diagrams have been treated as not modules but complementary documents. This paper provides a novel idea that treats a design model as a first-class software module termed design module. A system cannot be complied without design modules. A developer has to create and modify not only program modules but also design modules. To realize design modules, we introduce Archface, an architectural interface mechanism. Archface exposes architectural points shared between design and code. Archface plays a role as a design interface for a design module and as a program interface for a program module. Archface type system automatically checks the consistency between design and code. Our approach can integrate research on design modeling with research on programming in terms of modularity. Additional costs are not needed to introduce design modules, because Archface descriptions can be generated from a model editor and Archface is just an extension of the notion of program interfaces. That is, we can substitute Archface for traditional program interfaces.
Article Search
Highlighting the Challenges of Model-Based Engineering for Spaceflight Software Systems
Robert G. Pettit, IV. and Navneet Mezcciani
(Aerospace Corporation, USA)
Spaceflight software continues to experience exponential growth as functionality migrates from hardware to software. The resulting complexity of these mission critical systems demands new approaches to software systems engineering in order to effectively manage the development efforts and ensure that reliability is not compromised. Model-based systems/software engineering (MBE) approaches present attractive solutions to address the size and complexity through abstraction and analytical models. However, there are many challenges that must be addressed before MBE approaches can be effectively adopted on a large scale across an entire system. In this position paper, we highlight some of the key challenges based on our experiences with flight software programs employing elements of MBE.
Article Search

Runtime Models

A UML Profile for Dynamic Execution Persistence with Monitoring Purposes
Eladio Domínguez, Beatriz Pérez, and María A. Zapata
(University of Zaragoza, Spain; University of La Rioja, Spain)
System monitoring is typically performed by means of log files storing the sequential trace of the system events. However, these files constitute a poor solution when improved auditing features are required. For this reason, we advocate defining specific persistence structures for registering a more complete system trace. In particular, when the system behaviour is specified by means of a UML statechart, we propose to automatically generate a stereotyped UML class diagram containing information for tracing the system behaviour without loosing the statechart dynamic semantics. To do this, we have formally defined a Statechart Execution Persistence (SEP) UML profile which (1) eases audit and process improvement, (2) ensures accuracy and consistency of data, and (3) guides during the automatic generation of the system's storage mechanisms, following a MDD approach.
Article Search
Requirements Models for Design- and Runtime: A Position Paper
Alexander Borgida, Fabiano Dalpiaz, Jennifer Horkoff, and John Mylopoulos
(Rutgers University, USA; University of Toronto, Canada; University of Trento, Italy)
In this position paper we review the history of requirements models and conclude that a goal-oriented perspective offers a suitable abstraction for requirements analysis. We stake positions on the nature of modelling languages in general, and requirements modelling languages in particular. We then sketch some of the desirable features (... "requirements") of design-time and runtime requirements models and draw conclusions about their similarities and differences.
Article Search

Short Presentations

Model Oriented Programming: Bridging the Code-Model Divide
Omar Badreddin and Timothy C. Lethbridge
(University of Ottawa, Canada)
Model Driven Engineering proposes the use of models as the main development artifacts. This methodology involves generating code from models and then perhaps adding some details to the generated code. Frequently, it is required to also reverse-engineer code to generate models. Despite the wide acceptance of modeling benefits, the use of Model Driven Engineering practices remains limited. We present model oriented programming as a new paradigm to reduce the ever-present tension between model-centric and code-centric development styles. The core of this approach is to add UML abstractions such as associations and state machines directly into a high-level programming language code. In this approach, model diagrams become just another abstract view of the code. The need for reverse engineering is eliminated, since everything in the diagram is represented directly in the code. Model orientation is illustrated using Umple, a working model oriented programming platform. A functional layer of an airline reservation system is presented as a case study.
Article Search
A Model-Based Approach to Language Integration
Federico Tomassetti, Antonio Vetrò, Marco Torchiano, Markus Voelter, and Bernd Kolb
(Politecnico di Torino, Italy; voelter ingenieurbuero fuer softwaretechnologie, Germany; itemis, Germany)
The interactions of several languages within a software system pose a number of problems. There is several anecdotal and empirical evidence supporting such concerns. This paper presents a solution to achieve proper language integration in the context of language workbenches and with limited effort. A simple example is presented to show how cross-language constraints can be addressed and the quality of the support attainable, which covers error-checking and refactoring. A research agenda is then presented, to support future work in the area of language integration, taking advantage of modern language workbenches features.
Article Search
Prioritizing Software Anomalies with Software Metrics and Architecture Blueprints: A Controlled Experiment
Everton Guimaraes, Alessandro Garcia, Eduardo Figueiredo, and Yuanfang Cai
(PUC-Rio, Brazil; UFMG, Brazil; Drexel University, USA)
According to recent studies, architecture degradation is to a large extent a consequence of the introduction of code anomalies as the system evolves [3][4][5][6]. Many approaches have been proposed for detecting code anomalies, but none of them has been efficient on prioritizing code anomalies that represent real problems in the architecture design. In this sense, our work aims to investigate whether the prioritization of instances of three types of classical code anomalies, Divergent Change, God Class and Shotgun Surgery, can be improved when supported by architecture blueprints. These blueprints are informal models often available in software projects, and they are used to capture key architecture decisions. Moreover, we are also investigating what information may be useful in the design blueprints to help developers on prioritizing the most critical software anomalies. In many cases, developers indicated that it would be interesting the insertion of additional information on the blueprints in order to detect architecturally-relevant anomalies
Article Search

proc time: 0.1