Franc ¸ois Charoy Karim Dahman
email: dahman@loria.fr

Claude Godart
email: godart@loria.fr

Alignment and Change Propagation between Business Processes and Service-Oriented Architectures

Keywords: Business Process, SOC, MDE, SOA Alignment

Increasing the productivity of the Service-Oriented Software Engineering through a model-driven methodology needs to go beyond business services modeling and the automation of transforming models that adhere to the SOA style. Commonly, the business analysts focus on modeling business processes. Then, IT developers implement software architectures that are automatically generated from the process models. In this paper we look forward to maintaining the alignment between business services and their supporting IT assets when business settings evolve. We introduce an approach for an incremental synchronization between business process models and component configuration models that follow SOA architectural principles. We automate the change forward propagation by enforcing in-place translations of the updates on the models in order to preserve their consistency. Rather than executing the entire development process again, software architects can assess the necessity of propagating design decisions to the implementation level by adapting the deployed IT assets according to the business evolutions.

I. INTRODUCTION

Maintaining the alignment between evolving business solutions and their supporting IT capabilities is essential for enterprise information systems [START_REF] Chen | From software architecture analysis to service engineering: An empirical study of methodology development for enterprise soa implementation[END_REF]. Service-Oriented Computing [START_REF] Papazoglou | Serviceoriented computing: State of the art and research chall[END_REF] has emerged as an approach for modeling, building and managing software applications on the basis of Service-Oriented Architecture [START_REF] Papazoglou | Serviceoriented computing: State of the art and research chall[END_REF] (SOA). Software architectures that adhere to this style are implemented as loosely-coupled software components that are composed in configurations and linked by connectors. Those service-component realize business services at the implementation level by enacting process tasks. They expose their functionalities as business services, and consume other services in an uniform way [START_REF] Dumas | Service-enabled process management[END_REF].

Business-Driven Development experience shows that using Model-Driven Engineering [START_REF] Lopes | Generating transformation definition from mapping specification: Application to web service platform[END_REF] (MDE) enables to align software architectures with the business processes. During the initial development activities, IT developers can rapidly instantiate software architectures from business processes with an automated model transformation. However, this Business-IT alignment can disappear when business requirements evolve incrementally. Here, we want to enable the behavioural and architectural evolutions of business processes that imply structural adaptations. We support the adaptation of servicecomponent implementations when the business processes are modified to maintain their alignment.

To achieve that goal, we propose an incremental model synchronization framework. Following the generative approach of our previous work [START_REF] Dahman | Generation of Component Based Architecture from Business Processes: MDE for SOA[END_REF], we enforce a conceptual mapping between a business process model and a service-component configuration model. We automate the change forward propagation to translate consistently an update on the process model into the service model when a transformation was previously executed. We base our work on the formal foundations of graph rewritings [START_REF] Giese | From model transformation to incremental bidirectional model synchronization[END_REF], [START_REF] Biermann | Precise semantics of emf model transformations by graph transformation[END_REF] to preserve the model consistency. We have developed a proof-of-concepts prototype to validate our method of the consistency management between the models.

The paper is organized as follows. In Section II, we sustain the usage of two domain-specific languages for our MDE approach to bridge the gap between cross-organizational processes modeling and SOA development. Section III formally describes our framework and Section IV presents our incremental model synchronization principles. In Section V, we demonstrate a proof-of-concept implementation of those principles with a discussion on their theoretical and experimental evaluations. Finally, we situate our work with the related research in Section VI, and we present future possible extensions in Section VII.

II. BRIDGING THE GAP BETWEEN PROCESSES AND SOA

In this section, we present an example (inspired from [START_REF][END_REF]) of a Supply Network which illustrates some situations that occur when software architects have to propagate business process evolutions to the supporting service-component logic.

To model the business logic [START_REF] Dumas | Service-enabled process management[END_REF] of each partner in the network we use the Business Process Model and Notation [START_REF][END_REF] (BPMN) standard. It refers to a service orchestration [START_REF] Papazoglou | Serviceoriented computing: State of the art and research chall[END_REF] as a set of participants with processes in a collaboration. BPMN combines graphical and textual annotations to describe business process models with cross-domain capability sharing that are decoupled from their supporting software architectures. The BPMN diagram s in Figure 1 shows business service interactions between the collaborating partners (Supplier, Customer, Shipper and Invoicer). It specifies the behavioural (flows between tasks) and architectural (conversation links between participants) views of the business partners. The information exchanges are modeled as conversations that capture service contracts and interactions. The dotted box in s describes the design decisions made by the business analysts for the Ordering service (between Supplier and Customer) with a send-receive interaction pattern [START_REF] Van Der Aalst | Service Interaction: Patterns, Formalization, and Analysis[END_REF]. It is captured by a single BPMN conversation. We consider that the core BPMN constructs subset, drawn in the legend of Figure 1, is sufficient to capture the most important service-oriented design aspects. In [START_REF] Dahman | Generation of Component Based Architecture from Business Processes: MDE for SOA[END_REF], we provided a development scenario to transform a source BPMN collaboration model into a target servicecomponent configuration model described using the Service-Component Architecture standard [START_REF]SCA Assembly Model Specification 1.1, Open SOA[END_REF] (SCA). SCA provides a model for composing applications that embraces SOA principles. We refer to the program executions that implement the BPMN-to-SCA conceptual mapping (functional relation among BPMN and SCA constructs [START_REF] Dahman | From business process to component architecture: Engineering business to it alignment[END_REF]) as model transformations. For example, s generates the model t of Figure 1. A simplified conceptual mapping is shown in the figure's legend.

In order to automate model transformations, we conceptually map BPMN collaborations to SCA composites. Likewise, the BPMN participants map into SCA components. Those composites modularize and compose service-enabled business functionalities in a manner that is decoupled from their implementation code. For example, t describes a composite (Supply Network) of four components (Supplier, Customer, Shipper, Invoicer). It specifies the behavioural (flows between tasks), their service dependencies and other related artifacts which specify how they are consumed and offered. Each component exposes ports, also called services. It requires other services by means of references. It's configured to interact with the other components through wires. When a component is implied in bidirectional interaction patterns, callbacks are defined for the services and/or references (see Customer and Supplier in the dashed box of t). The callback of the consumer component (Customer) is used by the provider (Supplier).

The SCA wire is conceptually similar to the BPMN conversation construct. It represents an activation logic between two components and means an explicit message exchange. However, there is no mean of control flow between SCA services and references: each of them represents the direction of the first message exchanged between two components. Therefore, conversations between participants map1 into wires. A BPMN task maps into SCA service or reference, depending when it sends the first or the last message of the collaborations. For this purpose, we add an explicit index for each task in each process by extending the BPMN standard notation with the two icons: init and fin. The icon init (resp. fin) indicates an initial (resp., a final) task that sends or receives the first (resp. last) message in a service interaction pattern [START_REF] Van Der Aalst | Service Interaction: Patterns, Formalization, and Analysis[END_REF]. By introspecting process structures, an initial receive task is mapped to a service. Accordingly, a first send task maps to a reference. After the first receive task (resp., first service task), a process can contain a range of other send tasks (resp., receive tasks) that interact with the same participant. Thus, a final send task (resp., receive task) maps to a callback that is associated with the first mapped reference (resp., service).

The SCA composites can be deployed in a runtime engine that provide binding mechanisms and maintain the neutrality between component composition logic and their implementation code. Each component contains an implementation [START_REF]SCA Assembly Model Specification 1.1, Open SOA[END_REF] of service orchestration process with a suited programming language. BPMN processes map into SCA implementations. In this sense, BPMN processes can be transformed2 into other process execution languages, or even directly enacted with a BPMN-compliant workflow engine.

A. Maintaining alignment between Business Process and SOA

Now, we consider that business analysts need to change the Supply Network by separating the services concerns of Ordering and Invoicing as a best way to deal with their business requirements. They make a design decision to split the Ordering service (modeled in the as-is source model s of Figure 1). As depicted in (the to-be source model) s' of Figure 2, they update s with two separate conversations for send-after-receive and receive-after-send patterns [START_REF] Van Der Aalst | Service Interaction: Patterns, Formalization, and Analysis[END_REF].

Then, software architects have to propagate this source BPMN model change (so-called delta) to the previously generated target SCA model t of Figure 1. According to the BPMN-to-SCA conceptual mapping [START_REF] Dahman | From business process to component architecture: Engineering business to it alignment[END_REF], they must adapt the (as-is) target model t to a (to-be) target model t' as depicted in Figure 2. The software architects have to add a wire (Invoicing) between a service and a reference, and delete two callback. Here, change forward propagation is challenging since similar BPMN constructs are transformed into different SCA constructs: task Invoice maps to a callback in t and to a service in t' (because of the multivalued3 mapping relations). Manual adaptations of the SCA model are potentially error-prone [START_REF] Van Der Aalst | Service Interaction: Patterns, Formalization, and Analysis[END_REF]. Especially, they can lead to misalignments if they do not follow a strict roadmap and a thorough delta analysis between as-is and to-be models [START_REF] Dahman | Towards consistency management for a business-driven development of SOA[END_REF]. Thus, enabling uncontrolled updates on t is problematic.

Executing a full transformation of s' to get another model t * ' and automatically adapting t to t * ' is possible. We can operate an automated model difference (so-called diff), so that the difference and overlapping between the two model versions t and t * ' can be extracted. Then, we can compute t' by adapting t with the diff. However, a full transformation of s (when it evolves) is not suitable since any additional information in t is lost when applying the diff. The elements in t which are not covered by the overlapping cannot be derived automatically in t' and are thus lost. Hence, a practical approach should not replace t by t * ', but it has to reuse t in order to preserve extensions and refinements (crucial prerequisites to foster the MDE paradigm). Reusing previous SCA implementations for a new component composition logic and tracking the change impact at the architectural level becomes very difficult.

Moreover, when enforcing a diff-based model synchronization [START_REF] Antkiewicz | Design space of heterogeneous synchronization[END_REF], the change roadmap computation effort (to obtain to-be models from as-is ones) is proportional to the size of the models and not to the size of the updates. Recomputing a full transformation even though only a small fraction of the source model has been modified becomes very costly, especially when a frequent synchronization is considered. In practice, when the business logic evolves with incremental and localized updates that do not radically modify the BPMN model, we have to operate complex computations to obtain SCA models. For this reasons we want to incrementally adapt them.

Existing general synchronization frameworks [START_REF] Xiong | Towards automatic model synchronization from model transformations[END_REF] and transformation languages [START_REF] Antkiewicz | Design space of heterogeneous synchronization[END_REF] cannot work well for a functional and multivalued mapping [START_REF] Dahman | From business process to component architecture: Engineering business to it alignment[END_REF], since they are intended for generic model transformations. First, they require users to explicitly write a synchronization code to deal with each update, and on each domain-specific language. Second, mapping complexity of each change is compounded with the decisions regarding information loss or gain related to different levels of heterogeneous synchronizations [START_REF] Antkiewicz | Design space of heterogeneous synchronization[END_REF]. Thus, what sounds so straightforward in theory while using a model-driven approach, turns out to a very challenging endeavor in practice. To foreshadow a consistent maintenance of the Business Process-SOA alignment and change propagation automation, we introduce a framework which guarantees the structural consistency between our assorted domain-specific languages. We consider that this incremental BPMN-to-SCA model synchronization is a major use case for preserving the Business-IT alignment.

III. MODEL SYNCHRONIZATION FRAMEWORK

This section formalizes our incremental model synchronization framework. We also introduce the requirements that have to be satisfied by a tool support (so-called synchronizer [START_REF] Giese | From model transformation to incremental bidirectional model synchronization[END_REF]). Our following explanations are based on Figure 3. It shows the relations between the models of Figure 2. The key difference between the diff-based and the incremental synchronization is in remembering previous transformation results. The former discards previous transformation results and recomputes new ones, while the latter updates them. It synchronizes two models by a change propagation. It preserves the information which is not covered by the transformation and minimizes the computational effort. Formally, consider that a BPMN-to-SCA model transformation is a partial function denoted by trans : S → T that takes a source BPMN collaboration model from a set of BPMN models S and produces a target model in a set of SCA models T . Executing trans establishes a consistency relation between two models which is denoted by C ⊆ S × T . This relation is derived from the conceptual mapping between BPMN and SCA. For example, consider a BPMN model s in S and a SCA model t in T being transformed such trans(s) = t. Those models are consistent with respect to the binary relation as (s,t) ∈ C. Furthermore, given a source update U ∆S that alters s to s' such it produces inconsistent models with (s ′ ,t) ∈ C, the unidirectional incremental source-to-target synchronization framework consists in computing a target update U ∆T from U ∆S such that the application of the both updates results in consistent models: (s ′ ,t ′ ) ∈ C. It produces t' by adapting t such as U ∆T (t) = t ′ and U ∆S (s) = s ′ and establishing the relation C. We denote the incremental synchronization function by sync : C × ∆ S → T . The updates on the target model are obtained by directly interpreting the source model updates. We denote this interpretation by a function interp : ∆ S → P(∆ T ) that interprets source changes in ∆ S into a partition of target changes ∆ T .

To automate the incremental BPMN-to-SCA synchronization and to be compliant with our formalization, our synchronizer must implement a decidable algorithm. We consider that its execution (when synchronizing two models) has to satisfy the following criteria: uniformity, validity, conformity, stability, autonomy and idempotence. The uniformity and validity criteria require that it must produce consistent models. The conformity means that the resulting target models must conform to the SCA metamodel 4 . The stability means a nondestructive behavior on the SCA model when the BPMN model is not modified. The autonomy and the idempotence mean that it must returns the same proposed modifications on the target model when merging source models or their changes.

In practice, the synchronizer detects BPMN models changes. It translates them into SCA updates. When propagating those updates, it creates elements in the target if such elements do not exist. It modifies elements if such elements exist but have changed, and it deletes elements otherwise. These principles are explained below.

A. Abstracting Models to Graphs for Change Detection

In order to detect BPMN model evolutions and to adapt the SCA model, we relate models to labelled nested typed rooted graphs [START_REF] Biermann | Precise semantics of emf model transformations by graph transformation[END_REF]. Those graphs provide an intuitive and general 5 formalism to represent BPMN and SCA models. We consider the BPMN and SCA models as collections of typed objects and links with some structural constraints defined by the BPMN and SCA metamodels. A node can represent any kind of model object. Edges are used to represent all kinds of associations between objects. Nesting in graphs implies a number of constraints for model instantiations that must be enforced when models evolve. For this purpose, we use graphs with distinguished containment edge type and syntactic constraints to make model conform to metamodels.

We assimilate each model to a tuple (V, E, B, Y, I, Z) that includes the functions label:V ∪ E → B , type:V ∪ E → Y , source, target:E → V , and index:V → I . The functions express the labeling, the nesting and the typing in a graph. The tuple contains disjoint sets of node identifiers V , edge identifiers E , node and edge labels B , nodes and edge types Y , indexes I , and a structural correctness relation to express the nesting and associations constraints denoted by

Z = {(v, e, v ′ , i) ∈ V × E × V × I | index(v ′ ) = i ∧ source(e) = v ∧ target(e) = v ′ ∧ type(e) = cons(type(v), type(v ′ ))}.
The function cons:Y 2 → Y captures the language-specific syntax as a relation between model object types according to the metamodel. We use the relation Z to avoid the definition of an additional relation to capture the conformity relation between a model and its metamodel. For example, we write the equality cons(Collaboration, P articipant) = Contain to mean BPMN collaborations contain participants.We write cons(W ire, Ref erence) = Source and cons(W ire, Service) = T arget to express that SCA wires can be connected to references or services. 4 Which offers the vocabulary for formulating reasonings on top of models. 5 Graph transformations are proven in [START_REF] Diskin | Algebraic Models for Bidirectional Model Synchronization[END_REF] for all category of graphs.

Given a BPMN model s = (V s , E s , B s , Y s , I s , Z s ), and a SCA model t = (V t , E t , B t , Y t , I t , Z t ), we express our multivalued BPMN-to-SCA conceptual mapping with a partial function map : (Y s × I s ) → Y t where Y s denotes source types, Y t denotes target types and I s denotes model constructs indexes. We define our BPMN-to-SCA mapping relation as

CC = {(y, i, y ′ ) ∈ Y s × I s × Y t | y ′ ⊆ map(y, i)}.
For example, (Participant, * ,Component) ∈ CC means that BPMN participants map into SCA components with their nesting constraints. Also, mapping BPMN initial send tasks to SCA references is given by (SendTask,init,Reference) ∈ CC. Finally, we denote the consistency relation as a binary relation between source and target objects

C = {(o, o ′ ) ∈ (V s × V t ) ∪ (E s × E t ) | ∃i ∈ I s : (type(o), i, type(o ′ )) ⊆ CC}.

IV. AUTOMATING THE INCREMENTAL SYNCHRONIZATION

In order to sustain automated synchronizations, we have built a synchronizer which is based on three principles: change detection, change impact analysis and change propagation. We present those principles in the following sections.

A. Change Detection as Primitive Operations on Graphs

Since we relate a model to a graph, an update on a model describes a modification on a graph structure. Model evolutions can be expressed by graph rewritings [START_REF] Diskin | Algebraic Models for Bidirectional Model Synchronization[END_REF] and modeled by graph productions 6 . A production is defined through application rules which consist of in-place graph updates that are performed with a description of positive and/or negative patterns. Those conditional graph productions [START_REF] Mens | Conditional graph rewriting as a domain-independent formalism for software evolution[END_REF] are given through structural graph properties, while graph rewritings are usually defined through push-out constructions [START_REF] Diskin | Algebraic Models for Bidirectional Model Synchronization[END_REF].

Compared to our previous work [START_REF] Dahman | Towards consistency management for a business-driven development of SOA[END_REF], here, we investigate heterogeneous incremental model synchronizations. Actually, we have shown that conditional graph productions can be expressed by graph update operations in order to guarantee the correctness of the model evolution. Now, we examine in more details how to express compound model updates with primitive operations on atomic constructs. This approach offers finer model consistency management.

Operation

Precondition

Invariant Postcondition create(φ) -φ -(φ, * , * ) +φ destroy(φ) +φ -(φ, * , * ) -φ update(φ, µ, ν) -(φ, µ, ν) +φ +(φ, µ, ν) undo(φ, µ, ν) +(φ, µ, ν) +φ -(φ, µ, ν)
Table I shows a complete and minimal set of four primitive update operations and their corresponding application rules. This set is complete because we can indicate all the structural modification in a model assimilated to a graph. It is also minimal because we can not replace operations with each other to express the same update. For example, assigning the type Task and the label Order to an existing object with an identifier θ is given by update(θ, type, T ask), update(θ, label, Order).

To create an edge with identifier ω and assign a target node θ to this edge, we use create(ω), update(ω, target, θ). We also define the opposite operations for deleting an object from a graph and undoing a property of an object. The operation update can be considered as redo operation for the undo.

Our application rules include finite negative or positive application conditions that must be satisfied by each graph rewriting. Before applying an operation, it is necessary to verify invariants and verify that the precondition is fulfilled in the model that should be updated. Thereafter, the existence of positive or negative patterns has to be checked. If they are verified, invariants have to be checked and then updates can be applied and postconditions verified. For example, before applying the operation add(φ), we must avoid that an object with the same identifier φ already exists. The effect of this operation is that φ is added to the graph. Those rules allow to avoid structural conflicts by detecting contradictions between assertions. Table II presents the assertions used in Table I. The assertions are well established in the software community as a formal way to specify the applications rules for conditional graph productions [START_REF]Transformational Software Evolution by Assertions[END_REF]. In order to describe contradicting primitive operations, they are attached to graph productions operation rather than to graphs -we consider that models are related by morphisms that are totally labelpreserving, type-preserving [START_REF] Mens | Conditional graph rewriting as a domain-independent formalism for software evolution[END_REF] and root-preserving [START_REF] Biermann | Precise semantics of emf model transformations by graph transformation[END_REF]. We distinguish between positive and negative assertions to express the presence or the absence of a structural property. The negative assertions are denoted by a minus sign and mean the opposite of the positive assertions. We use wild-card assertions to express transitive constraints. For example, -(φ, * , * ) means that in order to assign properties to φ we must apply an update operation. Also, to apply an undo on a property µ with a value ν, +(φ, µ, ν) imposes that this property is already assigned to φ. Thus, we can not replace update with undo.

B. Change Detection as Compound Operation Sequences

The business analysts can edit a BPMN model in many places during a modeling session. The structural correctness checking of model updates is complex since it relates to the combinatorial explosion of the graph patterns [START_REF] Taentzer | Ensuring structural constraints in graphbased models with type inheritance[END_REF]. We decompose the model updates into primitive operations on atomic constructs. We can record their changes on a model s as a finite sequence of primitive operations that result in a model s' = U ∆S (s) such as the update

U ∆S : {δ i : S → S | δ i is a graph production } 1≤i≤n ∈ ∆ S .
In order to reduce the checking complexity and to comply with the BPMN and SCA modeling tools, we define atomic combined graph update operations as well-formed sequences of primitive operations. Tables III gives a non-exhaustive list of combinations. Combining operations provides enhanced semantics to express much meaningful updates [START_REF] Mens | Conditional graph rewriting as a domain-independent formalism for software evolution[END_REF], [START_REF] Dahman | Towards consistency management for a business-driven development of SOA[END_REF]. We state that two primitive operations in a sequence are distinct, if they affect independent model objects [START_REF] Xiong | Towards automatic model synchronization from model transformations[END_REF], [START_REF] Habel | Parallel independence in hierarchical graph transformation[END_REF]. It means that they can commute in the sequence without changing the result. The syntactic correctness of a sequence can be checked if the assertions imposed by an operation in the sequence do not contradict assertions of the earlier operations as given in Table II. An update sequence {δ i } 1≤i≤n is well-formed

7 if ∀α pi ∈ (δ k .pre ∪ δ k .inv) | 2 ≤ k ≤ n ∧ ∀α ip ∈ (δ l .inv ∪ δ l .pos) | l < k : α pi does not contradict α ip .
This definition ensures that the syntactic correctness is also maintained for a compound update. For example, the sequence {update(θ, label, Order), destroy(θ)} is ill-formed because assertion -(θ, * , * ) in the invariants of destroy(θ) contradicts the assertion +(θ, label, Order) in the postcondition of update(θ, label, Order). Actually, we have to remove all object properties before to destroy it.

Assuming that a modeling session starts with a structurally correct model which conforms to his metamodel, the resulting graph of an update should be a structurally correct model that conforms to the same metamodel. In order to check the conformity of the resulting model after applying a compound update, we verify operation sequences towards the structural correctness relation (i.e., Z in the previous section). For example, consider that adding a receive task node to the model s in Figure 1 is expressed with addNode(7, Invoice, ReceiveTask, 3, fin). This addition preserves the BPMN model structural correctness since by construction the operation addNode(v,b,y,v',i) in Table III verifies that (v,e,v',i)∈ Z s , where e is the edge inserted for nesting v in v.

C. Change Impact Analysis as Propagating Updates

In the previous section, we have defined the necessary properties to guarantee correct update applications on each of the BPMN and SCA models. In this section, we introduce the foundations for our consistency management approach. Namely, we propose a method for a change impact analysis which ensures that compound operations are propagated form BPMN to SCA models in a consistent manner.

An update operation δ ∈ U ∆S on the source model is propagated, if it forces a synchronization on the target model [START_REF] Antkiewicz | Design space of heterogeneous synchronization[END_REF]. It has to establish the consistency relation between the source model and the target model such that it preserves (U ∆S (s), U ∆T (t)) ∈ C. Therefore, our synchronizer produces update operations U ∆T on the target model such that U ∆T = interp(δ). Otherwise, δ is non-propagating. A simplified algorithm that provides the interpretation function interp is listed in Algorithm 1.

), undo(v,index,i), undo(v,type,y), undo(v,label,b), destroy(e), destroy(v) setIndex(v,i,i')

Updating the index of the node v from i to i' undo(v,index,i), update(v,index,i') setSource (e,v,v') Updating the source of the edge e from v to v' undo(e,source,v), update(e,source,v')

The algorithm is written with inference rules of the form: if premises / then conclusions . The premises refer to operations and conditions on the source BPMN model, and conclusions refers to the propagating operations on the target model. As stated in Section III, our incremental synchronizer takes as parameters an update on the source model U ∆S ∈ ∆ S (U ∆S (s) = s ′ ) and two consistent models such (s, t) ∈ C. Rather than executing the entire novel transformation, it enforces an in-place synchronization by interpreting U ∆S into a target update U ∆T ∈ ∆ T (t ′ = U ∆T (t)) to get t ′ consistent with s' such (s ′ , t ′ ) ∈ C holds. It interprets U ∆S into U ∆T and then propagates them to t.

Algorithm 1: Algorithm of the interpretation function. in :

U ∆S out : U ∆T foreach δ ∈ U ∆S do / * Initially U ∆T = ∅ * / 1 if δ=addNode(v, b, y, v ′ , i) ∧ (v ′ , v ′′ ) ∈ C ∧ (y, i, y ′ ) ∈ CC then (v, v ′′′ ) ∈ C ∧ addNode(v ′′′ , b, y ′ , v ′′ , i) ∈ U ∆T else C ← C ∪ (v, ∅) / * δ is non-propagating * / 2 if δ=insertEdge(e, b, y, v, v ′ ) ∧(v, v ′′ ), (v ′ , v ′′′ ) ∈ C ∧ (y, * , y ′ ) ∈ CC then (e,e') ∈ C ∧ insertEdge(e ′ , b, y ′ , v ′′ , v ′′′ ) ∈ U ∆T else C ← C ∪ (e, ∅) / * δ is non-propagating * / 3 if δ=setIndex(v, i, i ′ ) ∧ (v, v ′ ), (v, v ′′ ) ∈ C∧ (y, i, y ′ ), (y, i ′ , y ′′ ) ∈ CC then dropNode(v, b, y, v ′ , i), addNode(v ′ , b, y ′′ , v ′′ , i ′ ) ∈ U ∆T 4 if δ=setSource(e, v, v ′ ) ∧ (e, ∅), (v ′ , v ′′ ), (v ′′′ , v ′′′′ ) ∈ C ∧ (y, * , y ′ ) ∈ CC then (e, e ′ ) ∈ C ∧ insertEdge(e ′ , b, y ′ , v ′′ , v ′′′′ ) ∈ U ∆T
In order to illustrate our interpretation algorithm, consider that the BPMN model s is altered to s' (i.e., the case study of Figure 2) with the well-formed update sequence for s' in the Figure 4. The setIndex (7, fin, init, 3) is interpreted to dropNode [START_REF] Dahman | Generation of Component Based Architecture from Business Processes: MDE for SOA[END_REF][START_REF] Lopes | Generating transformation definition from mapping specification: Application to web service platform[END_REF], addNode(5,Invoice,Service,2,init) for t' by the rule in line 4. It supposes that a propagating operation addNode(7, Invoice, ReceiveTask, 3, fin) on s was already translated to addNode(5, Invoice, ReferenceCallback, 4, fin) on t such C contains [START_REF] Biermann | Precise semantics of emf model transformations by graph transformation[END_REF][START_REF] Dahman | Generation of Component Based Architecture from Business Processes: MDE for SOA[END_REF]. The rule in the line 5 translates setSource [START_REF] Huemer | Interorganizational systems: From business values over business processes to deployment[END_REF][START_REF] Habel | Parallel independence in hierarchical graph transformation[END_REF][START_REF] Omg | Meta Object Facility (MOF) 2.0 Query/View/Transformation Specification[END_REF] into a propagating insertion of the edge with a label C3 in t' and updates C with [START_REF] Huemer | Interorganizational systems: From business values over business processes to deployment[END_REF][START_REF] Antkiewicz | Design space of heterogeneous synchronization[END_REF].

Note that the consistency relation C serves as a working memory for tracking the interpretation of the update operations and transformation history-awareness. It keeps track of objects and links of the source model and their counterparts in the target model. The synchronizer locates the corresponding constructs in the transformation working memory that are affected by the source update. With the correspondence identified in the mapping relation CC, it computes in-place operations on the target with values from the source. Due to our partial mapping, some updates on the source model -which involve BPMN types without corresponding SCA types -are not propagated to the target model. For example, the BPMN constructs such as gateways have no counterparts in the SCA space because they are not relevant for the SCA configuration topology. Thus, when an operation is non-propagating, the working memory C is updated with a tuple (*,∅) to mean that the BPMN objects have no counterparts in SCA.

D. Change Propagation as Interpreting Updates

Finally, as depicted in Figure 3, our incremental synchronizer computes the traget model t'= sync(s, t, U ∆S ) such as the updates U ∆S and U ∆T produce consistent models. It establishes the consistency relation (U ∆S (s),t ′ ) ∈ C by propagating the U ∆T to the target model t. It adapt the SCA model t by computing t'= U ∆T (t) rather than executing the full transformation of the BPMN model. We see that the benefits of such a MDE approach include generating a roadmap, namely the delta U ∆T , to adapt the component configurations when business settings evolve. In practice, the SOA development stakeholders can rapidly assess the necessity to propagate adaptation of the SCA models into the application code by making different updates on the BPMN models. To help them to make rational decisions, we propose a tool to simulate and to evaluate this change impact of the different business evolutions that can be modeled in the business process models. This tool support is presented in the following section.

V. TOOL SUPPORT IMPLEMENTATION AND EVALUATION

In this section, we describe a proof-of-concept implementation of our principles (change detection, change impact analysis and change propagation) for a tool that sustains automated synchronizations. We also provide a theoretical and experimental evaluation of our synchronizer.

We have implemented our synchronizer as an extension to a BPMN Editor [START_REF]Yaoqiang bpmn editor[END_REF] to demonstrate that it can be integrated business process modeling suites. The editor is used to model a source BPMN and model. We have developed a filter that logs the primitive BPMN editing operation sequences. After applying our interpretation algorithm, we obtain a graph editing operation sequence that manipulates SCA constructs. We apply this sequence to another graph to produce the SCA model. We have implemented our interpretation algorithm in the Drools [22] rules engine. Due to this implementation we could meet the synchronization execution criteria presented in Section III. The interpretation function is based on the decidability and confluence offered by the Rete algorithm [22] implemented in Drools. The uniformity and validity criteria are verified by construction since the interp algorithm produces consistent models according to the conceptual mapping. We support conformity through the (primitive and combined) update operations that we have defined. We support the requirement of stability since we prohibit the application of the same update operations with specific conditions. We satisfy autonomy and idempotence since we assimilate model to graphs and their updates to conditional graph productions.

Our synchronizer behaves like a model transformation engine. Consider that two empty BPMN and SCA models are consistent. Building the BPMN model means applying BPMN updates that are contained in a non empty operation sequence. Synchronizing the two empty models with the BPMN update sequence produces the SCA update sequence which generates the SCA model. However, taking into account a source update sequence U ∆S on the source BPMN model that gives s ′ , the effort to interpret those updates, O(size(U ∆S )), should be lower than computing a full transformation of the altered source model, O(size(s ′ )). It results in a reasonable decoupling from the source model size when size(U ∆S ) ≤ size(s ′ ) . Thus, when the source update is small, it usually corresponds to a small target update, and the performance improvement to interpret the update operations is expected to be high.

In order to experiment our incremental synchronizer, we use the size of update operations as a metric to quantify the size of models and their changes. The size of a model (i.e., cardinal of objects and links) can be quantified by making a difference between the number of create operations and destroy operations in the sequence which represents that model. The size of a change (i.e., the number updates) is similarly calculated from the sequence which represents that change. This metric is independent from the experimental environment considerations. Our experimental evaluations consist in generating random update sequences for 1000 BPMN models and 1000 BPMN changes. In this way, the size size(U ∆S ) of the generated updates is independent from the size size(s) of the generated models. The generated models do not contain meaningful business logic, however they conform the BPMN metamodel. The operation sequences are randomized to have different sizes in such a way they equally likely overlap with the BPMN-SCA mapping. Then, we pass the update sequences representing the BPMN models (i.e., s in Figure 3) into our synchronizer to obtain the update sequences representing the SCA models (i.e., t in Figure 3). Again, we enforce interpretations of the update sequences representing the BPMN changes (i.e., U ∆S in Figure 3). This results in the update sequences representing the SCA changes (i.e., U ∆T in Figure 3). We can sum the update sequences of size(s) and size(U ∆S ) to obtain size(s ′ ). Summing size(t) and size(U ∆T ) gives size(t ′ ).

The Figure 5 plots the distribution of BPMN models size size(s ′ ) (blue cloud) and BPMN change size size(U ∆S ) (red cloud) against the fraction size(U∆ S ) size(s ′ ) . It also plots the distribution of SCA models sizes size(t ′ ) (yellow cloud) and SCA change sizes size(U ∆T ) (green cloud) against the fraction size(U∆ T ) size(t ′ ) . This figure gives two interesting observations. First, it confirms that our synchronizer implements a partial function due to the BPMN-SCA mapping, since size(t ′ ) ≤ size(s ′ ) (yellow and blue clouds) and size(U ∆T ) ≤ size(U ∆S ) (green and red clouds). Second, it illustrates the efficiency frame of the incremental synchronization. Actually, when size(U ∆S ) size(s ′ ) (i.e., the left side of the black lane) it is less complex to interpret the BPMN updates (red cloud) than the BPMN models (blue cloud). Otherwise, the size of the SCA updates (green cloud) becomes greater than the size of SCA models (yellow cloud). This empirical observations confirm the expected behavior of our synchronizer. Also, an unexpected behavior arises in the practical experiments. It concerns an almost linearity between the factors size(s ′ ) size(s) and size(t ′ ) size(t) . Since the generated updates are not correlated to the models (i.e., s ′ are not proportional to s), then this supports that our synchronization behaves like a transformation. Evidently, there are some limitations inherent to our operation-based method when size(U ∆S ) > size(s ′ ). For example, when adding two BPMN elements and deleting one of them it is less interesting to translate three operations than transforming the model (i.e., by neglecting the diff effort). To address this scalability issue we can reduce the update sequences by eliminating the redundancy and enforcing distinct operations. For example, an addition of a node followed by an update of node's attributes can be resolved to a single addition with the appropriate attributes. Also, opposite operations can be discarded. This normalization [START_REF]Transformational Software Evolution by Assertions[END_REF] algorithm is decoupled from the synchronizer since it is integrated with the BPMN editing operations filter. We refer the reader to [START_REF] Giese | From model transformation to incremental bidirectional model synchronization[END_REF], [START_REF] Diskin | Algebraic Models for Bidirectional Model Synchronization[END_REF] for further discussions on the scalability concerns.

VI. RELATED WORK

Building cross-organizational business systems with an SOA [START_REF] Papazoglou | Serviceoriented computing: State of the art and research chall[END_REF] that leverage the service-enabled process management best practices [START_REF] Dumas | Service-enabled process management[END_REF] implies a range of technical and methodological issues. First of all, the alignment between business settings and application functions has to be achieved with a Service Dominant Logic [START_REF] Chen | From software architecture analysis to service engineering: An empirical study of methodology development for enterprise soa implementation[END_REF]: the Service-Oriented Software Engineering. This requirement should drive the production of the business services to achieve desired business processes. Second, business processes evolution is an aspect which affects the software life-cycle. There are many ways to change software artifacts. They range from the requirements evolution of the business processes to the SOA and the source code. Several frameworks have emerged to help organizations to charter successful route to Service-Oriented Computing [START_REF] Papazoglou | Serviceoriented computing: State of the art and research chall[END_REF]. The Model-Driven Architecture provides a mean for using UMLbased transformations to drive the Service-Oriented Software Engineering [START_REF] Lopes | Generating transformation definition from mapping specification: Application to web service platform[END_REF]. However, as UML is neither fully serviceoriented, nor business process-centered, it needs to address the gap between the emerging standard notations and the lowerlevel standards. A methodology suggested in [START_REF] Huemer | Interorganizational systems: From business values over business processes to deployment[END_REF] advocates the integration of the business values perspective to Service-Oriented Computing. It defines a methodology for the business process space, but unfortunately fails to provide a practical development scenario. Also, some attempts [START_REF]Soa platform project[END_REF] provide tools to transform BPMN to SCA models. Unfortunately, they do not consider collaborative processes transformations and do not provide a mean for incremental model synchronizations.

To our knowledge, there is no tools providing automated incremental synchronization and change impact analysis framework with an advanced BPMN-to-SCA mapping. Only the general model synchronization frameworks [START_REF] Xiong | Towards automatic model synchronization from model transformations[END_REF] were used for the consistency management among heterogeneous models. Those frameworks give a general representation of the model updates, but rely on users to write code to handle each type of the modification in each metamodel [START_REF] Dahman | Towards consistency management for a business-driven development of SOA[END_REF]. Furthermore, QVT standard [START_REF] Omg | Meta Object Facility (MOF) 2.0 Query/View/Transformation Specification[END_REF] encourages to use external model synchronizer. In our case, the synchronizer extracts informations automatically from previous model transformations and does not require users to write more synchronization code. Graph transformation theory allows us to compute conflicts and dependencies of transformation by relying on the idea of critical pair of operations (i.e., on two assorted models) analysis. Research conducted in the area of conditional graph rewriting [START_REF] Giese | From model transformation to incremental bidirectional model synchronization[END_REF], [START_REF] Biermann | Precise semantics of emf model transformations by graph transformation[END_REF] has mainly been driven by theoretical computer scientists who put an emphasis on developing sound theory [START_REF] Diskin | Algebraic Models for Bidirectional Model Synchronization[END_REF]. However, change propagation across heterogeneous software models remains an open problem [START_REF] Xiong | Towards automatic model synchronization from model transformations[END_REF]. In [START_REF] Mens | Conditional graph rewriting as a domain-independent formalism for software evolution[END_REF], the operation-based graph productions were used to express refactoring software transformations and their evolution. The usage of the assertions facilitates the detection of the syntactic merge conflicts when transforming the graphs. The graph transformations are executed in a uniform and scalable way. However, this technique is mainly focused on homogeneous model transformation, i.e., where the source and target models conform to the same metamodel. In our work, we perform a more thorough investigation on the heterogeneous incremental model synchronization.

VII. CONCLUSION AND FUTURE WORK

Providing sound and effective ways to maintain the alignment between the business logic and its supporting software architectural logic is a challenge. It has become an important challenge today where services are pervasive and where BPM is mainstream in large companies strategy. In this paper, we have tackled this issue from the perspective of the relation between business process modeling and evolution and the corresponding Service Component Architecture design. Our approach not only allows to derive a component architecture from a business process collaboration, but, as demonstrated in this paper, allows to incrementally maintain this relation even in case of business evolutions. We have shown that a modeldriven approach can be used to derive an abstract service architecture from a business process. It also serves to maintain their alignment when the process model is incrementally updated. By deriving changes that have to be applied to the architecture, we avoid to recreate an entire transformation. Our framework is integrated to a change impact simulation and analysis tool which is based on graph rewriting technique to avoid the inconsistencies caused by change propagations. Finally, we propose metrics for measuring the impact of business process evolutions on SOA maintenance and demonstrating model transformation/synchronization efficiency which ensures knowledgeable change governance. The scope of our contribution is limited so far to the Service-Oriented Software Engineering that uses BPMN and SCA languages. However, it can be generalized to other domain-specific languages and further domain modeling.

This work raises important questions. For example, if the behavioural properties (deadlock, controllability [START_REF] Van Der Aalst | Service Interaction: Patterns, Formalization, and Analysis[END_REF], etc) on a business process can be verified at design-time, are they still valid for the component configuration at the execution-time. Likewise, how IT developers can adapt their assets without losing design decisions and diverging from the business settings. We are also thinking about using it to consider the cloud as the runtime framework where SCA is used for integrating composite applications with the service delivery platform.

Fig. 1 .

 1 Fig. 1. BPMN-to-SCA model transformation example.

Fig. 2 .

 2 Fig. 2. BPMN and SCA model evolution use case.

Fig. 3 .

 3 Fig. 3. Formalization of the incremental model synchronization.

dropNode ( 5 ,Fig. 4 .

 54 Fig. 4. Update operations and consistency relations of Fig 2.

Fig. 5 .

 5 Fig. 5. Incremental synchronisation efficiency.

Accounting SCA Constructs Source BPMN Collaboration Model

		Customer	Order			Invoice	Shipper	Shipping Request	Shipping Schedule
					C2 C1		C3 C4	Ordering	Shipping
		Supplier	Order	Calculation Price Initiate Invoice	Complete Price Calculation	Invoice Process Request Shipping Schedule	Shipping Schedule
						Accounting
		Supply Network	Invoicer		Request Calculation	Shipping Price	Final Price	s
	Target SCA	Assembly	Model	Network Supply	Customer	Supplier Ordering	Shipping	Shipper	Invoicer	t
	Legend
	BPMN Constructs	Sequence Flow Conversation Conversation Link Process Participant Gateway Collaboration	Start End Send Task Receive Task initial final	BPMN Collaboration Participant Process Send Task Receive Task Conversation Conceptual Mapping Composite SCA Component Implementation Reference or Callback Service or Callback Wire	Service Reference Callback Wire Implementation Composite Component

TABLE I PRIMITIVE

 I UPDATE OPERATIONS AND THEIR APPLICATION RULES.

TABLE II LIST

 II OF ASSERTIONS AND THEIR CONTRADICTIONS.

	Assertion	Notation	Contradicts
	Object φ exists	+φ	-φ
	Object φ has ν as a value for µ	+(φ, µ, ν)	-(φ, µ, ν)
	Object φ has no properties	-(φ, * , * )	+(φ, µ, ν)

TABLE III COMBINATIONS

 III OF PRIMITIVE UPDATE OPERATIONS.

	Compound Operation	Description	Primitive Operations
	addNode(v,b,y,v',i) insertEdge(e,b,y,v,v') dropNode(v,b,y,v',i)	Adding a node v of type y nested in node v' with a label b and an index i Inserting an edge e with a label b and a type y between nodes v and v' Deleting an existing node v from node v'	add(v), update(v,label,b), update(v,type,y), update(v,index,i), add(e), update(e,type,Contain), update(e,source,v'), update(e,target,v) add(e), update(e,label,b), update(e,type,y), update(e,source,v), up-date(e,target,v') undo(e,type,Contain), undo(e,source,v'), undo(e,target,v

We mainly focus on the mapping of sequence and message flows, and put the transformation of data flows between into language-agnostic data structures (being generated) out of this article's scope.

We assume well-formed and well-behaved business processes[START_REF] Van Der Aalst | Service Interaction: Patterns, Formalization, and Analysis[END_REF],[START_REF] Puhlmann | Investigations on soundness regarding lazy activities[END_REF].

There maybe multiple SCA models for the same BPMN model[START_REF] Dahman | From business process to component architecture: Engineering business to it alignment[END_REF].

They are based on the concept of gluing graphs and graph morphisms[START_REF] Diskin | Algebraic Models for Bidirectional Model Synchronization[END_REF]. They describe how to modify a right-hand graph to produce a related left-hand graph with forward transformations[START_REF] Biermann | Precise semantics of emf model transformations by graph transformation[END_REF].

pre, post and inv represent the assertion sets shown in TableIII.