 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 wont scale up. Roundtrip for maintenance, tool 
interoperability, and team collaboration are far from industry needs. 
But theres a light on the horizon with a new generation of MDE tools. 
In this issues 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 
systems 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.

raditional, vertical organizational models of soft?ware 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