Complex software systems demand for both effective and specific approaches to keep under control the increasing software functionalities, heterogeneity, team sizes and geographical distribution of the developers. The growing maturity of Model-Driven Engineering (MDE) [27] technologies is leading industry to take advantage of their benefits in terms of productivity, quality and reuse [22,7]. However, applying MDE in this setting requires research effort in order to achieve industry-scale tools.
As observed in [19], scalability is a critical concern for the industrial adoption of MDE. Large-scale tools have to cope with different topics; among many, creating and refining large models in a collaborative manner, working with model fragments obtained from partitions of large models, enabling the engineering, modularization and reuse of models and fragments, having transformation tools to cope with versioned models, and having infrastructures to storage and manage large models.
When projects and teams are large, modeling activity requires designers to divide their models in smaller partitions and work on them in a collaborative manner. In a typical scenario, multiple developers work on the same model in multiple branches, where each developer (or sub team) may initialize a repository branch and make modifications to this model; thus, versions grow rapidly. Traditional text based version control systems (e.g., SVN, Git) allow programmers to write code by locking a portion of work or to edit code collaboratively; in this case, programmers tend to frequently perform merge operations involving different versions of the same textual artifacts. Conversely, in software design, that is a complex and non-linear process, decisions are made at different development stages and obtaining the merged version early could not be desired. In fact, sometimes designers have not the complete, consistent and accurate information required to make a decision at design-time (or when the conflict occurs), that can be regarded as a source of uncertainty [24]. For instance, they could perform some analysis or wait for different view models before to be able to choose the best strategy. In these cases, they could be interested in postponing the version merging and continuing to operate on their model versions separately. In this paper, we propose a model-driven approach to represent and manage models edited in a collaborative manner by leveraging uncertainty to a first-class status. To this end, we propose a metamodel-independent approach to represent the solutions space (i.e, multiple versions) in a compact and 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 and handling of models. The technique is applied to a running example that involves business process models in the domain of Public Administrations (PAs) demonstrating the advantages of the proposed approach.
Structure of the paper. The paper is organized as follows. Section 2 sets the context of the paper through a motivating example that is used throughout the paper to demonstrate the approach. In Sect. 3 the model-driven approach to represent and manage collaborative models with uncertainty is presented and related challenges are discussed. In Sect. 4, related works are presented and finally Sect. 5 draws some conclusions.
As aforesaid, the management of large models raises not obvious issues mainly related to the collaborative use of models. In order to illustrate our proposal, we consider a motivating example that takes place in the public administrations (PAs) sector.
In modern society, the role of PAs is undergoing a transformation from controller to proactive service provider. In most cases, the provisioning of services is a collaborative activity shared among different, possibly many, organizations that are in general quite interrelated. In order to provide efficient services to citizens and companies, public servants have to manage extremely complex processes and a large amount of information due to changes in law and regulations, societal globalization and fast technology evolution.
In this context, the Learn PAd1 project [8] aims at developing a social, collaborative and holistic e-learning platform that enables process-driven learning and improvement of the process on a userfriendly basis of wiki pages enriched with additional documentation for a clearer understanding of the process together with guidance based on formalized models. The specification of business processes is usually done by means of standard notations like BPMN 2.0 [23] and concerns a sequence of activities that the administration executes in order to produce a service for the end user. Typically, it starts with i) receiving of some input (i.e. request, documentation), then ii) performing activities that add value (i.e., checks) using resources (i.e., humans, structures), and finally iii) producing an output.
For instance, Fig. 1 depicts a sub-process of a standard process, called Titolo Unico, where a citizen makes a request to municipality and third parties in order to obtain the permission to start a business activity according to the Italian law. Specifically, in the sub-process Check Application (CA) the employee in charge checks the received documents and verifies their validity. After that, the valid requests are sent to third party in PA in order to undergo the final verification and eventually to be accepted.
Models in PA are constantly updated and shared among different organizations, thus public servants daily deal with a large amount of data and a multitude of model versions, that is tedious and errorprone. In order to better understand the context, let us to consider the following scenario of collaborative modeling in PAs. Figure 2 depicts a scenario in which some modelers work collaboratively on the model in Fig. 1, that is considered as initial model. Then, it Figure 3: The overall architecture is extended, refactored and splitted in a set of versions, so that the changes are parallel dependent causing conflict issues.
Let us to suppose that, Modeler A and Modeler B are two employees of the same organization and they are working together in a collaborative manner. Both of them consider the sub-process Check Application (CA) depicted in Fig. 1 from the Learn PAd repository. The Modeler A is an expert of PAs procedures and adds to the initial model a BPMN element of type Lane, named Municipal Desk, in order to establish the unit responsible for the activity and improve the process execution (see Fig. 2(a)). Then, an expert of the BPMN language, called Modeler B, modifies the model and adds a pair of Inclusive Gateway to logically separate the existing message flows between Application valid and Application not valid, as showed in Fig. 2(b).
In meanwhile, an other organization decides to re-use models stored in the Learn PAd repository. In particular, as depicted in Fig. 2(c), the Modeler C acquires the model in Fig. 2(a) and renames the lane Municipal desk into District Desk; in this way, the responsibility of the activities is given to a different organizational unit.
Finally, as shown in Fig. 2(d), in a third organization, the Modeler D performs same changes on the model in Fig. 2(b) in order to improve the quality of the business process. In particular, the element First Integration Check of type Task is modified in Integration Check of type SubProcess in order to modeling a more complex process that includes a set of activities.
Let us to suppose that, modelers continue to work on the model and at a later time each organization requires to merge the modelers versions and obtain the proper organization version.
In this scenario, the same model is modified by different organizations and for each of them one or more modelers worked on it. Furthermore, for the scope of the Learn PAd repository, models and their versions has to be maintained and traced, so that further organizations can access and re-use it. For these reasons, it is crucial to have a comprehensive model representation that enable the information tracing and the management of different model versions in an automatic manner. The scope of this paper is to represent the multitude of generated models into a model with uncertainty capable of encoding all the alternatives in one instance and allowing the management.
In collaborative modeling, decisions may be made at different development stages requiring the designers to work with their model versions as long as uncertainty can be solved and a merged version can be obtained. In order to reduce the burden of managing a multitude of model alternatives, we present a metamodel-independent approach able to represent and manage uncertainty in collaborative modeling based on a revised basis in [24].
During the modeling, the same model is edited by multiple users. Changes introduced by modelers are maintained as alternative elements in the model producing uncertainty. During the management, modelers increasingly reduce (until resolve) such uncertainty by choosing among the alternatives. In particular, at each step, the modeler selects the desired alternative (i.e., making a model element in the solution space as certain), so that the uncertainty is gradually resolved by considering choices and dependencies. Note that, the two phases are not necessarily consecutive, in fact, at any time a modeler may decide to manipulate or manage the model or a part of it.
The overall architecture of the approach is depicted in Fig.
The uncertainty metamodel U M M is obtained by extending a base metamodel M M with specific connectives able to represent multiple alternatives asisen from collaborative modeling. These connectives denote the points of uncertainty where model elements belonging to a certain version are attached. Moreover, such points of uncertainty are traceable in order to permit the identification of specific merge strategies. The approach is metamodel independent, in fact its construction is realized by means of a model transformation and applies to any Ecore metamodel [14].
The uncertainty metamodel U M M structure is depicted in Fig. 4. As in the left-hand side of the figure, the metamodel is composed of two packages, the Base package that contains the elements of the base metamodel and the Uncertainty package that contains the elements that extend the base metamodel in order to allow the specification of points of uncertainty.
In particular, the uncertainty metamodel U M M is generated extending the base metamodel as following:
1) the metaclass User with attribute username that specifies the author making the editing is added;
2) the metaclass OperatorType that enumerates the logical operator literals AND, OR and XOR is added;
3) for each parent class C in base metamodel, such that it does not specialize other metaclasses:
4.1) a corresponding abstract metaclass IC is created such that C specializes IC. Such interface allows to choose among a certain element or an uncertain one.
4.2) a metaclass UC that extends IC is added. It specifies an association alternatives of type C and multiplicity 1.. * that relates the alternative elements to the uncertainty point of type C; an association upoints of type
The aforementioned procedure is implemented as an endogenous model-to-model transformation implemented in ATL.
The main advantage of such representation technique is that the uncertainty represented by a set of alternative models is leveraged to a first-class status. Hence, a complete set of models can therefore be manipulated as whole, for instance with an automated transformation (as done for instance in [16]), without iterating over each individual in the set.
According to the scenario described Sect. 2, we assume that in PAs, modelers are interested to specify complex processes by means of the standard notation BPMN and to exploit the Learn PAd repository where models are constantly updated and shared among different organizations.
Let us considering the BPMN 2.06 language as mentioned in the motivating example in Sect. 2. The language specification supports different modeling conformance levels (e.g., process modeling, process execution, etc.) that makes it as rich and complex. For the sake of understanding and brevity, we provide a restricted version of the BPMN 2.0 metamodel that concerns the process modeling conformance level and allows us to specify processes at a certain abstraction level and to model the running example discussed in Sect. 2. Starting from the simplified version of the BPMN metamodel, the correspondent uncertainty metamodel UBPMN is obtained as illustrated in the previous section 7 .
At this point, modelers may specify their models with uncertainty. In particualr, by using the proposed approach, the model in Fig. 2 Figure 5: The CA sub-process in Fig. 2 Models with uncertainty may over-approximate the solution space because of their combinatorial nature [24]. For instance, the scenario in Fig. 2 suggests that only one lane for the same activity can exist in the final model. However, the generated model with uncertainty could admit also models with both the lanes giving place to more solutions than those expected. Therefore, this outcome is avoided by using logical operators that allowing modelers to constrain and restrict the solutions to the ones depicted in the Fig. 2.
Listing 1 shows a fragment of the model with uncertainty representing the alternative solution models generated by the collaborative modeling in Fig. 2. It is given in its XMI 8 1 [...] 2 <users username="Modeler_A"/> 3 <users username="Modeler_B"/> 4 <users username="Modeler_C"/> 5 <users username="Modeler_D"/> 6 [...] 7 <laneSets xsi:type="LaneSet"> 8 <lanes xsi:type="Lane" name="Third Party PA"/> 9 <lanes xsi:type="ULane" users="//@users.0//@users.1// @users.2//@users.3" /> 10 <upoints users="//@users.0//@users.1//@users.
The proposed approach allows to use models with uncertainty in order to represent design alternatives in collaborative models. The approach aims to respond to the need for techniques indeed to the engineering, modularization and reuse of large models and complex modelling enabling their flexible combination.
As said, modelers edits their modification on the model with uncertainty that semantically correspond to a set of models conform to the base matamodel (solution space); then alternatives has to be selected and/or merged in order to obtain the desired (final) model version. Dependencies and conflicts in models cause issues related to consistency checking that has to be tackled.
However, a number of operation may be needed to give the designer a more effective support and to achieve a complete interoperability between the base and the uncertainty metamodels, as shown in the next section.
Once the uncertainty metamodel U M M is generated and modelers start to edit the model U M conforms to it in a collaborative manner, it is important to achieve the mean to manage the arising uncertainty. As said, multiple editing generates multiple alternatives; modelers may iteratively reduce the uncertainty by selecting the desired alternatives in a parametric manner and finally, when the uncertainty is totally resolved, the final model representing the desired design model is obtained. Note that the modeler may intentionally manage a sub-set of uncertainty points and postpone the complete resolution.
To this end, we provide an operation called f ilter that permits to the modelers to reduce the uncertainty according to a given property. In particular, the f ilter operation is a mapping defined as following:
that for any model with uncertainty U M ∈ U M M and a parameter p defined over the metamodel M M returns a model U M ∈ U M M where the uncertainty is reduced according to p (i.e., the solution models that not satisfying a given property are removed).
The operation is implemented by means of a model-to-model transformation called F ilter written in ATL. As said, it takes as input the U M model and a parameter (represented by a model P M conforms to the metamodel P M M ), and outcomes a model U M1 conforms to U M M , that is filtered according to P M . In particular, the generated model U M1 is included in U M , that is semantically equivalent to a subset of the models {M1..Mn} according to the parameter expressed in the model P M .
When the uncertainty is solved, the outcome is a final model without uncertainty (i.e., concretization model). Along with an incremental management, we provide to the designer the possibility to directly select one or more (or all as well) concretization models.
The concretization operator is defined in order to return the whole set of the concretizations represented in a model with uncertainty. More formally, such operator concr is a mapping defined for any base metamodel M M :
which takes an arbitrary model with uncertainty U M ∈ U M M and returns its k concretizations M1 • • • M k ∈ M M . By entangling the uncertainty with the specialized metamodel construction U M M , it is of crucial relevance to be able to retrieve the concretizations as instances of their base metamodel. As one can expect, the reasons why this is important can be numerous including the necessity to keep on exploiting, utilizing, and capitalizing on existing tools.
For instance, the uncertainty of the model in Fig. 5 can be solved in this way: i) the versions of the Modeler A and the Modeler B are merged together in order to obtain a final model of the first organization, ii) the versions of the Modeler C is selected to obtain a final model of the second organization, iii) the versions of the Modeler D is selected to obtain a final model of the third organization, and iv) a new version is selected by a modeler of a different organization.
Let us suppose that the modeler's of the first organization need to solve the uncertainty and obtain a final model, thus the F ilter transformation is applied as in the following:
-the modeler selects the task First Integration Check belongs to the uncertainty point edited by the Modeler B. Such parameter is given as input of the transformation; since the uncertainty point is involved in a logical operation AND all the elements in the uncertainty point are taken as certain part of the final model;
-the modeler selects the parallel gateway P1 belongs to the uncertainty point edited by Modeler B and Modeler D. Since the uncertainty point is involved in a logical operation AND both the elements Start2P1 and P1 are taken as certain and the second point of uncertainty is solved; finally -the lane Municipal Desk is selected and the last uncertainty point is solved.
The final model is depicted in Fig. 6.
In this work, we aim to support designers in specifying collaborative models and perform operation on them; for instance, designers may need to performs operations of model transformation on versioned models. Model transformation techniques typically operate under the assumption that models do not contain uncertainty. Actually, when a Figure 6: A possible resolution of the model in Fig. 5 modeler is still working on a versioned artifact, she may delay the application of model transformations until the information needed to perform the merge becomes available, or make premature resolutions of the existing versions in order to apply the model transformations, thus creating a risk that these resolutions are incorrect. With our approach, modelers may resolve the uncertainty by considering only one version of model, otherwise they may decide to postpone the resolution, so they they need to be supported in their operations (e.g., model transformations should be applied on models with uncertainty [16]). To this reason, we aim to provide a technique to adapt existing model transformations so that they can be applied to models even if they contain uncertainty [11].
Furthermore, by means of our approach modelers can therefore easily grasp the differences among candidate models and consistently make their decision without manually inspecting each model individually.
Our approach requires to be integrated on a collaborative modeling platform that supports multi user in real time and large models (of the scale of millions of model elements) paying attention to efficiency and performance.
The existing model versioning systems are mainly designed as version control systems (VCS), such as CVS or SVN. They support the long transaction model that assume that designers perform commit of large part of the work with respect to a certain previous version [19]. These systems are asynchronous and provide merging features and mechanisms able to automatically detect and solve conflicts by means of primitives like push, pull, commit and merge.
A modeling system supporting our approach has to be able to deal with models with uncertainty and to allow multi-users to collaboratively work with their models in a way that the uncertainty is transparent. The architecture is designed to support both offline and online collaboration in a multi-user and multi-device environment, and to provide a model access layer (transaction management, queries, views and manipulation), and an adaptation layer for the integration of access control and authentication (these may be provided by additional middleware such as the web server that hosts the actual communication between server and client). The environment will be implemented as an Eclipse Plugin embedded in the EMF framework 9 .
Let us to consider that modelers have access to a repository that provide different organizations to store and manage their models (as in the example in Sect. 2). Thus, modelers need to: i) visualize the repository and select the desired model by exploit a standard no-tation of feature diagrams [10], and ii) edit their artifact by means of an XMI editor and/or a visual editor embedded in the EMF environment. Going in more details, when the designer select a model, the concr operation extract the specific model from the model with uncertainty. Whereas, when modifications are made from a modelers and the push operation is performed, the system as to consequently update the model with uncertainty (i.e., changes are added as alternatives within uncertainty points).
Uncertainty is ubiquitous within contexts such as requirements engineering [12], software processes [18] and adaptive systems [26]. Uncertainty management has been studied in many works, often with the intention to express and represent it in models. In [15], partial models are introduced in order to let the designer specify uncertain information by means of a base model enriched with annotations and first-order logic. In [25] a formal approach called MAVO is proposed and applied to design models in order to express and allow automated reasoning in presence of uncertainty. In [24], an approach to manage the uncertainty generated as the outcome of a non-deterministic model transformation is proposed. The JTL bidirectional transformation engine [9] is revised to accommodate a intensional semantics, that permits a transformation to natively generate a model with uncertainty instead of a myriad of models. In particular, a model with uncertainty provides a compact representation of the solution space for the sake of usability and effectiveness. Model transformation techniques typically operate under the assumption that models do not contain uncertainty. Nevertheless, the work in [16] proposes a technique for adapting existing model transformations in order to deal with models containing uncertainty. In [11], the authors propose a bidirectional model transformation framework to cover incomplete transformations producing a multitude of possible solutions to consistency restoration. This multitude is managed in an intentional manner via models with built-in uncertainty (as proposed in [24]) and allows to these to be included as input in a model transformation process.
Feature models are a popular formalism for managing variability in software product lines. In this context, the Familiar project [4] provides an executable language that supports manipulating and reasoning about feature models and fully integrated modeling tool.
Despite a number of works have been proposed to cope with large and complex software systems, a new line of research is imperative in order to achieve scalability across the MDE technical space and to enable MDE to remain relevant [20]. Among the existing approaches that aim to cope with different topics concerning scalability, such as modeling languages, transformations, collaborative modeling, persistence and so on, we consider the followings as most related to our work. In [17] the authors aim at providing compositional technology and techniques for a languageindependent model modularization. In particular, they proposed a way of extending modeling languages with component capabilities. The implementation is based on EMF Eclipse. However, the work does not consider issues related to consistency preserving when models are interconnected.
The state of the art in collaborative modeling includes several prototype attempts of collaborative systems that are more closely aligned with version control systems (VCS), such as CVS or SVN [21,6,1,2]. Recently, the Eclipse collaborative modeling community proposed some convergent approaches. The Eclipse Modeling Framework Connected Data Objects (CDO) [5] is a model repository for EMF models supporting version management. EMF Compare [13] is a model comparison, differencing and merging tool often used in combination with traditional VCS. EMFStore [3] is a model versioning framework for EMF able to deal with conflict management.
They provides a still immature means for collaborative work and locking and conflict management [20]; they are more closely aligned with version control system such as CSV and SVN and implemented within EMF Eclipse. Moreover, they do not fulfill the need to have a flexible and scalable framework able to work independently from the specific domain-specific language or ad-hoc architecture.
MDE is now practiced in industry, and on very large complex systems engineering projects and problems. From this arises the need to enable designers to create and refine large models in a collaborative manner enabling the engineering, modularization and reuse.
In this paper, we proposed to deal with the uncertainty arisen from the collaborative editing of models by means of a metamodelindependent approach able to represent models with uncertainty. Furthermore, we proposed to manage the uncertainty by means of two kinds of operations to reduce or resolve the uncertainty. We plan to realize a model transformation approach able to deal with model with uncertainty (i.e., model with uncertainty are input and/or output of the transformation engine). Finally, we plan to integrate our approach in a collaborative environment for real time multi-user editing. We aim to extend the framework to help the modelers to make decisions among proposed design versions. The versions are initially partitioned, constrained, abstracted, and graphically visualized to the user. Then, when decisions are made, they are stored and used to drive subsequent decisions.
This research was supported by the EU through the Model-Based Social Learning for Public Administrations (Learn Pad) FP7 project (619583).