Nội dung

Developing Rule-Based Applications for the Web should be developed. These algorithms should be able to handle complex and heavy knowledge bases that combine rules and ontologies with a large number of concepts and relationships. Such knowledge bases are substantial, especially in the context of information integration where multiple domain vocabularies interact with upper-level ontologies. Furthermore, the Web is a large scale environment, where a huge set of resources are added every day. As a result, future knowledge bases will have to capture and describe more and more individuals. These facts should be taken into account by the developers that will target at designing new reasoning algorithms. Finally, a more practical issue that should be investigated is the development of a unified reasoning framework capable of managing both ontologies and rules. Today, there is no efficient and easy-to-use integrated reasoning module that can reason over both formalisms. As a consequence, the developer should use at least two different reasoning modules to handle such an integrated knowledge base. This can result to unexpected situations. For example, the restrictions defined by the ontology can be violated by the application of rules, since the rule engines do not take into account these restrictions (e.g., disjointness of concepts). Similarly, the application of rules could produce knowledge that would be useful for further description logic inferences. 6. CONCLUSION In this chapter we have discussed the application of rules to Web applications in order to achieve intelligent application behavior and efficient management of knowledge. We have described the main methodologies and technologies for integrating rules with ontologies, since the latter constitutes a mature knowledge technology on the Web. The chapter has also examined aspects of the different approaches. We also showed through several experiments that current reasoning modules are not efficient enough to manage knowledge stemming from large-scale environments like the Web, especially in the context of real-time applications which impose severe constraints in response times. Finally, more improvements should be made in the standardization of rules formalism on the Web and in the development of reasoning modules that can handle and reason over both ontologies and rules as integral knowledge. 7. REFERENCES W3C Semantic Web Activity (2008). Retrieved April 22, 2008, from http://www.w3.org/2001/ sw/. Alferes, J., Damasio, C., & Pereira, L. (2003). Semantic Web logic programming tools. ( . LNCS, 2901, 16–32. Antoniou, G., Billington, D., Governatori, G., & Maher, M., J. (2001). Representation results for defeasible logic. ACM Transactions on Computational Logic, 2(2), 255–287. doi:10.1145/371316.371517 Antoniou, G., & Damasio, C. V., Grosof, B., Horrocks, I., Kifer, M., Maluszynski, J., et al. (2005). Combining rules and ontologies: A survey. Deliverables I3-D3, REWERSE. Retrieved from, http://rewerse.net/deliverables/m12/i3-d3.pdf. Antoniou, G., & van Harmelen, F. (2004). A Semantic Web primer. MIT Press. Baader, F., Calvanese, D., McGuiness, D., Nardi, D., & Patel-Schneider, P. (2003). The description logic handbook: Theory, implementation, and applications. Cambridge: Cambridge University Press. Bassiliades, N., Antoniou, G., & Vlahavas, I. (2006). A defeasible logic reasoner for the Semantic Web . International Journal on Semantic Web and Information Systems, 2(1), 1–4. 473 Developing Rule-Based Applications for the Web Bechhofer, S., Moller, R., & Crowther, P. (2003). The DIG description logic interface. In D. Calvanese, G. de Giacomo, & F. Franconi (Eds.), Proc. of the 2003 Int. Workshop on Description Logics (DL 2003) (Vol. 81 of CEUR Workshop Proceedings), Rome, Italy. Boley, H., Kifer, M., & Patranjan, P. L., & Polleres, A. (2007). Rule interchange on the Web. In Reasoning Web 2007 (No. 4636, pp. 269-309). Springer. Brickley, D., & Guha, R. V. (2004). RDF vocabulary description language 1.0: RDF schema. Recommendation 10 February 2004, W3C. Retrieved April 22, 2008, from http://www.w3.org/ TR/rdf-schema/. Cardoso, J. (2007). The Semantic Web vision: Where are we? Intelligent Systems, 22(5), 84–88. doi:10.1109/MIS.2007.4338499 CLIPS. A tool for building expert systems. (2008). Retrieved April 22, 2008, from http://clipsrules. sourceforge.net/. de Bruijn, J., Lausen, H., Krummenacher, R., Polleres, A., Predoiu, L., Kifer, M., et al. (2005). The Web service modeling language WSML (Tech. Rep. WSML. WSML Final Draft D16.1v0.21). Retrieved from http://www.wsmo.org/TR/d16/ d16.1/v0.21/. de Bruijn, J., Polleres, A., Lara, R., & Fensel, D. (2005). OWL DL vs. OWL flight: Conceptual modeling and reasoning on the Semantic Web. In Proc. WWW2005, (pp. 623-632). Dean, M., Schreiber, G., Bechhofer, S., van Harmelen, F., Hendler, J., Horrocks, I., et al. (2004). OWL Web ontology language reference. W3C Recommendation 10 February 2004. Retrieved April 22, 2008, from http://www.w3.org/ TR/owl-ref/. 474 Donini, M. F., Lenzerini, M., Nardi, D., & Schaerf, A. (1998). AL-log: Integrating datalog and description logics. Journal of Intelligent Information Systems, 10(3), 227–252. doi:10.1023/A:1008687430626 Drools (2008). Retrieved April 22, 2008, from http://www.jboss.org/drools/. Eiter, T., & Ianni, G. B., Schindlauer, R., & Tompits, H. (2005). A uniform integration of higher-order reasoning and external evaluations in answer set programming. In Proc. IJCAI 2005. Morgan Kaufmann. Eiter, T., & Ianni, G. B., Polleres, A., Schindlauer, R., & Tompits, H. (2006a). Reasoning with rules and ontologies. In P. Barahona, F. Bry, E. Franconi, U. Sattler, & N. Henze (Eds.), Reasoning Web, Second International Summer School 2005, Tutorial Lectures (LNCS, pp. 93-127). Eiter, T., & Ianni, G. B., Schindlauer, R., & Tompits, H. (2006b). dlvhex: A system for integrating multiple semantics in an answer-set programming framework. In M. Fink, H. Tompits, & S. Woltran (Eds.), Proceedings 20th Workshop on Logic Programming and Constraint Systems (WLP 06), (pp. 206-210). Eiter, T., Lukasiewicz, T., Schindlauer, R., & Tompits, H. (2004). Combining answer set programming with description logics for the Semantic Web. In Proc. of the International Conference of Knowledge Representation and Reasoning (KR04). Farrell, J., & Lausen, H. (2007). Semantic annotations for WSDL and XML schema. W3C Recommendation, W3C, August 2007. Retrieved April 22, 2008, from http://www.w3.org/TR/sawsdl/. Forgy, C. (1982). Rete: A fast algorithm for the many pattern/many object pattern match problem. Artificial Intelligence, 19, 17–37. doi:10.1016/0004-3702(82)90020-0 Developing Rule-Based Applications for the Web Gardiner, T., Horrocks, I., & Tsarkov, D. (2006). Automated benchmarking of description logic reasoners. In Proc. of DL. Gelfond, M., & Lifschitz, V. (1991). Classical negation in logic programs and disjunctive databases. New Generation Computing, 9(3-4), 365–386. doi:10.1007/BF03037169 Grosof, B. N., Horrocks, I., Volz, R., & Decker, S. (2003). Description logic programs: Combining logic programs with description logic. In Proc. of the Twelfth International World Wide Web Conference (WWW 2003), (pp. 48-57). ACM. Haarslev, V., & Moller, R. (2001). RACER system description. In R. Gor’e, A. Leitsch, and T. Nipkow (Eds.), International Joint Conference on Automated Reasoning, IJCAR’2001, June 18-23, Siena, Italy, (pp. 701–705). Springer-Verlag. Horrocks, I. (1998). Using an expressive description logic: FaCT or fiction? In Proceedings of the Sixth International Conference on Principles of Knowledge Representation and Reasoning (KR’98), Trento, Italy, June 2–5, 1998, (pp. 636–647). Horrocks, I., Li, L., Turi, D., & Bechhofer, S. (2004a). The instance store: DL reasoning with large numbers of individuals. In Proc. of the 2004 Description Logic Workshop (DL~2004), (pp. 31-40). Horrocks, I., Parsia, B., & Patel-Schneider, P. F., & Hendler, J. (2005). Semantic Web architecture: Stack or two towers? In Proc. PPSWR 2005, (pp. 37-41), Dagstuhl Castle, Germany. Horrocks, I., Patel-Schneider, P. F., Boley, H., Tabet, S., Grosof, B., & Dean, M. (2004b). SWRL: A Semantic Web rule language combining owl and RuleML. W3C Member Submission, 21 May 2004. Retrieved April 22, 2008, from http://www. w3.org/Submission/SWRL/. Hustadt, U., Motik, B., & Sattler, U. (2004). Reducing SHIQ- description logic to disjunctive datalog programs. In Proc. of the 9th International Conference on Knowledge Representation and Reasoning (KR2004), (pp. 152-162). ILOG. Business Rule Management Systems, Optimization Tools and Engines, Visualization Software Components, Supply Chain Applications (2008). Retrieved April 22, 2008, from http:// www.ilog.com/. Jang, M., & Sohn, J.-C. (2004). Bossam: An extended rule engine for OWL inferencing. In Workshop on Rules and Rule Markup Languages for the Semantic Web at the 3rd International Semantic Web Conference (LNCS 3323, pp. 128-138). Jess, The Rule Engine For the Java Platform (2008). Retrieved April 22, 2008, from http:// www.jessrules.com/jess/index.shtml KAON2 – Ontology Management for the Semantic Web (2008). Retrieved April 22, 2008, from http:// kaon2.semanticweb.org. KAON – The KArlsruhe ONtology and Semantic Web tool suite (2008). Retrieved April 22, 2008, from http://kaon.semanticweb.org. Kifer, M., de Bruijn, J., Boley, H., & Fensel, D. (2005). A realistic architecture for the Semantic Web. In Proc. RuleML 2005 (pp. 17-29), Galway, Ireland. Klyne, G., & Carroll, J. J. (2004). Resource description framework (RDF): Concepts and abstract syntax. Recommendation 10 February 2004, W3C. Retrieved April 22, 2008, from http:// www.w3.org/TR/rdf-concepts/. McBride, B. (2002). Jena: A Semantic Web toolkit . IEEE Internet Computing, 6(6), 55–59. doi:10.1109/MIC.2002.1067737 475 Developing Rule-Based Applications for the Web Mei, J., Bontas, E. P., & Lin, Z. (2005). OWL2Jess: A transformational implementation of the OWL semantics. In Proceedings of International Workshops on ISPA (LNCS 3759, pp. 599-608). Motik, B., Horrocks, I., Rosati, R., & Sattler, U. (2006). Can OWL and logic programming live together happily ever after? In Proceedings ISWC2006 (LNCS 4273, pp. 501–514). Motik, B., Sattler, U., & Studer, R. (2005). Query answering for OWL-dl with rules. Journal of Web Semantics: Science . Services and Agents on the World Wide Web, 3, 41–60. doi:10.1016/j. websem.2005.05.001 Nute, D. (1994). Defeasible logic. In Handbook of Logic in Artificial Intelligence and Logic Programming, Nonmonotonic Reasoning and Uncertain Reasoning (Vol. 3). Oxford University Press. Patel-Schneider, P. F., & Horrocks, I. (2006). Position paper: a comparison of two modelling paradigms in the Semantic Web. In Proceedings of the 15th International Conference on World Wide Web (Edinburgh, Scotland, May 23 - 26, 2006). WWW ‘06, New York, NY (pp. 3-12). ACM Press. Polleres, A., & Schindlauer, R. (2007). DLVHEXSPARQL: A SPARQL Compliant Query engine based on DLVHEX. In Proceedings of 2nd International Workshop on Applications of Logic Programming to the Web, Semantic Web and Semantic Web Services (ALPSWS2007), Porto, Portugal. Prud’hommeaux, E., & Seaborne, A. (2005). SPARQL query language for RDF.http:// www.w3.org/TR/2005/WD-rdf-sparql-query-20050217/, 2005. O’Connor, M., Knublauch, H., Samson, T., & Musen, M. (2005). Writing rules for the Semantic Web using SWRL and Jess. Protégé with Rules WS. Madrid. RacerPro (2008). Retrieved April 22, 2008, from http://www.racer-systems.com/products/racerpro/ index.phtml. Pan, J. (2005). Benchmarking DL reasoners using realistic ontologies. In Proc. of the OWL: Experiences and Directions Workshop. Rainer. A. (2005). Web service composition under answer set programming. KI-Workshop “Planen, Scheduling und Konfigurieren, Entwerfenl” (PuK). Pan, J. Z., & Horrocks, I. (2004). OWL-E: Extending owl with expressive datatype expressions (Technical report, IMG/2004/KR-SW-01/v1.0). Victoria University of Manchester. RIF - Rule Interchange Format Working Group (2008). Retrieved April 22, 2008, from http://www. w3.org/2005/rules/wiki/RIF_Working_Group Parsia, B., Sirin, E., & Kalyanpur, A. (2005). Debugging OWL Ontologies. In Proceedings of the 14th International World Wide Web Conference (WWW2005), Chiba, Japan, May 2005. Retrieved from http://www.mindswap.org/papers/ debuggingOWL.pdf. Rosati, R. (2006a). DL+log: Tight integration of description logics and disjunctive datalog. In P. Doherty, J. Mylopoulos, & C.A. Welty (Eds.), Proceedings of the 10th International Conference on Principles of Knowledge Representation and Reasoning (KR 2006), Lake District, UK (pp. 68-78). AAAI Press. 476 Developing Rule-Based Applications for the Web Rosati, R. (2006b). Integrating ontologies and rules: Semantic and computational issues. In P. Barahona, F. Bry, E. Franconi, N. Henze, & U. Sattler (Eds.), Reasoning Web, Second International Summer School 2006, Lissabon, Portugal, September 4_8, 2006, Tutorial Lectures. (LNCS 4126, pp. 128-151). Rosati, R. (2006c). DL+log: Tight integration of description logics and disjunctive datalog. In Proceedings of the Tenth International Conference on Principles of Knowledge Representation and Reasoning (KR 2006) (pp. 68-78). AAAI Press. Rule, M. L. Rule Markup Initiative (2008). Retrieved April 22, 2008, from http://www.ruleml. org/. Sirin, E., Parsia, B., & Grau, B., C., Kalyanpur A., & Katz, Y. (2007). Pellet: A practical OWLDL reasoner. Journal of Web Semantics, 5(2). doi:10.1016/j.websem.2007.03.004 Tsarkov, D., & Horrocks, I. (2006). FaCT++ description logic reasoner: System description. In Proc. of the International Joint Conference on Automated Reasoning (IJCAR 2006). Wagner, G. (2003). Web rules need two kinds of negation (LNCS 2901, pp. 33-50). Knowledge-Based System: A system that exploits knowledge representation and reasoning techniques in order to achieve an intelligent behavior. Knowledge Representation: It is the process of exploiting formal methodologies and languages (e.g., rules formalisms, ontologies) in order to capture and describe knowledge. Ontology: A formal representation of a domain of discourse that describes concepts and relationships among them. This way, it provides a common vocabulary and allows for the inference of new knowledge. Reasoning: The systematic process of inferring new knowledge by applying formal implication rules to a given knowledge base. Rule-Based Application: An application that takes advantage of rules formalisms (e.g., Horn-clauses) in order to represent and infer new knowledge. Semantic Web: It is an extension of the current Web where resources are described through formal syntax and semantics in order to be human- and machine-readable. Endnotes 1 Key Terms and definitions 2 3 Logic Programming: It is a declarative paradigm of programming that is mainly based on first-order logic. Prolog is the most common logic programming language. 4 Also called as Datalog view in the literature http://con.fusion.at/dlvhex/ It offers free trials while educational and research licenses are available Universal Resource Identifiers This work was previously published in Handbook of Research on Emerging Rule-Based Languages and Technologies: Open Solutions and Approaches, edited by A. Giurca, D. Gasevic, and K. Taveter, pp. 371-392, copyright 2009 by Information Science References (an imprint of IGI Global). 477 478 Chapter 2.13 Modeling of Web Services using Reaction Rules Marko Ribarić Mihailo Pupin Institute, Serbia Shahin Sheidaei Simon Fraser University, Canada Milan Milanović University of Belgrade, Serbia Dragan Gašević Athabasca University, Canada Adrian Giurca Brandenburgische Technische Universität Cottbus, Deutschland Sergey Lukichev Brandenburg University of Technology at Cottbus, Germany Gerd Wagner Brandenburg University of Technology, Germany Abstract The development process of Web services needs to focus on the modeling of business processes rather than on low-level implementation details of Web services, and yet it also needs to incorporate the support for frequent business changes. This chapter presents the UML-based Rule Language (URML) and REWERSE Rule Markup Language (R2ML), which use reaction rules (also known as Event-Condition-Action rules) for modeling Web services in terms of message exchange patterns. Web services that are being modeled in this way can easily be integrated in the wider context of modeling orchestration and choreography. In order to achieve proposed solution, we have developed a plug-in for the Fujaba UML tool (so called Strelka) and a number of model transformations for roundtrip engineering between Web services and reaction rules. Also, the paper presents mappings of models of Web services with reaction rules into the Drools rule language, thus enabling the run time execution semantics for our rule-based models. DOI: 10.4018/978-1-60566-402-6.ch018 Copyright © 2010, IGI Global. Copying or distributing in print or electronic forms without written permission of IGI Global is prohibited. Modeling of Web Services using Reaction Rules 1. Introduction Web services provide a communication interface and a workflow management protocol for business systems. Their goal is set to change the Web from a static collection of information, to a dynamic place where different software components (business logics) can be easily integrated (Arroyo et al., 2004). Some of the factors that constrain web services from achieving that goal can be named as follow: when developers try to enrich the existing Web services with some new functionality, they have to implement necessary changes manually, which may lead to potential execution errors; furthermore, business rules, due to their declarative nature, are used for reflecting dynamic changes representing desired alteration in the business process. When business rules are used in a networked business, they are often large and complex, which makes them difficult to manage and change. There is a lack of automatic mechanism for updating Web services based on the business rules changes (Ribaric et al., 2008). The need for a more straightforward way to express, and manage business rules as a separate part of Web services’ composition has been recognized by researchers for the numerous benefits that it provides (Charfi & Mezini, 2004). However, integrating rule-based systems in a service-oriented environment is a complex task, due to the fact that both worlds have their own paradigms (Rosenberg & Dustdar, 2005). Many different factors involve in this integration. However, the most important one of these factors is the architecture of service oriented systems. In this architecture, layers play a great role. The layering architecture is needed to be represented and deployed in the world of rules which become challenging and could not be simple done. This integration approach should be loosely coupled, meaning that it is reasonable to expose business rules as services. The way of modeling Web services presented in this paper facilitates this integration process, and those services can be more easily integrated in the wider context of modeling orchestration and choreography. A promising way to solve these problems is to use a high-level modeling approach combined with the use of rules. A modeling approach will allow developers to focus on a problem domain rather than on an implementation technology. This is why we propose using an approach based on Model Driving Engineering (MDE). Although, there have been several attempts to leverage MDE principles to model Web services, they are still very low level oriented, as they again focus on technical details covered either by WSDL (Bezivin et al., 2004) (Vara et al., 2005) or OWL-S (Timm & Gannod, 2005) (Gronmo et al., 2005). The use of rules implying that they are defined in a declarative way, they can dynamically reflect business logic changes at run-time without the need to redesign the whole system. Since Web services are used for integration of business processes of various stakeholders, it is important for them to reflect changes in business logic, or policies, as good as possible. The solution that we propose is to use rules to represent and model business processes from the perspective of message exchange. That is, our modeling approach enables one to model Web services from the perspective of the underlying business logic regulating how Web services are used regardless of the context where they are used. To do so, our proposal is to leverage messageexchange patterns (MEPs) as an underlying perspective integrated into a Web service modeling language. This perspective has already been recognized by Web service standards (Chinnici et al., 2007), and our contribution is to raise this to the level of models. As the leading Rule Modeling language we benefit from UML-based Rule Modeling Language (URML) (Lukichev & Wagner, 2006a) for our approach. URML having strong ties with R2ML (REWERSE Rule Markup Language) empowers us to model rules in various languages. 479 Modeling of Web Services using Reaction Rules URML supports modeling of domain vocabularies in addition to integrity, derivation, production and reaction rules. .Business rules, being similar to natural language rules, are proposed to be modeled by using reaction rules (also known as Event-Condition-Action, ECA, rules) in this paper. Reaction rules will perform a task (Action) under some circumstances (Conditions) if some events (Event) take place and can best describe a business rule. We also have developed a plugin (called Strelka) for the well known UML tool Fujaba, which has a support for URML notation. Strelka also has the support transformation of URML models into Web Service Description Language (WSDL) and different types of rule languages such as Drools, Jess, and SWRL. In this paper, we discuss those transformations that are implemented by using a model transformation language entitled the ATLAS Transformation Language (ATL) (ATL, ver. 0.7). The paper is structured as follows: in the next section we give a bit of the background, including, Web services, R2ML and URML languages with the emphasis on reaction rules. In section 3 we introduce our approach for modeling business rules and services following by section 4 in which we introduce Strelka (Lukichev & Wagner, 2006b), a tool we developed that is capable of presenting URML diagrams, and performing transformations. Section 5 describes mapping process between URML and WSDL that is a part of Strelka, and also covers a deployment of URML diagrams to the Drools rule engine. Section 6 summarized the related work done so far and in Section 7 we conclude this work by summarizing the major points. 2. Background In this section, we give a brief overview of the technologies and techniques relevant to the problem under study. This includes a short description 480 of Web services, Drools rule engine, and rule language definitions based on MDE principles used in our modeling approach. A complete introduction into the ATLAS Transformation Language (ATL) can be found in the chapter entitled “Sharing ontologies and rules using model transformations”. Web Services A Web service is a loosely coupled component that exposes functionality to a client over the Internet (or an intranet) by using web standards such as HTTP, XML, SOAP, WSDL, and UDDI (Timm & Gannod, 2005). SOAP is an XML-based protocol for exchanging information in a decentralized, distributed environment. SOAP builds on XML and common Web protocols (HTTP, FTP, and SMTP) (Coyle, 2002). A SOAP message is the basic unit of communication between SOAP nodes. The “envelope” element represents the root of a SOAP message structure. It contains a mandatory body construct and optional header construct (Gudgin et al., 2007). The header construct is where meta-information can be hosted. In a large number of service-oriented architectures, the header is an important part of the overall architecture, and although it is optional it is rarely omitted. Web Service Description Language (WSDL) is a language for describing both the abstract functionality of a service and the concrete details of a Web service (Chinnici et al., 2007). At an abstract level, WSDL describes a Web service in terms of interfaces and the operations supported by the interfaces. An operation is an interaction with the service consisting of a set of (input, output, infault and outfault) messages exchanged between the service and other parties involved in the interaction (Chinnici et al., 2007). The messages are described independently of a specific wire format by using a type system, typically XML Schema. WSDL also describes the point of contact for a service provider, known as the Modeling of Web Services using Reaction Rules endpoint – it provides a formal definition of the endpoint interface and also establishes the physical location (address) of the service. Potential requestors need a way to discover Web services descriptors. It is necessary that these descriptors are collected and stored in a central registry. The key part of the Universal Description Discovery and Integration (UDDI) specification (Clement et al., 2004) presents standardizing information inside such a registry as well as specifying the way the information can be searched and updated. Regardless of how complex tasks performed by a Web service are, almost all of them require the exchange of multiple messages (Erl, 2005). It is important to coordinate these messages in a particular sequence, so that the individual actions performed by the message are executed properly. Message exchange patterns (MEPs) are a set of templates that provide a group of already mapped out sequences for the exchange of messages (Erl, 2005). This basically means that MEPs define how services should be used, as they can coordinate input and output messages related to a certain operation. The WSDL 2.0 specification defines three MEPs: • • • in-only pattern – supports a standard fireand-forget pattern (i.e., only one message is exchanged); robust in-only pattern – presents a variation of the in-only pattern that provides an option of sending a fault massage, as a result of possible errors generated while transmitting, or processing data; in-out pattern – presents a request-response pattern where two messages (input and output) must be exchanged. However, WSDL 2.0 specification offers the possible use of five more patterns (Lewis, 2007): • • • • • out-in pattern – also consists of exactly two messages (like in-out pattern), but now a service provider is the one that initiates the exchange of messages; out-only – consists of exactly one message (like in-only pattern), and is most often used for message notification; robust out-only - presents a variation of the out-only pattern that provides an option of sending a fault massage; in-optional-out – is similar to pattern in-out with one exception: sending an message that represents a response is optional, and because of this a requester that has started a communication should not expect this message; out-optional-in – is opposite to the previous pattern, where the input message is optional. Drools Drools is a business rule management system (BRMS) with a forward chaining inference based rule engine, more correctly known as a production rule system, using an enhanced implementation of the Rete algorithm. BRMS is a production rule system with a focus on knowledge representation to express propositional and first order logic in a concise, non ambiguous and declarative manner. The core of a production rules system is an inference engine that is able to scale to a large number of rules and facts. The inference engine matches facts and data, against production rules, also called productions, to infer conclusions which result in actions. A production rule is a two-part structure using first order logic for knowledge representation (Proctor et al). Figure 1 presents a schema of a production rule. It executes the actions while the conditions are being satisfied. Drools representation contains the same structure, LHS (Left Hand Side) is referring to conditions while RHS (Right Hand Side) is referring to actions. Name of the rule which is presented by “name” 481 Modeling of Web Services using Reaction Rules Figure 1. First order logic representation (left) Drools representation (right) is just for better understanding of rules and have no functional value. Attributes, marked with attributes in the rule are used for the rule internal functionality itself. The process of matching new or existing facts against production rules is called pattern matching, which is performed by the inference engine (part of Drools). Drools implements and extends the Rete algorithm The Drools Rete implementation is called ReteOO, signifying that Drools has an enhanced and optimized implementation of the Rete algorithm for object oriented systems (Schneier). For better understanding of rules and their structure please refer to the chapter “Object Oriented Rule Languages”. R2ML Existing Web rule languages (RuleML (Hirtle et al., 2006) and SWRL (Horrocks et al., 2004)) and rule modeling approaches (SBVR (SBVR, 2006) and PRR (Charfi & Mezini, 2004)) very nicely serve the purpose of rule interchange and rule representation independent of any specific platform, respectively. However, none of these languages offers a suitable modeling foundation that can be used for modeling Web services from a more abstract perspective of business processes and business rules in which they are used. That is, the language should be able to model reaction rules. Yet, such a modeling language should be closely related to the already existing software 482 modeling languages such as UML and preferably defined by following MDE principles. Finally, the language should be closely related to the Web standards for defining ontologies (OWL) and rules (RIF). We have decided to use REWERSE I1 Rule Markup Language (R2ML), as it fully satisfies the above requirements. The language is defined by a MOF-based metamodel which is refined by OCL constraints that precisely define relations between the language’s constructs in addition to those defined by the metamodel; it has an XML schema defined concrete syntax; it has a UML-based graphical concrete syntax, so called UML-based Rule Modeling Language (URML), which we will introduce it in the section below; and it has a number of transformations with other rule languages (e.g., JBoss’ Drools and OCL) allowing us to translate Web service models to the rule-based languages that can then regulate the use of Web services. R2ML is a rule language that addresses all the requests defined by the W3C working group for the standard rule interchange format (Ginsberg et al., 2006). The R2ML language can represent different types of rule constructs, that is, it can represent different types of rules (Wagner et al., 2006) including: integrity rules, derivation rules, production rule, and reaction rules. Integrity rules in R2ML, also known as (integrity) constraints, consist of a constraint assertion, which is a sentence in a logical language such as first-order predicate logic or OCL. Derivation rules in R2ML are used to derive new knowledge (conclusion) if a condition holds. Production rules in R2ML produce actions if the conditions hold, while post-conditions must also hold after the execution of actions. A reaction rule is a statement of programming logic (Giurca et al., 2006) that specifies the execution of one or more actions in the case of a triggering event occurrence and if rule conditions are satisfied. Optionally, after the execution of the action(s), post-conditions may be made true. R2ML also allows one to define vocabularies by using the