In the context of world economies transitioning to services, telecommunications services are the primary means of communication between different economic entities and are therefore essential. The focus on the end consumer, the convergence with the Internet, the separation between the software and the hardware implementing a service, and the telecommunications market deregulation have led to a revolution and a new era in the telecommunications industry. To meet these challenges, former national telecommunications providers have to reduce the construction time, from months to days, while affecting non-negatively other parameters (e.g., cost, quality of service, quality of experience) of new telecommunications services. To tackle this broad theme, we propose a telecommunications service construction process, the software tools that are to be used in this process and a tool building process to build them. The telecommunications service construction process reflects current practices in the telecommunications industry. As such, it should be (easily) accepted by practitioners. The software tools (i.e., Domain Specific Modeling Languages designed as profiles of an Enterprise Architecture Modeling Language, graphical editors, code generators, Off the Shelf network simulators, a collaboration Design Rationale Domain Specific Modeling Language) help telecommunications providers face the challenges. The tool building process relies on models and provides a high automation degree, hence software tools can be build more rapidly. We illustrate the telecommunications service construction process and the tools using a multimedia conferencing service. Our proposals contribute to reducing the construction time of new telecommunications services, while providing the possibility of improved quality of service and increased involvement of the consumer. Faster provisioning of new telecommunications services, that better answer the consumers¿ needs, will increase the rate of development of new economic services in general, and will ultimately have a positive impact on world economic development.

Research on quality issues of business process models has recently begun 
to explore the process of creating process models. With growing complexity, the creation 
of business process models requires the presence of several, potentially spatially 
distributed, stakeholders. As a consequence, the question arises how this affects the 
process of process modeling. In this paper, we present an extension to Cheetah Experimental 
Platform, specifically designed for investigating how process models are 
collaboratively created. Furthermore, we illustrate how various levels of interactions 
are supported by our modeling editor and outline its usage for analyzing the process of 
collaboratively creating process models. We believe that this extension is a first step 
toward understanding the process of process modeling in a collaborative setting which 
will ultimately help us to develop better process modeling environments.

Collaborative modeling tools are useful for many tasks within design or learning processes. However, they are difficult to build and are usually domain-specific. In response to this situation, we propose a model-driven method for the development of domain-independent collaborative modeling tools. This method consists of a methodological framework, a conceptual framework and a technological framework. The methodological framework defines the phases to be carried out when applying the method, whilst the conceptual framework is made up of the meta-models used in the method and the transformation processes established between them. Finally, the technological framework consists of the integration of some plug-ins from the Eclipse Modeling Project with some add-ons which provide collaborative functionality. Some case studies that exemplify this development method for specific domains are explained in detail, together with comparisons with similar approaches. Thus, an initial evaluation of this approach is provided and some advantages over those other approaches are identified. A further evaluation process in the form of an empirical study of use has also been carried out. Hence, the method proves to be useful for any user who does not have advanced knowledge of groupware programming and who needs to use a collaborative modeling tool in his/her work. Moreover, each framework implies a contribution that can be used in different contexts.

Model-Driven Engineering is rapidly emerging as a powerful 
way to increase quality and productivity in software development 
projects. However, its focus on modeling, specially with graphical notations, 
makes its adoption very difficult to blind and visually impaired 
users, who have always been able to program with the help of assistive 
technologies such as screen readers. Without a comprehensive and updated 
alternative text, this type of software artifact is of little use to 
a developer with visual impairment. In this paper we present ongoing 
research and the proposal of a tool to enable the collaboration between 
sighted and blind/visually impaired software developers. The tool will 
provide alternative textual representation to models in a web environment, 
so that collaboration can effectively occur. Details on the technical 
viability and basic functionality of the tool are presented. We believe 
these are of great interest to the MDE community, as other researchers 
and practitioners may build upon our initial ideas to develop their work. 
We also discuss future investigation possibilities, and the expected contributions 
of our research.

Abstract: Multiple architects may concurrently create and modify a model of computer software, each on their own client at a different location. Each change that is made to a model is forwarded to a server for analysis. The server may determine whether the change creates a conflict. If no conflict is detected, the change may be approved, saved, and propagated by the server to all of the other clients that are working on the same model. If a conflict is detected, on the other hand, the change may not be approved by the server. The server may instead provide notice of the conflict.

This paper describes a design study that explores how multi-touch devices can provide support for developers when carrying out modeling tasks in software development. We investigate how well a multi-touch augmented approach performs compared to a traditional approach and if this new approach can be integrated into existing software engineering processes. For that, we have implemented a fully-functional prototype, which is concerned with agreeing on a good object-oriented design through the course of a Class Responsibility Collaboration (CRC) modeling session. We describe how multi-touch technology helps with integrating CRC cards with larger design methodologies, without loosing their unique physical interaction aspect. We observed high-potential in augmenting such informal sessions in software engineering with novel user interfaces, such as those provided by multi-touch devices.

Distributed software modeling is common today, although geographically 
separated designers need to overcome several 
communication challenges. Software designers typically use 
version control systems (VCSs) to integrate their work. However, 
existing VCSs do not continuously inform all designers 
of new design decisions and conflicts. Designers often introduce 
conflicts precisely because they are unaware of such 
design decisions. Research on collaborative implementation 
has explored workspace awareness to deal with this challenge, 
and observed that providing workspace awareness facilitates 
conflict detection and resolution. However, existing 
workspace awareness tools typically do not work well as-is 
for collaborative modeling. We envision the emergence of 
new types of collaborative modeling tools that provide various 
forms of workspace awareness.

Costs and markets lead engineering teams to collaborate 
from different locations all over the world. Modelling tools are present in 
development processes to produce complex software and these tools have 
to be highly collaborative to permit teams to be productive. Axellience 
tries to resolve issues about distributed collaboration and modelling with 
GenMyModel.

Design is more important than ever as software systems continue to 
increase in complexity, become more distributed, expose multiple interfaces 
and have more integration points. Design process has also become more 
complex, involving dispersed teams, third-party components, outsourcing 
providers and business partners. Nevertheless, design tools have not sufficiently 
been coping with these growing challenges. In this paper, we discuss design 
challenges and highlight features of design tools that should help address them. 
We also describe a new application; Rational Design Management (DM) 
developed to boost the quality of design and streamline the design process. DM 
enables a collaborative approach that broadens the understanding of design, 
improves design quality and shrinks design time. DM leverages semantic web 
technologies and implements the Open Services for Lifecycle Collaboration 
(OSLC) specification to deliver a linked data approach for managing design. 
Such an approach facilitates design extensibility, reuse and integration across 
the development lifecycle.

Redesign of business processes is an activity frequently 
performed in modern organizations as a response to 
intrinsic and extrinsic change requirements. The way (methods, 
techniques, tools) a process is redesigned varies greatly with the 
process context. In contrast, involving stakeholders of a process 
in process redesign can be considered a common practice 
throughout organizations of all kinds. Hence, research and 
industry have only recently investigated the characteristics 
of collaboration in process redesign and the challenges that 
arise for software-support respectively. In this paper we will 
systematically describe findings from a case-study where we 
adapted a particular type of collaboration technology – a wiki 
engine – towards collaborative process modeling support and 
exposed it to a real-world setting. The case-study shows how 
a small team of domain experts within a large office supply 
manufacturing company redesigned a recruiting process by 
using a wiki as their primary process modeling environment.

Ensuring responsive design of web applications requires their user interfaces to be able to adapt according to different contexts of use, which subsume the end users, the devices and platforms used to carry out the interactive tasks, and also the environment in which they occur. To address the challenges posed by responsive design, aiming to simplify their development by factoring out the common parts from the specific ones, this paper presents Quill, a web-based development environment that enables various stakeholders of a web application to collaboratively adopt a model-based design of the user interface for cross-platform deployment. The paper establishes a series of requirements for collaborative model-based design of cross-platform web user interfaces motivated by the literature, observational and situational design. It then elaborates on potential solutions that satisfy these requirements and explains the solution selected for Quill. A user survey has been conducted to determine how stakeholders appreciate model-based design user interface and how they estimate the importance of the requirements that lead to Quill.

Domain-specific visual languages support high-level modeling for a wide range of application domains. However, 
building tools to support such languages is very challenging. We describe a set of key conceptual requirements for 
such tools and our approach to addressing these requirements, a set of visual language-based meta-tools. These 
support definition of meta-models, visual notations, views, modeling behaviours, design critics and model 
transformations and provide a platform to realize target visual modeling tools. Extensions support collaborative 
work, human-centric tool interaction, and multi-platform deployment. We illustrate application of the metatoolset 
on tools developed with our approach. We describe Tool Developer and cognitive evaluations of our 
platflorm and our exemplar tools, and summarise key future research directions.

In Model-Driven Engineering (MDE) adequate means for collaborative modeling among multiple team members is crucial for large projects. To this end, several approaches exist to identify the operations applied in parallel, to detect conflicts among them, as well as to construct a merged model by incorporating all non-conflicting operations. Conflicts often denote situations where the application of one operation disables the applicability of another operation. Whether one operation disables the other, however, often depends on their application order. To obtain a merged model that maximizes the combined effect of all parallel operations, we propose an automated approach for finding the optimal merging sequence that maximizes the number of successfully applied operations. Therefore, we adapted and used a heuristic search algorithm to explore the huge search space of all possible operation sequences. The validation results on merging various versions of real-world models confirm that our approach finds operation sequences that successfully incorporate a high number of conflicting operations, which are otherwise not reflected in the merge by current approaches.

Software modeling is a fundamental process in any software development methodology. This 
process aims at identifying the core elements in the system and the relations among those 
elements. It is also the phase where many important design decisions are made and those 
decisions will affect the quality of that software system through all the rest of the development 
phases. Software development is a social activity and includes extensive collaboration throughout 
the software lifecycle including the modeling phase. In modern software industry, many 
development teams are geographically spread out, making collaboration an important issue. 
In this thesis, we present a new approach to support development teams carry on modeling 
sessions even when the members are far away from each other. Our approach is based on realtime 
change-based collaboration that makes team members work together on the same model 
at the same time taking into consideration the importance of awareness among team members. 
To demonstrate our ideas, we built a tool, Sawa, a web-based collaborative software modeling 
tool that allows team members to work together on the same model at the same time. Sawa 
also increases team awareness by its highlighting system that makes all team members know 
who is doing or has done what. It also allows users to replay the building process of a model 
to get the full picture of how a model has reached its current state. 
We ran an evaluation experiment on Sawa and gathered qualitative feedback that supports our 
belief that our approach increases the productivity of modelers and helps them solve conflicts 
as they happen to avoid future complications, thus leading to better design decisions and better 
models in general.

We share experience in supporting development and evolution of a large banking product using a homegrown model driven engineering (MDE) toolset. We discuss improvements that needed to be introduced in the MDE toolset to support collaborative development with teams distributed across different geographical locations. Though experience is shared in a specific context, we believe, MDE researchers, enthusiasts, practitioners and tool vendors will find the takeaways from this experience applicable even in a more general context of large scale software development.

We introduce AToMPM, an open-source framework for designing domain-specific 
modeling environments, performing model transformations, manipulating 
and managing models. It runs completely over the web, making it independent 
from any operating system, platform, or device it may execute on. 
AToMPM offers an online collaborative experience for modeling. Its unique architecture 
makes the framework flexible and completely customizable, given that 
AToMPM is modeled by itself, and external applications can be easily integrated.

In model-driven software development, software models are the main artifacts used not 
only for supporting brainstorming, analysis, and design purposes, but also for generating executable 
code. Such software models are usually not created by one single developer, but within a team. To 
coordinate team work, versioning systems have proven to be indispensable for managing 
modifications performed by different modelers at the same time. When concurrently performed 
modifications are contradicting each other, the standard versioning paradigm requires the person 
who detected the conflict to resolve it immediately in order to keep the evolved artifacts in a 
consistent state. Whereas this approach works well in later phases of the software development 
process, in early phases, when the development team had not established a consolidated view on the 
system under development yet, the conflicts might provide valuable information on the various 
intentions of the modelers. This information might be lost if removed in an undocumented manner 
by a single modeler. We propose an alternative versioning paradigm for models, where conflicts are 
temporarily tolerated and discuss its technical realization for current modeling languages such as the 
UML. The resolution of conflicts is then not performed by one single modeler but within a team so 
that a consolidated version of the model is obtained

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

Model-Driven Engineering (MDE) refers to the systematic use of models 
as first class entities throughout the software development life cycle. Over the 
last few years, many MDE technologies have been conceived for developing domain 
specific modeling languages, and for supporting a wide range of model 
management activities. However, existing modeling platforms neglect a number 
of important features that if missed reduce the acceptance and the relevance of 
MDE in industrial contexts, e.g., the possibility to search and reuse already developed 
modeling artifacts, and to adopt model management tools as a service. 
In this paper we propose MDEForge a novel extensible Web-based modeling platform 
specifically conceived to foster a community-based modeling repository, 
which underpins the development, analysis and reuse of modeling artifacts. Moreover, 
it enables the adoption of model management tools as software-as-a-service 
that can be remotely used without overwhelming the users with intricate and 
error-prone installation and configuration procedures.

Guidelines and best practices on how to design and develop 
mobile applications are being periodically released by mobile 
OS vendors, mobile developers, and researchers. Still, 
a framework that collects and integrates them in a simple, 
holistic, and automated approach is missing. 
This work proposes a modelling framework supporting the 
collaborative design and development of data-intensive mobile 
applications. By using Model-Driven Engineering techniques, 
we define four modelling languages covering the main 
concerns coming from the mobile app development domain; 
the framework supports the analysis of models and the automated 
synthesis of executable mobile applications for multiple 
platforms. This paper provides an overall view of the 
modelling framework, and highlights its main features for 
both technical and non-technical stakeholders

The development of User Interfaces (UIs) is a complex task. Researches shown that one of the reasons is the lack of integrated views that often forces developers to implement suboptimal solutions. These integrated views refer to (1) the artifacts that are manipulated by the stakeholders during the UI development process and (2) how these artifacts relate to each other. To overcome the lack of integrated views in the context of model-based UI development this paper introduces AMEs, Adaptive Modelling Environments that support UI development by providing explicit representations of both the artifacts and their relations. A first prototype is depicted in a case study and illustrated with a video. Details of the architecture are provided.

In this paper we describe an approach for model-based realtime 
synchronization. We present an extension of the EMFStore 
platform which allows multiple collaborators to connect 
to each other directly via peer-to-peer and to synchronize 
changes on model instances with each other in real-time. 
With this approach we allow users to collaboratively work 
literally on the same model instance. We argue that this 
approach avoids serious conflicts and reduces the problem 
of outdated model instances.

The paper presents WebGME, a novel, web- and cloud-based, 
collaborative, scalable (meta)modeling tool that supports the design of 
Domain Specific Modeling Languages (DSML) and the creation of corresponding 
domain models. The unique prototypical inheritance, originally 
introduced by GME, is extended in WebGME to fuse metamodeling 
with modeling. The tool also introduces novel ways to model crosscutting 
concerns. These concepts are especially useful for multi-paradigm 
modeling. The main design drivers for WebGME have been scalability, 
extensibility and version control. The web-based architecture and the 
constraints the browser-based environment introduces provided significant 
challenges that WebGME has overcome with balanced trade-offs. 
The paper describes the architecture of WebGME, argues why the major 
design decisions were taken and presents the novel features of the tool.

Model- driven engineering (MDE) is increasingly used across industries 
to abstract designs and viewpoints. Development productivity improves 
owing to faster change cycles. However, many current MDE tools are 
suitable for drawing but won’t scale up. Roundtrip for maintenance, tool 
interoperability, and team collaboration are far from industry needs. 
But there’s a light on the horizon with a new generation of MDE tools. 
In this issue’s column, Alfonso Pierantonio and his team provide an 
overview of recent MDE technologies. I look forward to hearing from 
both readers and prospective column authors about this column and 
the technologies you want to know more about.

Contemporary engineering information system designs are generally interdisciplinary and exceedingly complex. As a result, managing and understanding these systems collaboratively poses unnecessary challenges to end users. In this research, we studied and developed visualization and collaboration techniques to facilitate comprehension and management of engineering information systems with great complexity. Existing commercial and research visualization developments only address applications in specific domains. This paper introduces two techniques applicable to large-scale models across various domains and integrated within a web-based modeling platform, WebGME. The techniques presented are 1) domain-specific visualization that allows representation of components in each domain with conventional or meaningful icons, and 2) model connectivity abstraction that allows domain independent, context-aware abstraction of model connections.

Software architects who collaboratively evolve a 
software model rely on version control systems (VCSs) to synchronize 
their individual changes to the model. However, with 
the current generation of software model VCSs, architects remain 
unaware of newly arising conflicts until the next synchronization, 
raising the risk that delayed conflict resolution will be much 
harder. There are existing tools that proactively detect analogous 
conflicts at the level of source code. However, it is challenging to 
directly use them for software models because those tools are constructed 
to manage code-level rather than model-level changes. 
Furthermore, no empirical data is currently available regarding 
the impact of proactive conflict detection on collaborative design. 
In this paper, we report on our design-level proactive conflict 
detection research, which specifically targets a class of higherorder 
conflicts that do not prevent merging but do violate a 
system’s consistency rule. We present FLAME, an extensible, 
operation-based collaborative software design framework that 
proactively detects conflicts. We also present a user study result 
involving FLAME conducted with 42 participants. The study 
indicated that the participants who used FLAME were able to 
create higher quality models in the same amount of time, and to 
detect and resolve higher-order conflicts earlier and more quickly

Real-time collaborative editing (RTCE) can support a group of people collaboratively work from distributed locations at the same time. However, consistency maintenance is one key challenge when different types of conflicts happen. Therefore a common synchronous mechanism is proposed to support consistency maintenance in the process of multi-view business modeling. Based on operation analysis on different views of models in the real-time collaborative editing system, detection of potential conflicts is realized by means of a decision-making tree. Then consistency maintenance provides a comprehensive and applicable conflicts detection and resolution for collaborative business modeling. Finally, a prototype of collaborative multi-view business modeling system is introduced to verify the approach. The point is that the mechanism proposes a comprehensive solution for collaborative multi-view business modeling.

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

Evolution and maintenance of the large-scaled software models require collaboration of several designers on the shared modeling artefacts. Since collaborators manipulate shared models in real-time, synchronization of the model changes is the main challenging aspect for collaborative modeling application. 

In order to achieve efficient real-time synchronization of changes, these changes have to be properly identified, represented by appropriate notations and exchanged by modeling deltas. This paper presents a real-time collaborative modeling application based on exchanging model differences between collaborators. Modeling deltas are represented by an operational delta notation. The approach is validated by presenting a collaborative class diagram editor.

When software engineers collaborate, they frequently use whiteboards or paper for sketching diagrams. This is fast and flexible, but the resulting diagrams cannot be interpreted by software modeling tools. We present FLEXISKETCH TEAM, a tool solution consisting of a significantly extended version of our previous, single-user FLEXISKETCH tool for Android devices and a new desktop tool. Our solution for collaborative, model-based sketching of free-form diagrams allows users to define and re-use diagramming notations on the fly. Several users can work simultaneously on the same model sketch with multiple tablets. The desktop tool provides a shared view of the drawing canvas which can be projected onto an electronic whiteboard. Preliminary results from an exploratory study show that our tool motivates meeting participants to actively take part in sketching as well as defining ad-hoc notations.

The increase in productivity implied by model-driven software product line engineering is weakened by the complexity exposed to the user having to manage a multi-variant model. Recently, a new paradigm has emerged: filtered software product line engineering transfers the established check-out/modify/commit workflow from version control to variability management, allowing to iteratively develop the multi-variant model in a single-variant view. This paper demonstrates SuperMod, a tool that supports collaborative filtered model-driven product line engineering, implemented for and with the Eclipse Modeling Framework. Concerning variability management, the tool offers capabilities for editing feature models and specifying feature configurations, both being well-known formalisms in product line engineering. Furthermore, collaborative editing of product lines is provided through distributed version control. The accompanying video shows that SuperMod seamlessly integrates into existing tool landscapes, reduces the complexity of multi-variant editing, automates a large part of variability management, and ensures consistency. 

The conceptual model in software development captures the key concepts in specific problem domains, as well as the important relationships between them. The quality of the conceptual model plays an important role for the success of requirements engineering and software development. Generally, the quality of the conceptual model is restricted by modelers' personal knowledge and experience, and a single modeler usually possesses parts of the information that should be captured in a high-quality conceptual model, especially when the problem domain has a high complexity. To address this problem, we developed a tool named SCCMT, which provides an approach to modeling the conceptual model collaboratively with a large number of people, especially an online crowd. The main characteristic of this tool is twofold. (1) An indirect interaction mechanism is proposed to solve the communication problem among the temporal and topographical distributed online modelers. (2) A merge-feedback process is provided to inspire any single modeler in the crowd to improve her/his model based on the current modeling result of the crowd.

Large-scale model-driven system engineering projects are carried out collaboratively. Engineering artifacts stored in model repositories are developed in either offline (checkout-modify-commit) or online (GoogleDoc-style) scenarios. Complex systems frequently integrate models and components developed by different teams, vendors and suppliers. Thus confidentiality and integrity of design artifacts need to be protected by access control policies. 

We propose a technique for secure collaborative modeling where (1) fine-grained access control for models can be defined by model queries, and (2) such access control policies are strictly enforced by bidirectional model transformations. Each collaborator obtains a filtered local copy of the model containing only those model elements which they are allowed to read; write access control policies are checked on the server upon submitting model changes. We illustrate the approach and carry out an initial scalability assessment using a case study of the MONDO EU project.

 Inconsistencies pose a severe issue to overcome in collaborative 
modeling scenarios, especially in settings with dierent 
domains involved. This is due to the signicantly different 
formalisms employed that have overlapping semantic 
domains. A pertinent example are today's mechatronic and 
Cyber-Physical Systems. 
In this paper, we propose an approach for managing inconsistencies 
based on explicitly modeled linguistic and ontological 
properties. We argue that to fully understand the 
reasons of their occurrence and impact on the overall design, 
inconsistencies should be investigated in the context of 
the process they emerge in. For this purpose, we propose 
a language for modeling processes in conjunction with the 
properties of the engineered system. Characteristics of inconsistencies 
are identied in terms of process models and 
properties. A method for optimal selection of management 
techniques is provided. We demonstrate our ideas on a case 
study of a real mechatronic system.

Due to the increase of their complexity, currently engineered systems 
cannot be developed by one individual, but are a product of a 
collaboration between multiple stakeholders who develop the system 
from different domain-specific views. Inconsistencies between 
views, however, hinder collaboration and therefore, must be managed. 
Since the encountered inconsistencies may potentially disappear 
as the natural consequence of a design workflow, tolerating 
them to a given extent may be desirable and can lead to a more efficient 
collaboration. A key to reason about tolerance is the quantification 
of the impact of single inconsistencies on the overall system 
design. 
In this paper we present a quantification model for semantic inconsistencies 
in discrete and continuous systems. We investigate 
characteristic behavioral patterns of inconsistencies based on this 
model and identify the links with various forms of tolerance. Finally, 
we discuss the directions of further expanding the approach 
required for a comprehensive inconsistency tolerance technique.

In case of collaborative modeling, complex systems are developed 
by different stakeholders. To guarantee security, 
access control policies need to be enforced during the collaboration. 
Levels of required confidentiality and integrity 
may vary across modeling artifacts, and even features of a 
single model element. 
Fine-grained rule-based access control was proposed to 
meet the needs of flexible and concise access control. Rulebased 
policies are inherently subject to conflicts between 
the rules; these conflicts should be interpreted in a consistent 
but also predictable way that caters to the preferences 
of the policy engineer. 
We propose a deterministic, parameterizable resolution 
strategy between conflicting rules to calculate effective access 
permissions for each fact in the model. Our approach is 
illustrated using a case study of the MONDO EU project.

Model-Driven Engineering (MDE) technologies aim to support the 
growing complexity of software systems. Models are increasingly 
becoming large and unmanageable, and hence difficult to be understood 
by humans and processed by machines. As a consequence, 
multi-user environments are necessary to enable designers to create 
and refine large models in a collaborative manner enabling the 
engineering, modularization and reuse. 
In this paper, we propose a model-driven approach to represent, 
manage and manipulate models edited in a collaborative manner. In 
particular, we propose to represent the solutions space (i.e, model 
versions) in an intensional manner by adopting a model with uncertainty. 
We define a plan to manage the uncertainty by selecting the 
desired design, to manipulate their collaborative models in manually 
or automatic way, and to exploit a collaborative environment 
for real time multi-user editing. The approach is showed by means 
of a motivating example that involves business models demonstrating 
the advantages of the proposed approach.

The application of the collaboration paradigm in software for teaching has resulted of a great help to increase motivation and participation of students. However, the development of such software is not an easy task. Model-driven development can be a help in this sense, provided that the peculiarities of collaborative learning systems are taken into account. In this paper, we introduce a model-driven development method for collaborative learning systems that gives support to group graphical modeling. The method is based on the use of models by different roles all over the development, and it also considers pedagogical usability factors to guarantee that the generated systems have into account the factors that are typical in the learning field. In order to have a measure of the usefulness of the method, we have applied it to create a series of collaborative modeling tools. These systems and the method have been evaluated by teachers/professors of different fields, who have stated a favorable opinion regarding the proposed approach

Signal-flow diagrams, state-space models and finite-state machines are established modeling concepts in embedded controller software development. However, in the emerging areas of automated driving and human-robot collaboration, the dynamic management of system and environmental objects is mandatory. For this, object-oriented concepts are required in addition to the established modeling concepts. This paper demonstrates the application of signal-flow diagrams together with object-oriented models in Modern C++ for the software development in the area of submicroscopic traffic control. Both the vehicle dynamics and the longitudinal controllers are modeled as signal-flow diagrams and state-space models. Above this control layer, the dynamic creation and removal of individual vehicles and environmental objects are modeled in Modern C++. Together with Boost odeint these models are directly represented on a high abstraction level. Modern C++ is no longer limited to programming but is used as an object-oriented modeling language both for reliable embedded software and simulation environments.

This instalment reports on two talks from the First International Workshop on Collaborative Modeling in MDE (model-driven engineering) and three papers from the 23rd International Conference on Software Analysis, Evolution, and Reengineering. The topics covered include model-driven engineering, forking and developer participation, FLOSS (free/libre and open source software) software projects, and perceptions of release practices.

The application of Model Driven Engineering in an industrial context implies working with large models, hence the need for collaborative modeling. Each developer focuses on a part of the large model and may manipulate it independently. As each part evolves rapidly and concurrently due to changes made by different designers, inconsistencies may occur. This work aims to provide support for dealing with concurrent changes. We propose a metamodel for the description of large models, and we also propose a process for the management of concurrent changes.

Models are primary artifacts in software development which influence the quality of the process and product. While students are trained to use design and development methodologies few teaching approaches address how they should create and evaluate alternative models to find a good solution. This paper suggests to complement common teaching formats with facilitated modeling sessions where small groups of students collaboratively work on a modeling problem. This experience increases the students' understanding of the importance of a shared understanding of the problem and design space. Students should also understand that they can actively shape their collaboration accordingly. A facilitation method for co-located modeling sessions with a multi-touch editor for UML class diagrams is introduced and its effectiveness is investigated in a comparative empirical study. The results suggest that students in facilitated teams not only developed more ideas than self-directed teams but that they also assessed and discussed them more thoroughly to come to a shared solution. Participants in both conditions considered the modeling session as a useful supplement for learning object-oriented modeling.

The design of large-scale complex systems requires their analysis from multiple perspectives, often through the use of requirements models. Diversely located experts with different backgrounds (e.g., safety, security, performance) create such models using different requirements modeling languages. One open challenge is how to align these models such that they cover the same parts of the domain. We propose a technique based on natural language processing (NLP) that analyzes several models included in a project and provides suggestions to modelers based on what is represented in the models that analyze other concerns. Unlike techniques based on meta-model alignment, ours is flexible and language agnostic. We report the results of a focus group session in which experts from the air traffic management domain discussed our approach.

This paper introduces our approach to a real-time synchronous collaborative modeling of software systems using 3D UML in a way similar to shared Google Document online with the aim to reduce the complexity of UML models and to increase work efficiency. In our approach, we decided to visualize the system with 2D UML diagrams on interconnected layers containing components (in class diagrams) or use case scenarios of the system (in sequence or activity diagrams) in 3D space. The goal of our method is to improve user's awareness of other developers in a multi-user workspace, adjust redundant components and visualize the history of user's actions in the UML class diagrams.

 Large-scale model-driven engineering projects are 
carried out collaboratively. Enabling a high degree of concurrency 
is required to make the traditionally rigid development 
processes more agile. The increasing number of collaborators 
increases the probability of introducing conflicts which need to 
be resolved manually by the collaborators. In case of highly 
interdependent models, avoiding conflicts by the use of locks 
can save valuable time. However, traditional locking techniques 
such as fragment-based and object-based strategies may impose 
unnecessary restrictions on editing, which can decrease the 
efficiency of collaboration. 
In this paper, we propose a property-based locking approach 
that generalizes traditional locking techniques, and further allows 
more fine-grained locks in order to restrict modifications only 
when necessary. A lock is considered to be violated if a match 
appears or disappears for its associated graph pattern (formula), 
which captures the property of the model that the upcoming edit 
transaction can be freely executed. An initial evaluation has been 
carried out using a case study of the MONDO EU project.

We are witnessing a rising role of mobile computing and social networks to perform all sorts of tasks. This way, social networks like Twitter or Telegram are used for leisure, and they frequently serve as a discussion media for work-related activities. In this paper, we propose taking advantage of social networks to enable the collaborative creation of models by groups of users. The process is assisted by modelling bots that orchestrate the collaboration and interpret the users' inputs (in natural language) to incrementally build a (meta-)model. The advantages of this modelling approach include ubiquity of use, automation, assistance, natural user interaction, traceability of design decisions, possibility to incorporate coordination protocols, and seamless integration with the user's normal daily usage of social networks. We present a prototype implementation called SOCIO, able to work over several social networks like Twitter and Telegram, and a preliminary evaluation showing promising results.

 In case of collaborative modeling, complex systems are de-veloped by different stakeholders, in offline submissions oronline sessions. To guarantee security, access control poli-cies need to be enforced during the collaboration. Levels ofrequired confidentiality and integrity may vary across mod-eling artifacts, and even features of a single model element.Fine-grained rule-based access control was proposed forflexible and concise policies. Multiple rules in a policy are in-herently subject to conflicts; we have previously shown howto interpret such conflicts in a consistent but also predictableway. However, in online collaboration scenarios, this inter-pretation has to be repeated upon each small change of themodel, thus the computational cost can be prohibitive.Now we present an improvement on the previous resultsallowing for incremental recomputation. Our approach is illustrated using a case study of the MONDO EU project

This paper proposes a new framework that takes advantage of the computing capabilities provided by the Internet of Thing (IoT) paradigm in order to support collaborative applications. It looks at the requirements needed to run a wide range of computing tasks on a set of devices in the user environment with limited computing resources. This approach contributes to building the social dimension of the IoT by enabling the addition of computing resources accessible to the user without harming the other activities for which the IoT devices are intended. The framework mainly includes a model of the computing load, a scheduling mechanism and a handover procedure for transferring tasks between available devices. The experiments show the feasibility of the approach and compare different implementation alternatives.

Model-based systems engineering of critical cyber-physical systems necessitates effective collaboration between different stakeholders while still providing secure protection of intellectual properties of all involved parties. While engineering artifacts are frequently stored in version control repositories, secure access control is limited to file-level strategies in most existing frameworks where models are split into multiple fragments with all-or-nothing permissions, which becomes a scalability and usability bottleneck in case of complex industrial models. 

In this paper, we introduce the MONDO Collaboration Framework, which provides rule-based fine-grained model-level secure access control, property-based locking and automated model merge integrated over existing version control systems such as Subversion (SVN) for storage and version control. Our framework simultaneously supports offline collaboration (asynchronous checkout-modify-commit) on top of off-the-shelf modeling tools and online scenarios (GoogleDocs-style short transactions) scenarios by offering a web-based modeling frontend. 

he adoption of Model-driven Software Engineering (MDSE) to develop complex software systems in application domains like automotive and aerospace is being supported by the maturation of model-driven platforms and tools. However, empirical studies show that a wider adoption of MDSE technologies is still an issue. One limiting factor is related to the limited support for collaborative MDSE. This paper reflects on research directions, challenges, and opportunities of collaborative MDSE.

Context: Collaborative Model-Driven Software Engineering (MDSE) consists of methods and techniques where multiple 
stakeholders manage, collaborate, and are aware of each others’ work on shared models. 
Objective: Collaborative MDSE is attracting research efforts from different areas, resulting in a variegated scientific body of knowledge. This 
study aims at identifying, classifying, and understanding existing collaborative MDSE approaches. 
Method: We designed and conducted a systematic mapping study. Starting from over 3,000 potentially relevant studies, we applied a rigorous 
selection procedure resulting in 106 selected papers, further clustered into 48 primary studies along a time span of 19 years. We rigorously 
defined and applied a classification framework and extracted key information from each selected study for subsequent analysis. 
Results: Our analysis revealed the following main findings: (i) there is a growing scientific interest on collaborative MDSE in the last years; (ii) 
multi-view modeling, validation support, reuse, and branching are more rarely covered with respect to other aspects about collaborative 
MDSE; (iii) different primary studies focus differently on individual dimensions of collaborative MDSE (i.e., model management, collaboration, 
and communication); (iv) most approaches are language-specific, with a prominence of UML-based approaches; (v) few approaches support 
the interplay between synchronous and asynchronous collaboration. 
Conclusion: This study gives a solid foundation for classifying existing and future approaches for collaborative MDSE. Researchers and 
practitioners can use our results for identifying existing research/technical gaps to attack, better scoping their own contributions, or 
understanding existing ones.

Managing inconsistencies between models is a key challenge in 
engineering processes of complex systems. Early detection of inconsistencies 
results in more efficient processes, because it can reduce 
the amount of re-execution of costly engineering activities. 
In this paper, we propose an approach for early inconsistency detection 
in engineering processes. In our approach, the engineering 
process is explicitly modeled, along with the important characteristics 
and constraints of the system, imposed by the requirements 
and system specifications. This information is then used to enact 
the process and augment it with a run-time consistency monitoring 
service. Inconsistencies are expressed as a satisfiability problem of 
the constraints. Early detection of inconsistencies is achieved by 
monitoring the constraints, that is, checking their satisfiability at 
specific points of the process. Our approach is supported with a 
framework which includes a visual process modeling tool, a process 
enactment engine and a state-of-the-art symbolic solver for early 
inconsistency detection.

Traditional, vertical organizational models of software development 
have been challenged by more agile and collaborative structures. 
Recently, this has also been demonstrated in the emergence 
of explicitly horizontalist organizational structures, focused on 
consensus-based decision making. In this paper, we describe the 
principles and processes of these “Consensus-Based Communities” 
(CBCs) and outline the main challenges they face as they try to 
implement “Consensus-Based Software Development” (CBSD). We 
express these as early, high level requirements for a tool supported 
methodology. Based on these, we present and analysis of existing 
tools that shows that no single tool provides complete support for 
consensus-based group decision making. We thus outline directions 
for future research, identifying opportunities for the development 
and deployement of model-based techniques in this emergent field

 To date, CASE tools have generally been built around pre-CASE analysis and design techniques. The paper argues that more benefit would be obtained if analysis and design techniques were 're-engineered' so as to make the best use of the capabilities offered by CASE tools. Techniques such as entity-relationship modelling and data flow diagrams have successfully been transferred to the CASE environment, with significant administrative and clerical benefits. However, these techniques were not necessarily designed with automation in mind, and their CASE implementations have failed to adequately address important aspects of the modelling process, such as communication, collaboration, and the application of past experience. Ways in which these aspects can be supported pro-actively by CASE tools are given, using examples from a prototype CASE tool.<>

Computer Aided Software Engineering (CASE) environments have spread at a lower pace than expected. One reason for this is the immaturity of existing environments in supporting development in-the-large and by-many and their inability to address the varying needs of the software developers. In this paper we report on the development of a next generation CASE environment called MetaEdit+. The environment seeks to overcome all the above deficiencies, but in particular pays attention to catering for the varying needs of the software developers. MetaEdit+ is a multi-method, multi-tool platform for both CASE and Computer Aided Method Engineering (CAME). As a CASE tool it establishes a versatile and powerful multi-tool environment which enables flexible creation, maintenance, manipulation, retrieval and representation of design information among multiple developers. As a CAME environment it offers an easy-to-use yet powerful environment for method specification, integration, management and re-use. The paper explains the motivation for developing MetaEdit+, its design goals and philosophy and discusses the functionality of the CAME tools.
Rosetta is a tool that supports the creation of object-oriented design documents, and which automatically checks the conformance of Java implementations to those designs. Rosetta is based on a novel World Wide Web (WWW) architecture, supporting collaborative use with heterogeneous development tools under a coevolutionary development process. Rosetta has been used extensively in our research group and in teaching at the first-year university level, and is currently undergoing industrial field trials. Rosetta has proved successful, but its deployment over the WWW has not proved as transparent to users as we had hoped

We investigate the use of XML as an open, cross-platform, and extendable file format for the description of hierarchical simulation models, including their graphical representations, initial model conditions, and model execution algorithms. We present HiMASS-x, an XML-centered suite of software applications that allows for cross-platform, distributed modeling and execution of hierarchical, component-based, and reusable simulation models.

The globalization of companies and business, and the improvements in communication and 
computing have lead to the need of new models of collaborative work. Real-time 
collaborative editing systems are included in the field of Computer Supported Collaborative 
Work (CSCW) systems, which allow users to view and design the same document 
simultaneously from geographically dispersed sites connected by networks. 
Distributed Software Engineering (DSE) requires technical knowledge that spans 
geographical and organizational boundaries. In a distributed environment, developers are 
dispersed across different sites and even countries. Even thought major contributions have 
been lately introduced to enable CSCW applications on the Internet to support global 
collaboration, the area of DSE requires further research. 
There are three inconsistency problems that arise in Collaborative Editing Systems: 
divergence, causal ordering violation and user intentions violation. Divergence can be solved 
serializing the operations at all sites, causality violation can be solved with a causal ordering 
communication protocol. However user intention violation solution is dependent on 
application semantics. 
There are few group support framework specialized in DSE, and distributed software 
modeling. However, we are not aware of any Collaborative Software Modeling Framework 
using Consistency Maintenance mechanisms where the user intentions are preserved. Current 
distributed software modeling frameworks address concurrency with traditional methods as 
locking, turn taking, serialization, etc. 
The algorithms and schemas presented in this work have been implemented in the 
DArgoUML prototype system. DArgoUML is a Distributed version of ArgoUML, which 
includes a Flexible Consistency Maintenance Framework based on Software Modeling 
Knowledge. The Framework can be considered Flexible as it allows the system to maintain 
temporal inconsistencies, as the shared document will merge to a consistent version. Some 
algorithms have been devised to detect different types of conflicts based on the different level 
of inconsistency they generate. Techniques have been presented to address each specific 
conflict or level of Inconsistency. Besides a mechanism for conflict group awareness is 
proposed, where users are aware of other user intentions when concurrent operations do 
conflict.

The distributed development of software is increasingly widespread, driven by the globalization of companies and business and enabled by the improvements in communication and computing (Grinter et al., 1999). The distributed development of software introduces new aspects of cooperative work in which a greater emphasis is placed upon technological support of the software development process. Software development activities deal with the complexity by constructing and validating models of the application domain. Models are important artifacts used for communication within the organizations, developers and stakeholders as well. Constructing correct, complete, consistent, and unambiguous models is a tough task that needs concurrent participation of multiple users possibly geographically dispersed. Distribution of software development through meetings is harder to control. Distributed meetings play typically a critical role in teamwork. During which large amount of implicit knowledge is exchanged through negotiation and conflicts resolution. Hence, efforts in supporting distributed development should focus on better supporting distributed meetings (Boulila, 2003)). This research focuses on the specific problem of distributed brainstorming and the construction of UML models of software through successive distributed teamwork meetings. In Particular we investigate the issues we considered in designing a unified framework based on CSCW concepts and software engineering to support concurrent object-oriented software analysis and design phases. We present an activity-based model and a prototype called GroupUML based on the framework

Distributed collaboration is becoming increasingly important
also in software development. Combined with an increasing
interest in experimental and agile approaches to
software development, this poses challenges to tool support
for software development. Specifically, tool support
is needed for flexible, distributed collaboration. We introduce
the Distributed Knight tool that provides flexible and
lightweight support for distributed collaboration in objectoriented
modelling. The Distributed Knight implementation
builds crucially on the type-based publish/subscribe
distributed communication paradigm, which provides an
effective and natural abstraction for developing distributed
collaboration tools.

Domain experts are essential for successful software development, but these experts may not recognize their ideas when abstracted into Unified Modeling Language (UML) or ontologies. We describe a Web-based tool for modeling that creates and manipulates a simple data model without representing it in UML, while promoting collaboration and the use of examples to compare and validate the model. The open-source tool, "NEMo," is a by-product of a team effort to invent and refine a complex data model and library of examples.

In the world of computer aided process modelling, the potential of web-based technologies has still not been fully exploited. In particular in the scope of collaborative model development, the use of those technologies helps to solve some common problems. In this paper a new modelling environment based on a combination of MathML, XML and JAVA™ is presented that especially addresses the problems faced when it comes to sharing models as well for documentation as for execution purposes. The application is currently used in e-learning scenarios, in which students learn to model distillation column systems with the only use of their web-browser by drag and dropping human readable equations into subsystems of a given process.

Most of software developers nowadays use objectoriented
method, and Unified Modeling Language
(UML) is the most popular modeling language used.
There are a number of tools for modeling software
application in UML notations, but the majority of
those tools do not support multi-user mode, where online
team collaboration is not supported.
In this paper, we developed a multi-user UML
Editor called WEKMU. This system allows a number
of developers to work together at the client site on the
same model and the server keep them updated in real
time of any change made by others. This feature is
implemented using .Net Remoting feature provided in
.NET framework. Beside the view synchronization,
this system also provide another feature, that is, Undo
function, which enables user to return to the previous
state of the model

In global software projects, informal communication across sites is severely hampered, making it difficult to disseminate implicit knowledge. Participants have a partial view of the overall organization, do not have access to the complete rationale behind decisions, and when changes arise, participants from other sites are surprised. Consequently, issues that could be clarified almost immediately require days until the relevant stakeholders are identified, the issues are understood, and a resolution is agreed upon. We focus on the specific problem of externalizing issues with their context, stakeholders, and organizational roles in distributed settings. The challenge is to capture sufficient knowledge as a side effect of development, while structuring it for long-term use. We describe Sysiphus, a distributed environment providing a uniform framework for system models, collaboration artifacts, and organizational models. Sysiphus encourages participants to make communication and issues explicit in the context of system models and become aware of relevant stakeholders

Business process (BP) change projects often involve the redesign of organizational information systems (IS). To successfully align the design of processes and IS, collaboration between BP and IS analysts is required. This is usually done with the aid of IS and BP models. This paper argues that such models often fail to address the concerns and information needs of both groups because they are not created in a collaborative way. Thus, it proposes a modeling framework that maps the constructs used in IS models to those used in BP models so that both groups consider their organizational views in their designs. The framework was applied in a business process change project for a multinational pharmaceuticals organization. The results of this case study indicated that: a) sharing the information between BP and IS models contributed to foster collaboration between analysts in both domains; and b) aiding the collaboration between analysts produced more integrated solutions.

Real-time Collaborative Software Engineering (CSE) tools have many perceived benefits including increased programmer communication and faster resolution of development conflicts. Demand and support for such tools is rapidly increasing, but the cost of developing such tools is prohibitively expensive. We have developed an architecture, CAISE, to support the rapid development of CSE tools. It is envisaged that the architecture will facilitate the creation of a range of tools, allowing the perceived benefits of collaboration to be fully realised. In this paper, we focus on the development of CSE tools within the CAISE architecture. We present examples to illustrate how such tools are constructed and how they support real-time multi-user collaborative software development. We also address issues related to the number of collaborators and discuss performance aspects.

Modeling is commonly used in the process of software development. UML (Unified Modeling Language) is a standard software modeling language and has been widely adopted for software analysis and design. As software systems are getting larger and more complex nowadays, software modeling using UML often requires collective and collaborative efforts from multiple software designers. In contrast, most of today's software modeling applications are still single-user-oriented and do not offer much help to coordinate interaction and collaboration among team members. In this paper, we will present the technical challenges and solutions in providing advanced collaboration capabilities and transparently integrating them into mainstream software modeling applications to effectively facilitate collaboration among geographically dispersed software designers. The work has been tested and demonstrated by the design of CoRSA (Collaborative Rational Software Architect) - an experimental collaborative software modeling prototype based on RSA, one of the most widely used commercial software modeling applications in the market

Building a collaborative application from scratch is a hard task. In the last decade many advances have been made to help the developers to construct collaborative applications, however little effort has been made to extend existing single-user applications to support real-time collaboration. This work presents a mapping from the main components of an existing single-user model-view-controller based application to multiuser real-time components of the collaborative application. The mapping allows reuse of existing single-user components by facilitating the construction of collaborative applications. This paper describes the mapping, the extension of an existing single-user application and discusses an experiment of the prototype application where the mapping was applied

We present COLLECT-UML, a constraint-based intelligent tutoring system (ITS) that teaches object-oriented analysis and design using Unified Modelling Language (UML). UML is easily the most popular object-oriented modelling technology in current practice. While teaching how to design UML class diagrams, COLLECT-UML also provides feedback on collaboration. Being one of constraint-based tutors, COLLECT-UML represents the domain knowledge as a set of constraints. However, it is the first system to also represent a higher-level skill such as collaboration using the same formalism. We started by developing a single-user ITS that supported students in learning UML class diagrams. The system was evaluated in a real classroom, and the results showed that students’ performance increased significantly. In this paper, we present our experiences in extending the system to provide support for collaboration as well as domain-level support. We describe the architecture, interface and support for collaboration in the new, multi-user system. The effectiveness of the system has been evaluated in two studies. In addition to improved problem-solving skills, the participants both acquired declarative knowledge about effective collaboration and did collaborate more effectively. The participants have enjoyed working with the system and found it a valuable asset to their learning.

One of the major concerns in the processes which involve human analysts is the existence of uncertainty/inconsistency. In this paper, we propose a model based on belief theory that attempts to capture the degree of analysts' uncertainty towards their expressed specifications and employs these information to create an integrated unique model.

 There have been various proposals for the formalization ofappropriate viewpoint-based frameworks. The model that we intend to devise attempts to provide a basis for conceptual model integration particularly with the existence of partial ignorance and uncertainty. The model will try to formalize the degree of uncertainty present in experts' expressions, and proposes tools for conceptual model integration and formal consensus building between the involved viewpoints.

Software development teams are composed of people with different knowledge and skills, who contribute to a project from often widely dispersed locations. Software development in geographically distributed environments creates software engineering challenges due to the interaction among members of distributed teams and the management of consistency and concurrency among project artefacts. In this paper, we propose Synchronous collaborative modelling Tool Enhanced with VErsioning management (STEVE) a collaborative tool supporting distributed Unified Modelling Language (UML) modelling of software systems. The tool provides a communication infrastructure enabling the concurrent editing of the same UML diagram at the same time by distributed developers. Complex UML diagrams are decomposed and managed in a fine-grained hierarchy of sub-artefacts, thus providing change and configuration management functionalities for both the diagram and the graphical objects. Thus, software predefined diagram components can be consistently reused and shared across different diagrams of a given project.

Software development teams are composed of people with different knowledge and skills, who contribute to a project from often widely dispersed locations. Software development in geographically distributed environments creates software engineering challenges due to the interaction among members of distributed teams and the management of consistency and concurrency among project artefacts. In this paper, we propose Synchronous collaborative modelling Tool Enhanced with VErsioning management (STEVE) a collaborative tool supporting distributed Unified Modelling Language (UML) modelling of software systems. The tool provides a communication infrastructure enabling the concurrent editing of the same UML diagram at the same time by distributed developers. Complex UML diagrams are decomposed and managed in a fine-grained hierarchy of sub-artefacts, thus providing change and configuration management functionalities for both the diagram and the graphical objects. Thus, software predefined diagram components can be consistently reused and shared across different diagrams of a given project.

Model-driven development is becoming a reality. Different CASE tool vendors support this paradigm, allowing developers to define high-level models and helping to transform them into refined models or source code. However, current software configuration management tools use a file-based data model that is barely sufficient to manipulate source code. This file-based data model is not adequate to provide versioning capabilities for software modeling environments, which are strongly focused on analysis and architectural design artifacts. The existence of a versioned repository of high-level artifacts integrated with a customized change control process could help in the development and maintenance of such model-based systems. In this work, we introduce Odyssey-SCM, an integrated software configuration management infrastructure for UML models. This infrastructure is composed of a flexible version control system for fine-grained UML model elements, named Odyssey-VCS, and two complementary components: a customizable change control system tightly integrated with the version control system, and a traceability link detection tool that uses data mining to discover change traces among versioned UML model elements and provides the rationale of change traces, automatically collected from the integrated software configuration management infrastructure.

Collaborative Editing Systems require mechanisms of 
control in order to make the collaboration more effective. The 
synchronous collaboration allows the notion of simultaneity; 
however, it demands more adequate perception elements. In the 
collaborative edition of UML diagrams where dependencies 
between their modeling elements do exist, it is necessary to apply 
a mechanism of control to support the edition of consistent 
models. In this work, we present a multi-level locking mechanism 
that automatically manages locks in the modeling elements of 
UML diagrams during a collaborative session. This paper also 
describes a controlled experiment conducted to study the use of 
the multi-level locking mechanism during collaborative modeling 
sessions, and the observations from the empirical data collected.

Specification by models plays a decisive role, during the development process of complex systems. The division and concurrency of labor in teams is a further characteristic of such development. Therefore an efficient configuration and variant management of resulting documents is essential. In practice, a lot of established configuration management systems like CVS and Subversion are available which provide a text based merge. Unfortunately these systems are inappropriate for the management of models because they ignore the syntactic and semantic structure which is specified by the associated meta-models. Especially during the merge of model versions the mentioned systems fails at the generation of a meta-model consistent model. In this paper a proposal is presented which is enabled to merge model versions in a model based, collaborative development process. Furthermore meta-model independent methods for consistent-receiving model merging are explained.

Many research approaches aiming at control and
mitigation of risks in global software development
(GSD) are based on tool support. Following a rigorous
research approach these tools need to be evaluated
and therefore implemented. Existing tools lack support
for research requirements. As a consequence
researchers often have to build their own solution from
scratch. This is a time consuming task associated with
the risk of failure. This paper proposes a platform
called unicase. The goal of unicase is to support
researchers in building tools for evaluation of research
approaches in GSD. Unicase is based on Eclipse
technology and helps the researcher in the evaluation
of tool-supported approaches to GSD including
approaches to risk management.

Collaborative modeling systems are useful and promising tools for many tasks. However, they are difficult to build and are domain-specific. In response to this situation, we propose a model-driven process for the development of this kind of systems. This process is based on the use of some ontologies which characterize the concepts used in a software architecture to support collaborative modeling systems. These ontologies, from which the meta-models used in the generation process are derived, are explained in detail. In order to emphasize the utility of the proposal, an example of how the concepts in the ontologies are instantiated in a specific system, SPACE-DESIGN, is shown. It is also explained how by means of this approach it is possible to obtain reconfigurable systems, even at a level of application domain, by means of the use of model specifications and transformations.

 Developers in modern and geographically distributed software companies need to collaborate because most of them are part of big development teams involved in large projects. CASE tools are commonly used to model software applications. However, most of them are not really prepared to support collaboration in the sense that they do not provide developers with a real collaborative environment. In this paper, we show the design and the implementation of a cooperative CASE tool called CE4WEB to support the edition of UML diagrams using the Service Oriented Architecture (SOA) paradigm. The tool described in this paper demonstrates the successful use of groupware tools and Software Engineering techniques. An evaluation method is also presented to show the validity of the proposal.

This work presents an approach for realizing Model-Driven software engineering in the distributed and multi-developers context. It particularly focuses on the scalability problems in a complex software project involving a large set of inter-connected models: (1) how to manipulate large data volume with limited computing resources, and (2) how to maintain consistency of inter-model links in a large model set, facing to concurrent model updates. As a solution, we propose the scalable copy-modify-merge mechanism, which allows each developer to copy only a model subset from the entire model set, to manipulate this subset locally, and to merge it back to the repository. This mechanism ensures the global consistency of the model set, particularly against dangling links. Our approach is generic: it is applicable to all model types (UML and Domain-Specific Models). Also, it offers interoperability with existing, heterogeneous CASE tools. Its prototype implementation in the ModelBus environment is now available on the Eclipse project "MDDi".

Today's software development projects have a huge demand for a comprehensive and integrated support in the team-based development of models. Since they typically rely on file-based version control systems such as CVS and assume that working with models does not differ from working with code, current solutions solve only one part of the problem. This paper addresses this gap between what is needed in practice and what is provided by existing tools. Based on the collaboration platform Jazz, a model repository prototype is developed that provides adequate versioning support and leverages the collaboration mechanisms provided by Jazz for concurrent model development. Especially the integration of concurrently developed models turned out to be a complex and collaborative task. The results of this investigation are integrated into the prototype yielding a model repository that supports team-based development to a considerable extent.

For the versioning of code a pantheon of version control system (VCS) solutions
has been realized and is successfully applied in practice. Nevertheless, when it comes to
merging two different versions of one artifact, the resolution of conflicts poses a major challenge.
In standard systems, the developer who performs the later commit is sole in charge
of this often time-consuming, error-prone task. This commit carries the inherent danger of
losing the modifications of the other developer. Recently, collaborative merge approaches
for code versioning systems have been proposed to minimize this risk. In this paper we
propose to apply similar techniques in the context of model versioning where the challenge
of merging two versions is even more formidable due to their graph-structure and their rich
semantics. In particular, modeling is used in the early phases of the software development,
where a collaborative merge is beneficial to elaborate a consolidated understanding of a
domain.

Software design activities require rich communication channels where developers can exchange information in multiple ways. It is well established that geographic distribution impacts negatively on the effectiveness of design meetings. In this paper, we present a tool for supporting virtual software design meetings. The features of the tool address four fundamental challenges identified from the literature: (1) information sharing, conflict resolution and development of consensus among geographically distributed designers, (2) availability of sufficient and organizable drawing surfaces for graphical representations, (3) developing shared understanding and managing focus during the discussion and (4) appropriate capturing and storing of all design-relevant information.

Increasingly, models are becoming first class core assets, 
and model-driven engineering requires novel techniques, 
tools, and practices to face the globalization of software 
development in the (always more) pervasive IT world. 
This paper proposes a framework for synchronous and 
asynchronous concurrent and collaborative modeling. Synchronous 
collaborative modeling offers services for sharing 
the modeling space, models, documentation, and configuration, 
while asynchronous collaborative modeling offers services 
for supporting merging of models modified and edited 
separately by different software engineers. Our approach is 
based on the observation that it is in general more convenient 
to store differences between subsequent versions of a 
system than the whole models of each stage.

In this paper, we present a model-driven approach to construction of web-based collaborative environments that could be efficiently tailored to modeling and simulation needs of an arbitrary number of M&S application domains. To achieve broad applicability, our approach is based on general concepts and taxonomies in fields of Modeling and Simulation, Distributed Systems, and Collaborative Software. Such stable concepts constitute the collaborative Modeling and online Simulation (cMoS) framework. cMoS provides a general basis for a family of Web-Based M&S applications. Specific M&S applications are supported through customization of the variation points in cMoS. To enable efficient tailoring to specific applications during the operation phase, the variation points are not implicitly hardcoded as traditionally, but are explicitly expressed as models. The use of the resulting models is still limited due to a high barrier of their implementation. This barrier is sought to be amended by model-driven engineering (MDE): models of the variation points are computerized and their implementation is automatically generated. The end result is a model-driven and mostly programming free cMoS system adaptable to new M&S applications through abstract modeling of the variation points. The proposed framework and model-driven construction of a cMoS system are demonstrated. The system customization has been verified for a number of domains: Data Flow Diagrams (DFD), Discrete Event System Specification (DEVS), Process Interaction (PI) and Dynamic Traffic Routing (DTR). A demonstration of the latter is included in this paper. Generic cMoS functionality, such as modeling, collaborative sharing of conceptual models, online simulation and management of shared simulation resources is demonstrated as well.

Traditional CASE tools are desktop-based, so they do not support online software collaboration. That is, they do not allow members of software project teams who are geographically distributed to collaborate and work together on software projects. This constrains software houses from tapping into global talent pools that can help reduce software costs and acquire needed expertise. Online CASE tools can help solve this problem. This paper presents a prototype Online CASE tool that supports collaborative software system modeling by enabling team members who are geographically distributed to work together. Software modelers specify their software systems using a set of triplets for each UML diagram and the tool uses the triplets to automatically render high-quality SVG graphics, thus eliminating the need for manual diagramming. The current version supports three UML diagrams: Class, Use case and Sequence. The tool is implemented using Active Server Page (the Microsoft's server-side scripting engine) and VBScript (the Microsoft's Visual Basic Scripting Language) and can be accessed on the Web.

We have used a design science approach to study the collaborative creation of conceptual models. We have designed a collaborative modeling architecture based on business needs and applicable knowledge from theory and empirical findings from a modeling study using conventional modeling. A tool for this architecture was then developed and used as an instrument to confirm the practical relevance of the approach and the validity of the employed theory.

Constraint maintenance plays an important role in keeping the integrity and validity of UML models in embedded software design. While constraint maintenance capabilities are reasonably adequate in existing UML modeling applications, little work has been done to address the distributed constraint maintenance issue in multi-user collaborative modeling environments. The nature of the issue is to maintain constraint consistently across distributed sites in a collaborative modeling environment in the face of concurrency. In this paper, we propose a novel solution to this issue, which can retain the effects of all concurrent modeling operations even though they may cause constraint violations. We further contribute a distributed constraint maintenance framework in which the solution is encapsulated as a generic engine that can be mounted in a variety of single-user UML modeling applications to support collaborative UML modeling and distributed constraint maintenance in embedded software design processes. This framework has been implemented in a prototype distributed collaborative UML modeling application CoRSA.

UML diagrams have become the de-facto standard for the visual
modeling of software systems. The creation and discussion of these
diagrams is a critical factor impacting the quality of the artifacts under
development. Traditionally, facilitating the collaboration of globally
distributed team members with heterogeneous system environments has
been a costly and time-consuming endeavor. This paper aims to advance
the state-of-the-art of model-based development by providing a collaboration
environment, which supports the synchronous distributed creation
and manipulation of UML diagrams and also lowers the technical entry
barriers for participating in the modeling process. We present a prototypical
implementation of a collaborative editor for synchronous lightweight
modeling (SLIM). Applying innovative techniques, which only rely on
functionality natively supported by modern web browsers, technical issues
impeding clients to be integrated into the collaborative environment
are avoided and ad hoc collaboration is facilitated.

With the advancement of network technology and globalization of business, distributed software development has become in common. Along with this trend, distributed synchronous collaborative modeling support systems have been proposed. This study points out two issues traditional systems have; they donpsilat relate conversations with model diagrams, and they canpsilat replay histories of modeling by associating contents of conversations with elements of model diagrams. The authors developed a distributed synchronous collaborative modeling support system for UML diagrams, called Libra-on-Chat, which solved the issues. As the results of an experiment, the system allowed participants to focus on elements in a diagram under discussion. It also enabled developers to grasp design rationale in review.

Large, multinational software development organizations face a number of issues in supporting software design and modeling by geographically distributed architects. To address these issues, we present CoDesign, an extensible, collaborative, event-based software modeling framework developed in a distributed, collaborative setting by our two organizations. CoDesign's core capabilities include real-time model synchronization between geographically distributed architects, as well as detection and resolution of a range of modeling conflicts via several off-the-shelf conflict detection engines.

Model driven engineering is one answer to 
increasing demands on software development and 
maintenance. Today’s software systems are often 
large, complex but also safety-critical and should be 
highly adaptable in life cycle. The efficient 
development of large and complex software systems 
needs a high degree of collaboration in the design and 
specification phases. Well-defined, (graphical) 
modeling languages provide therefore a matter of 
communication for software engineers. Further the 
distribution of development locations and the 
concurrency of work are typical in global software 
engineering projects. This kind of collaborative 
modeling needs reliable integration mechanisms for 
co-evolved models. However the syntactic and 
semantic correct (consistent) integration of concurrent 
evolved models is not satisfactorily supported by 
current tools. Especially the inconsistency resolution 
for merged architecture and design models is a 
communication-intensive, collaborative task. This 
paper proposes a technology support of automatic 
inconsistency analysis and visualization for distributed 
modelers whose synchronize their parallel work.

 Modeling is an important aspect of information system development, allowing for abstract descriptions of systems and processes. Therefore, models are often characterized as communication artifacts between different stakeholders in a development process. However, modeling as such has turned out to be a specialist activity, requiring skills in arcane modeling languages and complex tools. 

In this paper, we suggest and present an approach for collaborative, Wiki-based modeling of process models and UML (class-)diagrams. While other web-based "lightweight" modeling tools are available, our approach consequently follows the Wiki-paradigm and allows us to semantically process the modeled information building upon Semantic MediaWiki.

The Model Driven Development (MDD) paradigm is gaining acceptance due to its ability to raise the level of abstraction and automation in the construction of software. However, current tools lack of some capabilities that are essential for MDD collaborative work such as version control. Because of this, large-sized projects that need teamwork development are hard to tackle. A software repository is a key component in an infrastructure that supports collaborative work; it provides version control and other advanced features such as distributed development. Several model repository tools are currently available but they are mainly focused in providing model persistence. Several approaches for supporting version control have been proposed but they exhibit some significant limitations as they have been designed to support model management, giving poor or no support for metamodel development. 

We propose a repository that is capable of uniformly managing metamodels and models through all their development processes. Incremental and collaborative development of (meta)models is supported using a version control system that allows developers to examine the changes applied to the (meta)models. We have devised an architecture to register changes between versions that is an alternative to the traditional delta-based scheme in order to improve performance. Such architecture is explained from the database, driver and version control perspectives.

This contribution presents GEMSjax – a web-based metamodeling
tool for the collaborative development of domain specific languages.
By making use of modern Web 2.0 technologies like Ajax and
REST services, the tool allows for simultaneous web browser-based creation/editing
of metamodels and model instances, as well as secure remote
model access via REST, which enables remote model modification
over a simple HTTP-based interface. This paper describes the
complex technical challenges we faced and solutions we produced to provide
browser-based synchronous model editing. It further explains on
the XACML-based access control mechanisms to provide secure remote
access to models and model elements. Additionally, we highlight the usefulness
of our approach by describing its application in a realistic usage
scenario.

Models are important artifacts in the software development life-cycle and are often the result of a collaborative activity of multiple developers. When multiple developers modify the same model, conflicts can occur and need to be resolved by merging. Existing approaches for model merging require developers to solve all conflicts before committing. The later a developer commits the higher the probability for even more conflicts. This forces the developers to solve every conflict as soon as possible and without consulting the other developer. However, we claim that developers often need to discuss their choice of conflict resolution with another developer in case of a complex conflict, since a conflict also expresses differences in opinion about the model. In this paper we propose to allow developers to postpone a decision of a modeling conflict. We present an approach to make conflicts part of the model and represent them as first-level entities based on issue modeling from the field of Rationale Management. This facilitates the possibility for collaborative conflict resolution and merging. Furthermore, it allows for a complete batch merge instead of interactive merging, where all conflicts are added to the model and then resolved later. To substantiate our claim that developers favor to discuss complex conflicts we conducted a case study.

Collaborative techniques for business process design are generally supported by groupware tools that allow process actors to interact collecting their knowledge about the activities performed. Despite success reports, challenges are still observed due to the complexity of this task. We propose to gather benefits of interviews, collaboration and visual methods in eliciting business processes in order to deal with problems identified in literature. We present an approach based on a collaborative mobile application which analysts should use while interviewing process stakeholders. The information is collected through a simple BPMN diagram through which they exchange information and build parts of the models.

Today the distribution of development locations, the co-evolution of models and the concurrency of work are typical for collaborative modeling in software projects. Software engineering teams demand modeling techniques at several abstraction levels to manage the complexity of software descriptions. Besides, software models are applied more and more for the specification of safety-critical systems. Hence software models take a hybrid role - as a matter of team communication and precise specification for refinement. Both aspects are considered in the research area of Model Driven Engineering (MDE). It provides methods to deal with formal specified meta-models of graphical (intuitive) modeling languages. Unfortunately the syntactical a semantically correct (consistent) integration of concurrently evolved models is poorly considered by the most MDE approaches. Especially the detection and analyzing of model merge conflicts can be automatized by using logical inference techniques. Therefore this paper proposes an approach based on description logics.

Development, maintenance and operation of complex
IT–systems, involving various stakeholders are challenging
tasks. Managing such IT–systems with model–based
approaches can help to cope with this complexity. As IT–
systems are changing during their lifetime, as do the models
describing certain aspects of such systems. Document and
model versioning repositories are the preferred infrastructure
to maintain the documents and models, reflecting the evolution
of the IT–system. However, there are more complex requirements
to model versioning compared to classical source code
or document versioning: Depending on the types of models
different modelling tools may be employed and must interface
to the repository. The consistency between models must be
ensured, and finally, since various stakeholders are involved,
changes must be propagated between models. In this paper, we
analyse these requirements and present the basic architectural
concepts for a Living Models infrastructure that supports the
evolution of models.

These last five years have seen the generalization of model usage, as their adequation to the design of complex systems began to be more and more understood, and researched. Modeling using specifically tailored models is now common practice. Modeling tools, especially in Eclipse, matured a lot and they are fit for a lot of different contexts and requirements; from the French unemployment office to the NASA. This rising success is not complete yet though, and collaborative modeling is barely taking off, holding back wider adoption. 

Let's go back all the way to 2006. At that time, during the Eclipse Summit Europe conference, the community at large voices its concerns: there is no available open-source component aiming at comparing and merging models; while such a tool is critical to the success of all modeling-related technologies. Models were becoming more and more central in the development process, their importance rising to the level of the source code's... and yet there was no tool designed to allow teams to work on models collaboratively. It is in light of this observation that we decided to start the EMF Compare project. 

The challenges were then to be able to compare any kind of model, be it specific or based on a standard, with a good scalability and accuracy of the matching algorithms; and have this comparison integrated with the many different version control management systems available. At that time, there was but a few commercial tools barely starting to provide basic support for collaborative work on models; and the community recognized our commitment in providing a reliable open-source stack. 

Five years later, both technologies and practices have dramatically evolved. What seemed obvious in 2006 turned out to be but one option among many others, and as time went by we have seen that the original challenges only were a subset of what we were really going to face. 

This talk will start with the story, from the perspective of an Eclipse commiter and Obeo insider, of what happened during those five past years: how practices and requirements evolved, how our component adapted to these changes and has been used in practice, how we tackled collaborative modeling needs together with our adopters... 

I will then move on to what is going on right now from the Eclipse side; focusing on how EMF Compare, along with -among others- Mylyn and CDO, are playing a major role in settling the basis of a sound modeling platform supporting collaboration.

Semantic annotations are a way to provide a precise meaning to business process elements, which supports reasoning on properties and constraints. Among the obstacles preventing widespread adoption of semantic annotations are the technical skills required to manage the formalization of the semantics and the difficulty of reconciling the different viewpoints of different analysts working on the same business process. In this paper, we support business analysts in the collaborative annotation of business processes by means of a tool inspired to the Wiki pages model. Using this tool, analysts can concurrently work on process elements, ontology concepts, process annotation or constraint specification. The underlying formalism is not exposed in the Wiki pages, where natural language templates are used. 

Domain Specific Modeling (DSM) tools have matured and became powerful over the past few years and are now used more frequently to model complex systems. Consequently, the demand for model management and collaboration among DSM tools becomes more important. In collaborative modeling, domain specific models are mostly edited and elaborated concurrently by different semi-autonomous users. Hence, there is a need for reconciliating these parallely evolved models so as to seamlessly work together. CSCW community proposes tools or techniques to ensure collaboration among general purpose modeling languages, but they do not give functionalities to support reconciliation and merging for asynchronous modification. In addition, management of communications among members of collaborative group could also help to facilitate collaboration in the group. In this paper, we propose a communication framework to manage exchanges of concurrently edited DSM models among users. Besides, we present a reconciliation framework to merge concurrently evolved DSM models.

Development of model-based Electric/Electronic (E/E) architecture in the automotive industry poses a high demand on the data management of models. The collaborative modeling work involves stakeholders dispersed across various locations and departments, while the models themselves are often extremely large-scaled. In this paper, we present our approach addressing the model data management issue for both asynchronous and synchronous modeling. Compared to asynchronous modeling, which is based on the lock/commit mechanism for cross-department collaboration, synchronous modeling is targeted to assist quick and efficient interaction among small groups of members. We use the delta model for versioning in the database as well as for the synchronous modeling functionality. Furthermore, other versatile uses of the delta model such as the cumulative delta model and the reverse delta model are also introduced.