Maintaining different but consistent views on the same process is often necessary in BPM projects. For example, a business analyst typically works on a business process model at a different level of abstraction than an IT architect. These views evolve independently and synchronizing them is not trivial. In this demonstration, we showcase our Shared Process Model prototype that allows different stakeholders to work on different views of a business process model while keeping these views synchronized. In particular, we will look at scenarios where a business view and an IT view are modified and a subset of the modifications need to be propagated from one view to the other. This demonstration targets the general BPM audience interested in ensuring consistency between various level of realisation of a business process model and solving the related round tripping problems. This demonstration will also appeal to people interested in process comparison and process merging - the two core techniques used by our prototype to propagate changes from one view to the other.
The Shared Process Model is a research prototype built on top of the BPMN2
Modeler — an Eclipse-based graphical BPMN 2.0 model editor [
It also ensures that the two views remain consistent, i.e., the IT view is
a ‘faithful’ representation of the business view and vice et versa. The enxact
notions of consistency considered ad how they are ensured or checked is out of
scope of this paper but are presented in the technical report [
Finally, the Shared Process Model provides a set of model refactoring operations to support the user in modifying a view while retaining its consistency with the other view. For example, it provides refactoring operations to refine an activity into a subprocess or into a set of activities together with the control-flow between them, to specify that an activity is implemented as a script task or a service task, and to simplify a portion of the process into a single activity. Shared Process Model implementation and change propagation: Fig. 2 illustrates the internal of our implementation a Shared Process Model: two BPMN 2.0 process models representing the two views and correspondences (the highlighted vertical arrows) relating the nodes of the two models. Note that correspondences can point to multiple corresponding nodes and that some nodes of the IT view do not have a corresponding node in the business view.
We now present a short scenario where the Shared Process Model is used to
synchronize a business and an IT view on a process. A screen-cast of featuring
this scenario is available on the project webpage [
Initialization of the Shared Model First, Alan captures the business process model illustrated by Fig. 3. Alan initializes the Shared Process Model, which now contains this process in both views and the appropriate correspondences. From now on, Alan will work on the business view and Paul on the IT view. Alan asks Paul to create an implementation of the process model.
Fig. 3: Initial business process model Private and Common Changes: Using refactoring operations, Paul refines the specification of the activities by specifying their realization, some activities are implemented as script tasks other by service tasks. He also adds the exception flow. These changes are only relevant to the IT view. Therefore, Paul commits the changes as private. Paul then realizes that he can optimize the control-flow of the process and that Alan forgot one activity. These changes are relevant to business view and Paul updates them as common. The IT view now displays the process in Fig. 4 while the business view displays the process illustrated on top of Fig. 2. Private refactoring: Paul wants to convert the two human activities into one. He uses the simplify selection refactoring wizard, which turns a selection of elements into a single activity and reroutes the incident edges of the selection accordingly. The refactoring also creates the correspondence between the two business activities and the IT activity. This change is a private change. The Shared Process Model now contains the two views illustrated by Fig. 2. Common changes using correspondences Finally, Paul inserts a new activity between ‘Validate Pin’ and ‘Input Transaction Data’ as a common change which results in the IT view illustrated by Fig. 5. Looking at Fig. 2, one realizes that the translation of this change, as described in Sect. 2, requires to navigate the correspondences and to perform a structural analysis. Updating this change results in the business view illustrated by Fig. 6. The two views have evolved and are now significantly different. However, the Shared Process Model is still able to propagate automatically changes between the two views ensuring that they stay consistent maintaining the correspondences between its different elements.
In this prototype, we focused on the propagation of control-flow related modifications. The propagation of some attribute modifications such as, for example, changing the type of an event is not implemented but could easily be added. We also consider the implementation of a user interface allowing a user to approve or reject the changes made by another user. For example, Alan could approve only a subset of the common changes proposed by Paul.
We only presented the modifications of two views: business and IT. The Shared Process Model can be generalized to any two BPMN 2.0 views. The architecture of the prototype as well as comparison and merging components would scale up to a larger number of views. However, the correspondences would require a more complex representation and management.
We currently support scenarios where IT view and business view modifications are interleaved. Ultimately, we aim to integrate the Shared Process Model in a modern BPM suite where models sit in a shared repository, the Shared Process Model would then be a shared object in the repository and new scenarios would involve concurrent editing of the IT and business view. Support to prevent, detect, and resolve conflicts arising from concurrent editing is necessary for these scenarios.