Models in Software Engineering

The doctoral symposium (DocSym) of the 14th International Conference on Model Driven Engineering Languages and Systems (MODELS 2011) provided an opportunity for doctoral researchers to present and discuss their research, and to gather feedback from peers and experienced researchers in the field.

The goal of the DocSym is to provide a forum in which PhD students can present their work in progress and to foster the role of MODELS as a premier venue for research in model-driven engineering. The symposium aims to support students by providing independent and constructive feedback about their already completed and, more importantly, planned research work. The symposium was accompanied by prominent professors in the field of model-driven engineering who will actively participate in critical discussions.

In model-driven engineering, domain-specific languages (DSLs) play an important role in providing well-defined environments for modeling different aspects of a system. Detailed knowledge of the application domain as well as expertise in language engineering is required to create new languages. This research work proposes automated knowledge acquisition to support language engineers in early language development phases. We describe an iterative approach in which DSL development benefits from formalized knowledge sources and information extraction from text supporting domain analysis and metamodel construction. We show how the acquired knowledge is used to guide language engineers and how knowledge acquisition is adapted according to modeling decisions.

Several metamodels have been proposed in the software engineering literature recently. For practical usage, it is important to ensure that these metamodels can be used in an interoperable fashion. In this paper we present an approach as a part of our PhD research in the same direction. Our methodology is based on the study of analogous characteristics among metamodels, ontologies and schemas. We have adopted ontology merging and schema matching techniques and apply them to the domain of metamodels to assist in creating interoperable metamodels. This methodology is applied and presented here with an illustrative example in which we show the results of merging two of the OMG metamodels: the Organization Structure Metamodel (OSM) and the Business Process Modelling Notation (BPMN).

The Educators’ Symposium (EduSymp) focuses on discussing teaching the usage of software modelling techniques throughout all phases of a software development process to software engineers at universities and software industries. Collocated with the ACM/IEEE International Conference on Model-Driven Engineering Languages and Systems (MODELS), EduSymp provides the opportunity to discuss new ideas and approaches in the wide area of teaching modelling within the software modelling community to gain new insights and ideas. Besides paper presentations the 7th EduSymp, held in October 2011 in Wellinton, New Zealand, also comprised an inspiring keynote about challenges and opportunities in teaching modelling as well as an active discussion on skills and competencies to be educated in modern modeling education.

The paper presents an approach to teaching software modeling that has been put into practice at the Babeş-Bolyai University of Cluj-Napoca and Paul Sabatier University in Toulouse. This aims at persuading students of the advantages deriving from the usage of rigorous models. The development of such models, which relies on the Design by Contract technique, is a must in the context of the Model-Driven Engineering paradigm. Another goal of our approach is for students to acquire core software modeling principles and techniques, allowing them to identify and avoid various types of pitfalls enclosed by the modeling examples posted on web. Following a decade of use and teaching of OCL, we have concluded that starting with a defense of the necessity and advantages offered by the use of constraints (an “inverted curriculum” approach) is a far more efficient teaching method compared to a pure technical introduction into the language itself.

EAMDE was a 12 month research project, investigating how industry uses model-driven software development (MDSD). Using quantitative and qualitative research techniques, experiences were collected on the adoption and application of MDSD in 17 companies. The study highlighted examples of good and bad practice that lead to success or failure with MDSD. Some of these practices appear to have ramifications on the way that MDSD, and software modeling more generally, is taught within universities. This paper presents three of the key findings relevant to education: (1) A significant number of successful MDSD companies build their own modeling languages and generators, suggesting a re-orientation of education away from UML notation to fundamental modeling principles; (2) MDSD is generally taught top-down, whereas industry success is more likely when MDSD is applied bottom-up; (3) successful application of MDSD requires skills both in abstract modeling and compilers/optimization; however, these skills tend to be separated in standard CS curricula.

The VARY workshop took place on the first day of the MODELS conference week and brought together researchers and practitioners in the field of variability modeling. The workshop contained invited talks on empirics of MDD and reuse, and on the Common Variability Language standardization. The example session showed how variability modeling could be useful in e-commerce and multiple country business software. The generic result session showed a survey on variability modeling approaches and how to evolve variability definition when base model is changed. Finally the analysis session handled techniques for optimizing product validity checking and product line metrics. The ample time for discussions was easily filled and engaged many in the stable audience throughout the day.

We present an approach for evolving separate variability models when the associated base model is altered. The Common Variability Language (CVL) is a generic language for modeling variability in base models. The base models are oblivious to the associated variability models, causing additional challenges to this association when the base models are maintained. Assuming that a base model has been changed, we suggest using CVL to record this change. Further analysis of this CVL model reveals the impact of the change, an may in some cases result in automatic evolution of the variability model corresponding to the changed base model. We illustrate and discuss the approach using an example from the train domain.

Service Oriented Architecture (SOA) has emerged as a paradigm for distributed computing that promotes flexible deployment and reuse. However, SOA systems currently lack a systematic approach for managing variability in service requirements and design. Our paper addresses this problem by applying software product line (SPL) concepts to model SOA systems as service families. We introduce an approach to model SOA variability with a multiple-view SOA variability model and a corresponding meta-model. The approach integrates SPL concepts of feature modeling and commonality/variability analysis with different service views using UML and SoaML. This paper describes a multiple-view meta-model that maps features to variable service models as well as model consistency checking rules. We describe how to derive family member applications and also present a validation of the approach.

Following the trend of other editions, it was held this year (2011) in Wellington, New Zealand, the 5th International Workshop on Multi-Paradigm Modelling: Concepts and Tools (MPM). Once again has been a satellite event of the International Conference on Model-Driven Engineering Languages and Systems (MoDELS). It aims at further the state-of-the-art as well as to define future directions of this emerging research area by bringing together world experts in the field for an intense one-day workshop. This paper summarizes the results of this year’s event.

Multi-view modelling is a widely accepted technique to reduce the complexity in the development of modern software systems. It allows developers to focus on a narrowed portion of the specification dealing with a selected aspect of the problem. However, multi-view modelling support discloses a number of issues mainly due to consistency management, expressiveness, and customization needs. A possible solution to alleviate those problems is to adopt a hybrid solution for multi-view modelling based on an arbitrary number of custom views defined on top of an underlying modelling language. In this way it is possible to benefit from the consistency by-construction granted by well-formed views while at the same time providing malleable perspectives through which the system under development can be specified. In this respect, this paper presents an approach for supporting synchronization mechanism based on model differences in hybrid multi-view modelling. Model differences allow to focus only on the manipulations operated by the user in a particular view, and to propagate them to the other views in a incremental way thus reducing the overhead of a complete recomputation of modified models.

When different parts of a system depend on different technical domains, the best suitable paradigm for modeling each part may differ. In this paper, we focus on the semantic adaptation between parts of a model which use different modeling paradigms in the context of model composition. We show how CCSL, a language for defining constraints and relations on clocks, can be used to define this semantic adaptation in a formal and modular way.

Most software development projects apply modelling in some stages of development and to various degrees in order to take advantage of the many and varied benefits of it. Modelling is, for example, applied for facilitating communication by hiding technical details, analysing a system from different perspectives, specifying its structure and behaviour in an understandable way, or even for enabling simulations and generating test cases in a mode-driven engineering approach. Thus, the evaluation of modelling techniques, languages and tools is needed in order to assess their advantages and disadvantages, to ensure their applicability to different contexts, their ease of use, and other issues such as required skills and costs; either isolated or in comparison with other methods.

Modularity is a widely advocated strategy for handling complexity in conceptual models. Nevertheless, a systematic literature review revealed that it is not yet entirely clear under which circumstances modularity is most beneficial. Quite the contrary, empirical findings are contradictory, some authors even show that modularity can lead to decreased model understandability. In this work, we draw on insights from cognitive psychology to develop a framework for assessing the impact of hierarchy on model understandability. In particular, we identify abstraction and the split-attention effect as two opposing forces that presumably mediate the influence of modularity. Based on our framework, we describe an approach to estimate the impact of modularization on understandability and discuss implications for experiments investigating the impact of modularization on conceptual models.

This paper presents an experiment carried out as a pilot study to obtain a first insight into the influence of the quality of UML models on the maintenance of the corresponding source code. The quality of the UML models is assessed by studying the amount of information they contain as measured through a level of detail metric. The experiment was carried out with 11 Computer Science students from the University of Leiden. The results obtained indicate a slight tendency towards obtaining better results when using low level of detail UML models, which contradicts our expectations based on previous research found in literature. Nevertheless, we are conscious that the results should be considered as preliminary results given the low number of subjects that participated in the experiment. Further replications of this experiment are planned with students and professionals in order to obtain more conclusive results.

The 6th edition of the workshop Models@run.time was held at the 14th International Conference MODELS. The workshop took place in the city of Wellington, New Zealand, on the 17th of October 2011. The workshop was organised by Nelly Bencomo, Gordon Blair, Robert France, Betty H.C. Cheng, and Cédric Jeanneret. We present a summary of the workshop and a synopsis of the papers presented during the workshop.

We consider the problem of run-time discovery and continuous monitoring of new components that live in an open environment. We focus on extracting a formal model—which may not be available upfront—by observing the behavior of the running component. We show how the model built at run time can be enriched through new observations (dynamic model update). We also use the inferred model to perform run-time verification. That is, we try to identify if any changes are made to the component that modify its original behavior, contradict the previous observations, and invalidate the inferred model.

Approaches to self-adaptive software systems use models at runtime to leverage benefits of model-driven engineering (MDE) for providing views on running systems and for engineering feedback loops. Most of these approaches focus on causally connecting runtime models and running systems, and just apply typical MDE techniques, like model transformation, or well-known techniques, like event-condition-action rules, from other fields than MDE to realize a feedback loop. However, elaborating requirements for feedback loop activities for the specific case of runtime models is rather neglected.

All workshops of the MoDeVVa series are focused on Model-Driven Engineering, Verification, and Validation.

Models are purposeful abstractions. They are important elements in established life cycle management approaches, especially in model-driven approaches. Most importantly, they are very useful for communication of important aspects of the software being developed - they are used to support the focus on these important aspects and to make complex systems simple to understand. Furthermore, models are descriptions at an arbitrary level of detail and can, thus, be used to make traceability from requirements to any other object in development easier. If the models are not just sketches, but also have a formal foundation, they can also used for automatic transformation or code generation. Typical applications are the automatic generation of large parts of system source code, which results in a decrease of system engineering costs. One of the most important representatives for the application of models is the Model-Driven Engineering (MDE) approach. MDE is a development methodology that is based on models, meta models, and model transformations. There are many tools to support models, (domain-specific) modeling languages, model transformations, and code generation. The usage of models, model transformations, and code generation is becoming more and more important for industrial applications. The fact that development of MDE-related techniques still moves forward shows that MDE is quickly changing and that new approaches and corresponding issues arise frequently. The focus of the MoDeVVa series is on verification and validation (V&V) techniques in the context of MDE. V&V are currently very relevant in many safety-critical domains, with some of those domains being heavyweight representatives such automotive or avionics.

This paper presents an approach for automatically generating a testing oracle for train stations. Based on a model of a train station and a formal definition of the behavior of the station, Alloy is used to generate all positive traces from a given situation. By specifying the precondition (test input), a simulation of the station model gives all legal train movement from this state, which defines the testing oracle. This oracle can be used for checking the result of testing the implementation of the station by comparing the train movement from the test with the legal train movement specified by the oracle. We suggest a prototype implementation based on the Train Control Language and give an example oracle for a typical test-case. Furthermore, we elaborate on the benefits of using product line technology, given by the Common Variability Language, to reduce the analysis effort necessary to obtain the oracle for product models.

Despite technical improvements in current verification tools, the increasing size of developed systems makes the detection of design defects more difficult. Context-aware Model-Checking is an effective technique for automating software verifications considering specific environmental conditions. Unfortunately, few existing approaches provide support for this crucial task and mainly rely on significant effort and expertise of the engineer. We previously proposed a DSL (called CDL) to facilitate the formalization of requirements and contexts. Experiences has shown that manually writing CDL models is difficult and error prone task. In this paper, we propose a tool-supported framework to automatically generate CDL models using eXtended Use Cases (XUC). XUC models consistently link use cases with scenarios with respect to the domain specification vocabulary of the model to be checked. We also propose a requirements specification language to fill the gap between textual requirements and CDL properties. An industrial case study is presented to illustrate the effectiveness of XUCs to generate correct and complete CDL models for formal model analysis.

While there are many aspect-oriented modeling (AOM) approaches, from requirements to low-level design, it is still difficult to compare them and know under which conditions different approaches are most applicable. This comparison, however, is crucially important to unify existing AOM and more traditional object-oriented modeling (OOM) approaches and to generalize individual approaches into a comprehensive end-to-end method. Such a method does not yet exist. This paper reports on work done at the inaugural Comparing Modeling Approaches (CMA) workshop towards the goal of identifying potential comprehensive methodologies: (i) a common, focused case study for six modeling approaches, (ii) a set of criteria applied to each of the six approaches, and (iii) the assessment results.

With the increasing adoption of Model-Based Development in many domains (e.g., Automotive Software Engineering, Business Process Engineering), models are starting to become core artifacts of modern software engineering processes. By raising the level of abstraction and using concepts closer to the problem and application domain rather than the solution and technical domain, models become core assets and reusable intellectual property, being worth the effort of maintaining and evolving them. Therefore, increasingly models experience the same issues as traditional software artifacts, i.e., being subject to many kinds of changes, which range from rapidly evolving platforms to the evolution of the functionalities provided by the applications developed. These modifications include changes at all levels, from requirements through architecture and design, to executable models, documentation and test suites. They typically affect various kinds of models including data models, behavioral models, domain models, source code models, goal models, etc. Coping with and managing the changes that accompany the evolution of software assets is therefore an essential aspect of Software Engineering as a discipline.

The fourth ACES-MB workshop brought together researchers and practitioners interested in model-based software engineering for real-time embedded systems, with a particular focus on the use of models for architecture description and domain-specific design, and for capturing non-functional constraints. Six presenters proposed contributions on a systematic transition from systems modeling using SysML to software modeling using UML, verification of initial architecture models against requirements using consistency checking techniques, techniques to check the validity of refinement relation between abstraction levels, constructing rapid prototypes to assess the behavioral design characteristics, new abstraction layers to describe operating system and mixed-signal issues, and a model-driven approach for parallelizing software programs. In addition, a lively group discussion tackled these issues in further detail. This report presents an overview of the presentations and fruitful discussions that took place during the ACES-MB 2011 workshop.

The electric and electronic architecture (EEA), which is built up during the concept phase of automotive electronics development, has fundamental impact on the success of a vehicle under development. The complexity of upcoming architectures requires novel approaches to support system architects during the design phase.

This paper describes a model-based generic approach which allows verifying an EEA with regard to its requirements by using techniques of consistency checks during an early design phase. This includes handling of incomplete models. In this case it offers the possibility to automate consistency checks and in future work facilitate an automatism for optimization and design space exploration to check different realization alternatives of an initial EEA. Automatic report generation of results serves for documentation.

In this paper, we describe a model-driven approach that aids the developer in parallelizing a software program. Information from a dynamic call tree, data dependencies and domain knowledge from the developer are combined in a model transformation process. This process leads to a model of the application where it becomes obvious which parts of the application can be executed in parallel.