Generating Preliminary Edit Lenses from Automatic Pattern Discovery in Business Process Modeling

Abstract

Business process models are often used to describe a single system at di erent levels of abstractions|for instance, a business work ow speci cation and its corresponding IT implementation|and have to be synchronized. Describing such model synchronizations with approaches to bidirectional model transformations (e.g., lenses) has several advantages from maintainability to veri cation. However, describing a synchronization from scratch by manually writing update operations can be tedious and error-prone. We show how to automatically generate such synchronizations by identifying re nement patterns in the relation between di erent models and by representing those patterns as edit lenses. Although these generated synchronization operations may not completely re ect all the re nement patterns that correlate the models in practice, a considerable part of manual work can be saved by generating them automatically rst, and then only check and optimize them manually.

-

Business Process Modeling (BPM) involves the participation and collaboration of many stakeholders (e.g. Business Analysts, Systems Analysts, IT Architects and Developers). The distribution of responsibilities and roles results in the creation of di erent models of the same business process. Specialized modeling languages have been developed to represent such models, for example the Business Process Modeling and Notation (BPMN). Business- and IT-level models evolve concurrently and periodically need to be synchronized [ 2 ]. Synchronizing the models means propagating changes in both directions, i.e., from business to IT and vice versa. Writing such synchronizations usually requires uncovering tacit knowledge, which may be lost entirely. IT personnel at the Bank of Northeast of Brazil (BNB), our industry partner, has faced this challenge as part of a regulatory compliance project. Without appropriate tool support, this task is very time-consuming and error-prone.

Aiming at mitigating this problem, there is a multitude of frameworks for bidirectional model transformations (BXs) [3{6,8,9]. Although these approaches provide the foundations of BXs in terms of properties and operations, few concrete implementations of such frameworks are available. It remains unclear how to generate such transformations in many problem domains. In particular, there is a lack of practical BX frameworks tailored to deal with consistency of business process models that target di erent levels of abstraction.

In this paper, we leverage previous work on process model matching [ 1 ] and present a practical approach for generating preliminary bidirectional model transformations in BPM based on edit lenses [ 9 ]. The implemented framework is tailored to process modeling at di erent abstraction levels. First, we start by providing some background in BPM and important concepts used throughout the paper (x 2). Following, we discuss some background and rationale behind using edit lenses to deal with process models (x 3). Then, we present technical details of the approach (x 4) and show some evaluation based on industrial case studies (x 5). Finally, we discuss related work (x 6), conclusions, and future work (x 7). 2

Business Process Models at Di erent Levels of

Abstraction

2.1

Background

A business process is a collection of structured or ad hoc activities that produce a speci c output, such as service or product. The activities of a process interact with IT assets to capture, transform, or report business data. In practice, a range of business to IT-oriented stakeholders create and use business process models for speci c purposes, including requirements elicitation, documentation, simulation, and execution. Figure 1 shows two models in BPMN 2.0, each representing the process of using an Automated Teller Machine (ATM) system at di erent level of abstraction. We added shorter names in parentheses (e.g., (AC), (GB)) to avoid clutter when referring to the models. The rst model (Fig. 1.a) represents a business-level process speci cation. The second one (Fig. 1.b) is an IT-level speci cation. 2.2

Process Structure Tree (PST)

Any BPMN model can be uniquely decomposed into single-entry single-exit (SESE) regions [ 10 ]. Let G = (N; E) be a work ow graph, where N is the set of nodes and E the set of edges. A SESE region R = (N 0; E0) is a nonempty subgraph of G, i.e., N 0 N and E0 = E \ (N 0 N 0) such that there exist edges e; e0 2 E with E \ ((N nN 0) N 0) = feg and E \ (N 0 (N nN 0)) = fe0g; e and e0 are called the entry and the exit edge of R, respectively. The Process Structure Start

Approve Card

(AC) Customer Inserts Card into ATM (Trigger)

Approve & Get Transaction (AGT)

Timeout Cancel Transaction

(CT) PSTa R0

R2 R3 GB

R4 DA

X1 X1

Get Balance

(GB) Debit(DAAcc)ount Get Balance

(GB) Tree (PST) for a BPMN process model is a tree representing the decomposition of the model into SESE regions [ 10 ]. Figure 2 shows the PSTs corresponding to the BPMN process models. There is a unique PST for each BPMN model. The root represents the whole process model. Leaves represent model elements, i.e., tasks, gateways and events. Inner nodes represent SESE regions.

Di erences between Business and IT process models We have compiled a catalog of 11 recurrent patterns used to re ne business-level models into IT-level models [ 2 ]. These patterns include (i) adding or modifying properties of model elements, such as changing the name or type of an activity, and (ii) changing the ow structure. An example from category (i) is the renaming and retyping of the empty start event Start (Fig. 1.a) into the message-driven event Customer inserts card into ATM (Fig. 1.b). An example from category (ii) is the re nement of the task Debit Account (Fig. 1.a) into the block consisting of the gateways X5 and X6 and two other tasks Debit Checkings and Debit Savings (Fig. 1.b). 3

Edit Lenses

A lens is a bidirectional transformation between a pair of connected data structures, X and Y, capable of translating an edit on one structure into an appropriate edit on the other. Each lens is a pair of functions|to and from|one mapping X updates to Y updates and the other mapping Y updates to X updates. Although many varieties of lenses exist in the literature, only edit lenses [ 9 ] o er a satisfactory treatment of how editing operations are represented.

Our approach employs edit lenses because of two reasons. First, in business process modeling, changes (including re nement patterns [ 2 ]) can be distilled into atomic editing operations, such as inserting, deleting or moving an activity and updating its attributes. Second, edit lenses are intuitive. Human users can inspect them easily to review, add, discard or select speci c operations before synchronizing the models. 4

Generating Edit Lenses from Correspondences between

Process Models

In previous work [ 1 ], we presented an algorithm to automatically detect nontrivial correspondence patterns [ 2 ] between BMPN process models across levels of abstraction. The algorithm identi es attribute and structural correspondences over the PSTs of the input models. Table 1 shows the correspondences identi ed by the matching algorithm on the PSTs shown in the Fig. 2.

For each correspondence, the lenses generator produces a pair of functions, to and from, composed of edit operations for bidirectional transformations in both directions: business ,! IT (to) and business - IT (from). Regions and model elements without correspondences, such as P STa.DA and P STb.GS, are treated as individual inserts or deletes. The edit operations are generated according to the following heuristic: { insert(l,y,k); insert a new PST node l as the k th child of node y. For example, in Fig. 2, the region P STb.R6 is inserted as the 3rd child of P STb.R4: insert (P STb.R6,P STb.R4,3). { delete(x); delete PST node x from its parent. In the example, P STa.DA is deleted from P STa.R4: delete(P STa.DA). { move(x,y,k); node x becomes the k th child of y. In the example, the task

P STa.GB is moved from P STa.R3 to P STb.R5: move(P STa.GB,P STb.R5,1) { update(x,v); update value of x with v. For example, the value of the node

P STa.PR was updated to P STb.CR: update(P STa.PR,P STb.CR) { re ne(r,s); the region r is re ned into the region s: the atomic changes are also presented by inserts and deletes. In the example, the region P STa.R4 is re ned into the region P STb.R7. The corresponding inserts and deletes are presented hierarchically, such as delete(P STa.DA), insert(P STb.R8,P STb.R7, 2), and so on.

Node positions are shown as parameters using absolute paths. A path like \/0/4/3/0" means: the unique child of the 3rd child of the 4th child of the root node. The output of the lenses generator for the correspondences vii and viii previously shown are as follows: vii P STa.GB =P STb.GB to (business ,! IT ) move PSTNode="GB" destination="/0/4/2/2" origin="/0/3/2" from (business - IT ) move PSTNode="GB" destination="/0/3/2" origin="/0/4/2/2" viii P STa.R4 =P STb.R7 to (business ,! IT ) refine PSTNode="R4(DA..DA) to R7(X5..X6)" composed of: delete PSTNode="DA" source="/0/3/3/0" insert PSTNode="X5" destination="/0/4/3/0" insert PSTNode="X6" destination="/0/4/3/1" insert PSTNode="R8(DC..DC)" destination="/0/4/3/2" insert PSTNode="R9(DS..DS)" destination="/0/4/3/3" insert PSTNode="DC" destination="/0/4/3/2/0" insert PSTNode="DS" destination="/0/4/3/3/0" from (business - IT ) refine PSTNode="R7(X5..X6) to R4(DA..DA)" composed of: delete PSTNode="X5" source="/0/4/3/0" delete PSTNode="X6" source="/0/4/3/1" delete PSTBranch="R8(DC..DC)" source="/0/4/3/2" delete PSTBranch="R9(DS..DS)" source="/0/4/3/3" insert PSTNode="DA" destination="/0/3/3/0"

Users can review this preliminary set of edit operations to add, remove, group and discard speci c ones. The nal lens (revised by the user) is executed when something is changed in either of the two models to generate a consistent version of the other model. The synchronization is fully automatic: our implementation provides a module on top of VIATRA2 to synchronize any number of individual operations selected by the user. Transformations are rst performed on the PSTs, and afterwards they are transformed back into BPMN. Occasional malformed BPMN models after the transformations (e.g., an added task without incoming or outgoing ows) need to be xed manually by the user. To deal with this issue we are currently working on integrating the approach with a quick x generator [ 7 ] that guides the user in xing post-synchronized models, when needed. 5

Evaluation

Implementation. We have implemented the lenses generator framework in Java as an Eclipse feature (Fig. 3), on top of the SOA Tools Platform BPMN Modeler.

Evaluation. The quality of generated lenses directly depends on the quality of the matching algorithm, whose recall varies between 40-70% [ 1 ]. Thus, the users always need to review the initial lenses to capture the correct re nement patterns and create a baseline of operations that ensure proper business-IT synchronization. We wanted to know how much manual work is needed to update baselines of lenses over time, in the presence of typical model changes. We inspected 48 real changes made in three BPM projects over a period of one year, and counted how many individual operations would need to be manually changed in each baseline to meet those changes. The results are shown in the Table 2.

A large number of operations needs to be manually revised to cope with changes. Nevertheless, we believe that keeping baselines of lenses is useful, instead of the burden of periodically rebuilding all synchronizations from scratch. Approximately 50% of the work over the analysed period would be saved by basically maintaining the lenses incrementally, in pace with the changes.

Fig. 3: Edit Lenses Generator Tool Project Customer Registration Credit Backo ce Procurement Bidirectional transformation frameworks originate from the lenses framework proposed by Foster et al. [ 6 ] which assumes one model being an abstract view of the other. Inspired by the lenses framework, researchers proposed state-based framework for symmetric synchronization [ 8 ]. As a more general case, symmetric synchronization allows neither of the model to be a view of the other. However, as Diskin et al. [ 3 ] point out, state-based bidirectional transformations actually mix two di erent operations|delta discovery and delta propagation|leading to several semantic problems. To x these problems, several approaches [ 3, 5, 9 ] propose delta-based frameworks, where deltas are taken as input and output. Typical delta-based frameworks include delta lenses [ 4 ] for the asymmetric cases, and symmetric delta lenses [ 5 ] and edit lenses [ 9 ] for the symmetric cases. 7

Conclusions

We have presented a practical approach that generates preliminary edit lenses in BPM, tailored to maintaining consistency of process models at di erent abstraction levels. A prototype tool is implemented on top of Eclipse and SOA Tools Platform. We performed a preliminary evaluation of the tool based on real-world models. As for future work, we aim to perform a qualitative assessment of the approach, obtaining feedback from BPM practitioners in industry. We also hope that this work may encourage developers to evolve the approach and provide tool support to more elaborated BX scenarios in BPM.

Acknowledgment

We would like to thank the Bank of the Northeast of Brazil (Banco do Nordeste { BNB) for providing the case study as well as valuable requirements and feedback on the design of the tool.

References

1. Branco , M.C. , Troya , J. , Czarnecki , K. , Kuster, J., Volzer, H.: Matching Business Process Work ows Across Abstraction Levels . In: Proceedings of 15th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems. MODELS 2012 , ACM/IEEE ( 2012 )

2. Branco , M.C. , Xiong , Y. , Czarnecki , K. , Kuster, J., Volzer, H.: A case study on consistency management of business and IT process models in banking . Journal of Software and Systems Modeling SoSyM ( 2013 )

3. Diskin , Z. , Xiong , Y. , Czarnecki , K. : From state- to delta-based bidirectional model transformations . In: Proceedings of the Third international conference on Theory and practice of model transformations . pp. 61 { 76 . ICMT' 10 , Springer-Verlag, Berlin, Heidelberg ( 2010 )

4. Diskin , Z. , Xiong , Y. , Czarnecki , K. : From State- to Delta-Based Bidirectional Model Transformations: the Asymmetric Case . Journal of Object Technology 10 ( 2011 )

5. Diskin , Z. , Xiong , Y. , Czarnecki , K. , Ehrig , H. , Hermann, F. , Orejas , F. : From State- to Delta-Based Bidirectional Model Transformations: the Symmetric Case . In: Proceedings of the 14th international conference on Model driven engineering languages and systems . pp. 304 { 318 . MODELS' 11 , Springer-Verlag, Berlin, Heidelberg ( 2011 )

6. Foster , J. , Greenwald , M. , Moore , J. , Pierce , B. , Schmitt , A. : Combinators for bidirectional tree transformations: A linguistic approach to the view-update problem . ACM Transactions on Programming Languages and Systems (TOPLAS) 29(3) , 17 ( 2007 )

7. Hegedus, A. , Horvath , A. , Rath , I. , Branco , M.C. , Varro , D. : Quick x generation for DSMLs . In: Proceedings of IEEE Symposium on Visual Languages and HumanCentric Computing VLHCC 2011 . IEEE ( 2011 )

8. Hofmann , M. , Pierce , B. , Wagner , D. : Symmetric lenses . In: Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages . pp. 371 { 384 . POPL '11, ACM , New York, NY, USA ( 2011 )

9. Hofmann , M. , Pierce , B.C. , Wagner , D. : Edit lenses . In: POPL . pp. 495 { 508 ( 2012 )

10. Vanhatalo , J. , Volzer, H., Leymann , F. : Faster and More Focused Control-Flow Analysis for Business Process Models Through SESE Decomposition . In: ICSOC 2007 . pp. 43 { 55 . LNCS, Springer-Verlag, Berlin, Heidelberg ( 2007 )