},
MessageList{
getShipmentQuote { Retailer -> Shipper : GetShipmentQuote}, shipmentQuote { Shipper -> Retailer : ShipmentQuote}
} },
Peerset{
Shipper{
States{sh1,sh2,sh3}, InitialState {sh1}, FinalStates{sh3}, TransitionRelation{
t_sh1{ sh1 -> sh2 : getShipmentQuote, Guard{ true }
},
t_sh2{ sh2 -> sh3 : shipmentQuote, Guard{ true }
} } } } }
A.2 Inventory
Bottomup { Schema{
PeerList{Inventory, Retailer}, TypeList{
CatalogRequest[
getCatalogRequest[xsd:bool]
],
CatalogResponse[
productList[
product [xsd:string], productID[xsd:int], price [xsd:int]
]{1,10}
],
CheckAvailability[
productList[
product [xsd:string], productID[xsd:int], quantity [xsd:int]
]{1,10}
],
Availability[
productID [xsd:int], available [xsd:bool]
] },
MessageList{
catalogRequest { Retailer -> Inventory : CatalogRequest}, catalogResponse { Inventory -> Retailer : CatalogResponse}, checkAvailability { Retailer -> Inventory : CheckAvailability}, availability { Inventory -> Retailer : Availability }
} },
%- set of guarded automata Peerset{
Inventory{
States{si1,si2,si3,si4,si5}, InitialState {si1},
FinalStates{si5}, TransitionRelation{
ti1{ si1 -> si2 : catalogRequest,
Guard{ true } },
ti2{ si2 -> si3 : catalogResponse, Guard{ true }
},
ti3{ si3 -> si4 : checkAvailability, Guard{ true }
},
ti4{ si4 -> si5 : availability, Guard{ true }
} } } } }
A.3 Bank
Bottomup { Schema{
PeerList{Bank,Retailer}, TypeList{
GetAccCredib[
bankaccount[
accountID [xsd:int], accountType[xsd:int]
] ],
AccCredib[
balance[xsd:int]
],
GetCCCredib[
creditcard[
number [xsd:int], expiryMonth [xsd:int], expiryMonth [xsd:int]
] ],
CCCredib[
balance[xsd:int]
] },
MessageList{
getAccCredib { Retailer -> Bank: GetAccCredib}, accCredib { Bank -> Retailer: AccCredib},
getCCCard { Retailer -> Bank: GetCCCredib}, ccCredib { Bank -> Retailer: CCCredib}
} },
Peerset{
Bank{
States{sb1,sb2,sb3,sb4}, InitialState {sb1}, FinalStates{sb3}, TransitionRelation{
t_b1{ sb1 -> sb2 : getAccCredib, Guard{ true }
},
t_b2{ sb2 -> sb3 : accCredib, Guard{ true }
},
t_b3{ sb1 -> sb4 : getCCCredib, Guard{ true }
},
t_b4{ sb4 -> sb3 : ccCredib, Guard{ true }
} } } } }
Operation Semantics of Change Operators
This appendix contains all the operation semantics for all basic change op-erators specified in Table 3.2 in Chapter 3.
B.1 Protocol
Addition of a state:
addState(si)
< S, s0, F, M, T >→< S ∪ si, s0, F, M, T >
Removal of a state:
removeState(si)
< S, s0, F, M, T >→< S − si, s0, F, M, T >
Addition of a transition:
addTrans(si, m, sj)
< S, s0, F, M, T >→< S, s0, F, M, T ∪ (si, sj, m) >
Removal of a transition:
removeTrans(si, m, sj)
< S, s0, F, M, T >→< S, s0, F, M, T − (si, sj, m) >
Addition of a message:
addMsg(rec, sen, g)
< S, s0, F, M, T >→< S, s0, F, M∪ (rec, sen, g), T >
Removal of a message:
removeMsg(rec, sen, g)
< S, s0, F, M, T >→< S, s0, F, M− (rec, sen, g), T >
Note that there are three types of states in a graph, namely initial, final and normal. The final states and initial state are respectively a subset and an element of the set of states, for this reason they are not specified explicitly here.
B.2 Type
In the above we have given the operation semantics from a set-theoretic per-spective. For type we do the same. However, because we defined it before as a grammar, we can not use the above directly. We therefore express a gram-mar as a single set containing only types (E). An type is then specified as:
e = (t, d, p, x, y, c) where t is the tag (name) of the element, d the datatype, p denotes the location between other elements (as defined by Xpath in Section 3.4.1), the minimum and maximum cardinality (x and y respectively) and c∈ {seq, choice} a structural constraint which can be either a sequence or a choice. Using this set, we define the operators as follows:
Addition of a type:
addType(τ, d, p) E → E ∪ (τ, d, p, 1, 1, seq)
When adding a type, the constraints gets the standard values for the con-straints, which is 1 for the cardinality and seq for the structural constraint.
Removal of a type:
removeType(τ, p)
E∪ (τ, d, p, x, y, c) → E\(τ, d, p, x, y, c) Update cardinality:
updateCC(x, y, p)
{E ∪ (τ, d, p, x′, y′, c)} → {E ∪ (τ, d, p, x, y, c)}\(τ, d, p, x′, y′, c) Update structural constraint:
updateSC(cs, p)
{E ∪ (τ, d, p, x, y, c)} → {E ∪ (τ, d, p, x, y, cs)}\(τ, d, p, x, y, c)
Specification of Business Requirements
This appendix contains the specification of the example business rules and target protocol used throughout the thesis. They are in the format described in Section 5.5.
C.1 Business Rules
Bottomup { Schema{
PeerList{BR2,BR3}, TypeList{
Acceptance[
acceptance[xsd:bool]
],
Rejected[
rejected[xsd:bool]
] },
MessageList{
accept { BR2-> BR2: Acceptance}, reject { BR3-> BR3: Rejected}
}
},
Peerset{
BR2{
States{sbr21,sbr22}, InitialState {sbr21}, FinalStates{sbr22}, TransitionRelation{
t_br21{ sbr21-> sbr22: accept,
Guard{ $availability/Availability[available = true] and
$getAccCredib/GetAccCredib[balance > 0] and
$shipmentQuote/ShipmentQuote[shipmentID > 0] =>
$accept[
//acceptance:= true ]}
} } }, BR3{
States{sbr31,sbr32}, InitialState {sbr31}, FinalStates{sbr32}, TransitionRelation{
t_br31{ sbr31-> sbr32: reject,
Guard{ $availability/Availability[available = false] or
$getAccCredib/GetAccCredib[balance < 0] or
$shipmentQuote/ShipmentQuote[shipmentID <= 0] =>
$reject[
//rejected:= true ]}
} } }
}
C.2 Target Protocol
Bottomup { Schema{
PeerList{Customer,Retailer}, TypeList{
GetCatalog[
getCatalogRequest[xsd:bool]
],
Catalog[
productList[
product [xsd:string], productID[xsd:int], price [xsd:int]
]{1,10}
], Order[
customer[
name [xsd:string], address[
streetName [xsd:string], zipcode [xsd:string], city [xsd:string], country [xsd:string]
],
bankaccount[
accountID [xsd:int], accountType[xsd:int]
] ],
productList[
product [xsd:string], productID[xsd:int], price [xsd:int], quantity [xsd:int]
]{1,10}
],
OrderAccept[
acceptance [xsd:bool]
],
OrderReject[
rejected [xsd:bool]
] },
MessageList{
getCatalog { Customer -> Retailer : GetCatalog }, catalog { Retailer -> Customer : Catalog },
order { Customer -> Retailer : Order },
orderAccept { Retailer -> Customer : OrderAccept }, orderReject { Retailer -> Customer : OrderReject } }
},
Peerset{
Customer{
States{sc1,sc2,sc3,sc4,sc5,sc6}, InitialState {sc1},
FinalStates{sc5,sc6}, TransitionRelation{
t_c1{ sc1 -> sc2 : getCatalog, Guard{ true }
},
t_c2{ sc2 -> sc3 : catalog, Guard{ true }
},
t_c3{ sc3 -> sc4 : order, Guard{ true }
},
t_c4{ sc4 -> sc5 : orderReject,
Guard{ $reject/Rejected[rejected = true]}
},
t_c5{ sc4 -> sc6 : orderAccept,
Guard{ $accept/Acceptance[acceptance = true]}
} }
} } }
Specification of the Retailer
This appendix contains of the our example orchestrator, the retailer, as cre-ated by the composition operator discussed in Chapter 4. It is in the format described in Section 5.5. Note that we omit here the specifications of ser-vices and the typelist as they are identical to the ones that were given in Appendix A and Appendix C.
Bottomup{
Schema{
PeerList { Retailer, Customer, Shipper, Bank, Inventory}
TypeList {}
MessageList {
accept { Retailer -> Retailer: Acceptance},
shipmentQuote { Shipper-> Retailer: ShipmentQuote}, getShipmentQuote {Retailer-> Shipper: GetShipmentQuote}, getAccCredib { Bank-> Retailer: GetAccCredib},
accCredib { Retailer-> Bank: AccCredib}, reject { Retailer-> Retailer: Rejected},
availability { Inventory-> Retailer: Availability},
checkAvailability { Retailer-> Inventory: CheckAvailability}, catalogResponse { Inventory-> Retailer: CatalogResponse}, catalogRequest {Retailer-> Inventory: CatalogRequest}, getCatalog {Customer-> Retailer: GetCatalog},
catalog { Retailer-> Customer: Catalog}, order { Customer-> Retailer: Order},
orderAccept {Retailer-> Customer: OrderAccept},
orderReject { Retailer-> Customer: OrderReject}
} },
Peerset{
Retailer{
States{sc1, sc2, si2, si3, sc3, sc4, si4, si5, sbr32, sc5, sb2, sb3, sh2, sh3, sbr22,sc6}
InitialState{sc1}
FinalStates{sc5, sc6}
TransitionRelation{
t_c1{ sc1 -> sc2: catalogRequest Guard { true }
},
ti1{ sc2 -> si2: getCatalog Guard { true=>
getCatalog [
/GetCatalogRequest/getCatalogRequest :=
/GetCatalog/getCatalogRequest ]
} },
ti2{ si2 -> si3: catalogResponse Guard { true }
},
t_c2{ si3 -> sc3: catalog Guard { true=>
catalog [
/Catalog/productList/product :=
/CatalogResponse/productList/product /Catalog/productList/productID :=
/CatalogResponse/productList/productID /Catalog/productList/price :=
/CatalogResponse/productList/price ]
}
},
t_c3{ sc3 -> sc4: order Guard { true } },
ti3{ sc4 -> si4: checkAvailability Guard { true=>
checkAvailability [
/CheckAvailability/productList/product :=
/CatalogResponse/productList/product /CheckAvailability/productList/productID :=
/CatalogResponse/productList/productID /CheckAvailability/productList/quantity :=
/Order/productList/quantity ]
} },
ti4{ si4 -> si5: availability Guard { true }
},
ot_7{ si5 -> sbr32: reject
Guard { (( $availability/Availability
[( available == false) ] ||
$accCredib/AccCredib
[( balance < 0) ]) ||
$shipmentQuote/ShipmentQuote [( shipmentID <= 0) ]) =>
reject [
//rejected := true ]
} },
t_c4{ sbr32 -> sc5: orderReject
Guard { $reject/Rejected [( rejected == true) ]=>
orderReject [
/OrderReject/rejected := /Rejected/rejected ]
} },
t_b1{ si5 -> sb2: getAccCredib Guard { true=>
getAccCredib [
/GetAccCredib/bankaccount/accountID :=
/Order/payment/bankaccount/accountID /GetAccCredib/bankaccount/accountType :=
/Order/payment/bankaccount/accountType /GetAccCredib/name := /Order/customer/name ]
} },
t_b2{ sb2 -> sb3: accCredib Guard { true }
},
ot_11{ sb3 -> sbr32: reject
Guard { (( $availability/Availability
[( available == false) ] ||
$accCredib/AccCredib
[( balance < 0) ]) ||
$shipmentQuote/ShipmentQuote [( shipmentID <= 0) ]) =>
reject [
//rejected := true ]
} },
t_sh1{ sb3 -> sh2: getShipmentQuote Guard { true=>
getShipmentQuote [
/GetShipmentQuote/productList/productID :=
/CatalogResponse/productList/productID
/GetShipmentQuote/productList/quantity :=
t_sh2{ sh2 -> sh3: shipmentQuote Guard { true }
},
ot_14{ sh3 -> sbr22: accept
Guard {(($availability/Availability
[( availibility == true) ] &&
$accCredib/AccCredib
[( balance < 0) ]) &&
$shipmentQuote/ShipmentQuote [( shipmentID < 0) ])=>
accept [
//acceptance := true ]
} },
t_c5{ sbr22 -> sc6: orderAccept Guard { $accept/Acceptance
[( acceptance == true) ]=>
orderAccept [
/OrderAccept/acceptance :=
/Acceptance/acceptance ]
}
},
ot_16{ sh3 -> sbr32: reject
Guard { (( $availability/Availability
[( available == false) ] ||
$accCredib/AccCredib
[( balance < 0) ]) ||
$shipmentQuote/ShipmentQuote [( shipmentID <= 0) ]) =>
reject [
//rejected := true ]
} } } } }}
Ackfor, R. & Emery, F. (1972). On Purposeful Systems. Adline Atherton.
Ader, M. (2004). Workflow Comparative Study. Waria.
Agarwal, V., Chafle, G., Mittal, S., & Srivastava, B. (2008). Understanding Approaches for Web Service Composition and Execution. In Compute ’08:
Proceedings of the 1st Bangalore annual Compute conference (pp. 1–8).
Aggarwal, R., Verma, K., Miller, J., & Milnor, W. (2004). Constraint Driven Web Service Composition in METEOR-S. In SCC ’04: Proceedings of IEEE International Conference on Services Computing (pp. 23–30).
Aït-Bachir, A., Dumas, M., & Fauvet, M.-C. (2009). Detecting Behavioural Incompatibilities between Pairs of Services. In WESOA ’08: Fourth In-ternational Workshop on Engineering Service-Oriented Applications (pp.
79–90).
Aksit, M. & Choukair, Z. (2003). Dynamic, Adaptive and Reconfigurable Systems Overview and Prospective Vision. In ICDCSW ’03: Proceedings of the 23rd International Conference on Distributed Computing Systems (pp. 84–90).
Alonso, G., Casati, F., Kuno, H., & Machiraju, V. (2004). Web Services:
Concepts, Architectures and Applications. Springer-Verlag.
Andrews, T., Dholakia, H., Goland, Y., Klein, J., Liu, K., Roller, D., Smith, D., Thatte, S., Trickovic, I., & Weerawarana, S. (2003). Business Process Execution Language for Web Services, Version 1.1.
Andrikopoulos, V., Benbernou, S., & Papazoglou, M. P. (2008). Managing the Evolution of Service Specifications. In CAISE ’08:Proceedings of the
20th international conference on Advanced Information Systems Engineer-ing (pp. 359–374).
Andrikopoulos, V., Benbernou, S., & Papazoglou, M. P. (2009). Evolving Services from a Contractual Perspective. In CAISE ’09: Proceedings of the 21st International Conference on Advanced Information Systems En-gineering (pp. 290–304).
Anthony, R. J. (2009). Policy-based Autonomic Computing with Integral Support for Self-Stabilisation. International Journal of Autonomic Com-puting, 1(1), 1–33.
Antonellis, V. D., Melchiori, M., Santis, L. D., Mecella, M., Mussi, E., Per-nici, B., & Plebani, P. (2006). A Layered Architecture For Flexible Web Service Invocation. Software: Practice and Experience, 36(2), 191–223.
Ardagna, D., Comuzzi, M., Mussi, E., Pernici, B., & Plebani, P. (2007).
PAWS: A Framework for Executing Adaptive Web-Service Processes.
IEEE Software, 24(6), 39–46.
Arsanjani, A. (2005). Toward a Pattern Language for Service-Oriented Ar-chitecture and Integration, Part 2: Service Composition. http://www.
ibm.com/developerworks/webservices/library/ws-soa-soi2/.
Ashby, W. R. (1960). Design for a Brain, 2nd Edition. Chapman & Hall.
Avizienis, A., Laprie, J.-C., Randell, B., & Landwehr, C. (2004). Basic Concepts and Taxonomy of Dependable and Secure Computing. IEEE Transactions on Dependable and Secure Computing, 1(1), 11–33.
Bae, J., Bae, H., Kang, S.-H., & Kim, Y. (2004). Automatic Control of Workflow Processes Using ECA Rules. IEEE Transactions on Knowledge and Data Engineering, 16(8), 1010–1023.
Baldoni, M., Baroglio, C., Chopra, A. K., Desai, N., Patti, V., & Singh, M. P. (2009). Choice, Interoperability, and Conformance in Interaction Protocols and Service Choreographies. In AAMAS ’09: Proceedings of the 8th International Joint Conference on Autonomous Agents and Multiagent Systems (pp. 843–850).
Bandinelli, S., Nitto, E. D., & Fuggetta, A. (1994). Policies and Mechanisms to Support Process Evolution in PSEEs. In ICSP3 : Proceedings of the 3rd IEEE International Conference on the Software Process (pp. 9–20).
Baresi, L., Guinea, S., & Pasquale, L. (2007a). Self-healing BPEL Processes with Dynamo and the JBoss Rule Engine. In ESSPE ’07: International Workshop on Engineering of Software Services for Pervasive Environments (pp. 11–20).
Baresi, L., Guinea, S., Pistore, M., & Trainotti, M. (2009). Dynamo + Astro:
An Integrated Approach for BPEL Monitoring. In ICWS ’09:Proceedings of the 2009 IEEE International Conference on Web Services (pp. 230–237).
Baresi, L., Nitto, E. D., Ghezzi, C., & Guinea, S. (2007b). A Framework for the Deployment of Adaptable Web Service Compositions. Service Oriented Computing and Applications, 1(1), 75–91.
Baryannis, G., Carro, M., Danylevych, O., Dustdar, S., Karastoyanova, D., Kritikos, K., Leinter, P., Rosenberg, F., & Wetzstein, B. (2008). Overview of the State of the Art in Composition and Coordination of Services. De-liverable PO-JRA-2.2.1, S-Cube Consortium.
Becker, K., Lopes, A., Milojicic, D. S., Pruyne, J., & Singhal, S. (2008). Au-tomatically Determining Compatibility of Evolving Services. In ICWS ’08:
Proceedings of the 2008 IEEE International Conference on Web Services (pp. 161–168).
Bellwood, T., Capell, S., Clement, L., Colgrave, J., Dovey, M. J., Feygin, D., Hately, A., Kochman, R., Macias, P., Novotny, M., Paolucci, M., von Riegen, C., Rogers, T., Sycara, K., Wenzel, P., &
Wu, Z. (2004). Universal Description Discovery Integration (Version 3). http://www.oasis-open.org/committees/uddi-spec/doc/spec/
v3/uddi-v3.0.2-20041019.htm.
Benatallah, B., Casati, F., Grigori, D., Nezhad, H. R. M., & Toumani, F.
(2005). Developing Adapters for Web Services Integration. In CAISE ’05:
Proceedings of the 17th International Conference on Advanced Information Systems Engineering (pp. 415–429).
Benatallah, B., Casati, F., & Toumani, F. (2004a). Analysis and Man-agement of Web Service Protocols. In ER ’04: Proceedings of the 23rd International Conference on Conceptual Modeling (pp. 524–541).
Benatallah, B., Casati, F., & Toumani, F. (2004b). Web Service Conversa-tion Modeling: A Cornerstone for E-Business AutomaConversa-tion. IEEE Com-puter, 8(1), 46–54.
Benatallah, B., Casati, F., & Toumani, F. (2006). Representing, Analysing and Managing Web service Protocols. Data and Knowledge Engineering, 58, 347–357.
Berardi, D., Calvanese, D., De Giacomo, G., Lenzerini, M., & Mecella, M.
(2003). Automatic Composition of e-Services that Export their Behavior.
In ICSOC ’03: Proceedings of the 1st International Conference on Service Oriented Computing (pp. 43–58).
Berardi, D., Calvanese, D., Giacomo, G. D., Hull, R., & Mecella, M. (2005a).
Automatic Composition of Transition-based Semantic Web Services with Messaging. In VLDB ’05: Proceedings of the 31st International Conference on Very Large Databases (pp. 613–624).
Berardi, D., Calvanese, D., Giacomo, G. D., Hull, R., & Mecella, M. (2005b).
Automatic Composition of Web Services in Colombo. In SEBD ’05: Pro-ceedings of the Thirteenth Italian Symposium on Advanced Database Sys-tems (pp. 8–15).
Bernstein, P. A. (2003). Applying Model Management to Classical Meta Data Problems. In CIDR ’03: Proceedings of the First Biennial Conference on Innovative Data Systems Research.
Bernstein, P. A., Halevy, A. Y., & Pottinger, R. A. (2000). A Vision for Management of Complex Models. ACM SIGMOD Record, 29(4), 55–63.
Berre, A.-J., Hahn, A., Akehurst, D., Bezivin, J., Tsalgatidou, A., Vermaut, F., Kutvonen, L., & Linington, P. F. (2004). State-of-the-art for Interop-erability Architecture Approaches. EU INTEROP Network of Excellence Deliverable D9.1.
Betin-Can, A., Bultan, T., & Fu, X. (2005). Design for Verification for Asynchronously Communicating Web Services. In WWW ’05: Proceedings of the 14th international conference on World Wide Web (pp. 750–759).
Bézivin, J. (2005). On the Unification Power of Models. Software and System Modeling, 4(2), 171–188.
Booth, D., Haas, H., McCabe, F., Newcomer, E., Champion, M., Ferris, C.,
& Orchard, D. (2004). Web Services Architecture. Working notes, W3C.
Brand, D. & Zafiropulo, P. (1983). On Communicating Finite-State Ma-chines. Journal of the ACM, 30(2), 323–342.
BRG (2000). Defining Business Rules, What are They Really? http:
//www.businessrulesgroup.org/first_paper/br01c0.htm.
Brogi, A., Canal, C., Pimentel, E., & Vallecillo, A. (2004). Formalizing Web Service Choreographies. Electronic Notes in Theoretical Computer Science, 105(10), 73–94.
Brown, A., Fuchs, M., Robie, J., & Wadler, P. (2001). MSL. A Model for W3C XML Schema. In WWW ’01: Proceedings of the 10th International Conference on World Wide Web (pp. 191–200).
Broy, M., Leuxner, C., Sitou, W., Spanfelner, B., & Winter, S. (2009). For-malizing the Notion of Adaptive System Behavior. In SAC ’09: Proceed-ings of the 2009 ACM Symposium on Applied Computing (pp. 1029–1033).
Bruning, S., Weissleder, S., & Malek, M. (2007). A Fault Taxonomy for Service-Oriented Architecture. In HASE ’07: Proceedings of the 10th IEEE High Assurance Systems Engineering Symposium (pp. 367–368).
Buckley, J., Mens, T., Zenger, M., Rashid, A., & Kniesel, G. (2005). Towards a Taxonomy of Software Change. Journal of Software Maintenance And Evolution: Research and Practice, 17, 309–332.
Bullard, V., Murray, B., & Wilson, K. (2006). An Introduction to WSDM.
Committee Draft. wsdm-1.0-intro-primer-cd-01, OASIS.
Bullard, V. & Vambenepe, W. (2006). Web Services Distributed Manage-ment: Management Using Web Services (MUWS1.1) Part 1. Oasis com-mittee draft, OASIS.
Bultan, T., Fu, X., Hull, R., & Su, J. (2003). Conversation Specification:
a New Approach to Design and Analysis of e-Service Composition. In WWW ’03: Proceedings of the 12th International Conference on World Wide Web (pp. 403–410).
Bunke, H. (2000). Graph Matching: Theoretical Foundations, Algorithms, and Applications. In VI ’2000: Proceedings of the International Confer-ence on Vision Interface (pp. 82–88).
Calvanese, D., Giacomo, G. D., Lenzerini, M., Mecella, M., & Patrizi, F.
(2008). Automatic Service Composition and Synthesis: the Roman Model.
IEEE Data Engineering Bulletin, 31(3), 18–22.
Carbonell, J. G., Michalski, R. S., & Mitchell, T. M. (1983). Machine Learn-ing: A Historical and Methodological Analysis. AI Magazine, 4(3), 69–79.
Cardoso, J. (2006). Complexity Analysis of BPEL Web Processes. Software Process: Improvement and Practice, 12(1), 35–49.
Casati, F., Ceri, S., Pernici, B., & Pozzi, G. (1996). Workflow Evolution. In ER ’96: Proceedings of the 15th International Conference on Conceptual Modeling (pp. 438–455).
Casati, F., Ceri, S., Pernici, B., & Pozzi, G. (1998). Workflow Evolution.
Data & Knowledge Engineering, 24(3), 211–238.
Casati, F., Shan, E., Dayal, U., & Shan, M.-C. (2003). Business-Oriented Management of Web Services. Communications of the ACM, 46(10), 55–
60.
Chan, K. S., Bishop, J., Steyn, J., Baresi, L., & Guinea, S. (2007). A Fault Taxonomy for Web Service Composition. In WESOA ’07: Third Interna-tional Workshop on Engineering Service-Oriented Applications: Analysis, Design, and Composition (pp. 363–375).
Charfi, A., Dinkelaker, T., & Mezini, M. (2009). A Plug-in Architecture for Self-Adaptive Web Service Compositions. In ICWS ’09: Proceedings of 7th International Conference on Web Services (pp. 35–42).
Charfi, A. & Mezini, M. (2004). Hybrid Web Service Composition: Business Processes meet Business Rules. In ICSOC ’04: Proceedings of the 2nd international conference on Service oriented computing (pp. 30–38).
Cheng, S.-W., Garlan, D., & Schmerl, B. (2006). Architecture-Based Self-Adaptation in the Presence of Multiple Objectives. In SEAMS ’06: Pro-ceedings of the 2006 International Workshop on adaptation and Self-Managing Systems (pp. 2–8).
Cibrán, M. A., Verheecke, B., Vanderperren, W., Suvée, D., & Jonckers, V.
(2007). Aspect-oriented Programming for Dynamic Web Service Selection, Integration and Management. World Wide Web, 10(3), 211–242.
Cisco (2007). Service Virtualization: Managing Change in a Service-Oriented Architecture. White paper, CISCO.
Cobena, G., Abiteboul, S., & Marian, A. (2002). Detecting Changes in XML Documents. In Proceedings of the 18th International Conference on Data Engineering (ICDE 2002) (pp. 41–52).
Colombo, M., Nitto, E. D., & Mauri, M. (2006). SCENE: A Service Compo-sition Execution Environment Supporting Dynamic Changes Disciplined Through Rules. In ICSOC ’06: Proceedings of the 4th International Con-ference on Service-Oriented Computing (pp. 191–202).
Cottrell, L. (2001). Passive vs Active Monitoring. http://www.slac.
stanford.edu/comp/net/wan-mon/passive-vs-active.html.
Cox, D. E. & Kreger, H. (2005). Management of the Service-Oriented Ar-chitecture Life Cycle. IBM Systems Journal, 44(4), 709–726.
Curbera, F. (2007). Component Contracts in Service-Oriented Architectures.
Computer, 40(11), 74–80.
Curbera, F., Duftler, M. J., Khalaf, R., Nagy, W. A., Mukhi, N., &
Weerawarana, S. (2005). Colombo: Lightweight Middleware for Service-Oriented Computing. IBM Systems Journal, 44(4), 799–820.
Daniel, F. & Pernici, B. (2006). Insights into Web Service Orchestration and Choreography. International Journal of E-Business Research, 2(1), 58–77.
Dardenne, A., van Lamsweerde, A., & Fickas, S. (1993). Goal-Directed Requirements Acquisition. Science of Computer Programming, 20(1-2), 3–50.
De Backer, M., Snoeck, M., Monsieur, G., Lemahieu, W., & Dedene, G.
(2009). A Scenario-based Verification Technique to Assess the Compatibil-ity of Collaborative Business Processes. Data and Knowledge Engineering, 68(6), 531–551.
Delgado, N., Gates, A. Q., & Roach, S. (2004). A Taxonomy and Cata-log of Runtime Software-Fault Monitoring Tools. IEEE Transactions on Software Engineering, 30(12), 859–872.
Denaro, G., Pezze, M., Tosi, D., & Schilling, D. (2006). Towards Self-Adaptive Service-Oriented Architectures. In TAV-WEB ’06: Proceedings of the 2006 workshop on Testing, Analysis, and Verification of Web Ser-vices and Applications (pp. 10–16).
Di Nitto, E., Ghezzi, C., Metzger, A., Papazoglou, M., & Pohl, K. (2008).
A Journey to Highly Dynamic, Self-Adaptive Service-Based Applications.
Automated Software Engineering, 15(3-4), 313–341.
DMTF (2008). Web Services for Management (WS-Management) Specifica-tion. Final Standard DSP0226, Distributed Management Task Force.
Dorn, C., Schall, D., & Dustdar, S. (2009). A Model and Algorithm for Self-Adaptation in Service-oriented Systems. In ECOWS ’09: Proceedings of the European Conference on Web Services.
Dustdar, S., Goeschka, K. M., Truong, H.-L., & Zdun, U. (2009). Self-Adaptation Techniques for Complex Service-oriented Systems. In Pro-ceedings of the 5th IEEE International Conference on Next Generation Web Services Practices.
Dustdar, S. & Schreiner, W. (2005). A Survey on Web Services Composition.
International Journal on Web and Grid Services, 1(1), 1–30.
Ellis, C., Keddara, K., & Rozenberg, G. (1995). Dynamic Change within Workflow Systems. In COCS ’95: Proceedings of Conference on Organi-zational Computing Systems (pp. 10–21).
Ernst, M. D., Lencevicius, R., & Perkins, J. H. (2006). Detection of Web Service Substitutability and Composability. In WS-MaTe ’06: Proceeding of the International Workshop on Web Services — Modeling and Testing (pp. 123–135).