Rule languages and inference engines incorporate reasoning capabilities to Web information systems. This paper presents a modeldriven approach for the development of rule-based applications for the Web. The method is applied to ontology and rule speci cations in OWL and SWRL, generating a rich, functional Web architecture based on the Model-View-Control architectural pattern and the JavaServer Faces technology, embedding a Jess rule engine for reasoning and inferencing new information. The proposal is described through an illustrative example. A tool supporting the ideas presented this paper has been developed.
Rule-Based Systems (RBS) is the leading technology for the development of
Knowledge-Based Systems from the beginnings of the Arti cial Intelligence. RBS
is a kind of software systems in which the human expert's knowledge applied for
solving a complex task such as diagnosis, monitoring, assessment, and so on,
is represented as a set of declarative production rules. Rules encode domain
knowledge and business logic as condition-action pairs, whereas rule engines are
able to interpret the rules and reason over the information loaded in the working
memory, using some inference method to deduct new assertions and achieve a
conclusion as the human expert would do [
Currently, a high interest exists in making the Web a more e ective platform
for intelligent systems. In this context, rule languages and inference engines
provide Web information systems with reasoning capabilities [26]. Rules and
ontologies play a key role in the architecture of the Semantic Web, as they are
used to provide meaning and reasoning facilities to semantic Web applications
[
Ontologies are typically used for domain modeling, in which a
conceptualization of a particular domain is given. Although ontology formalisms are quite
mature and the Web Ontology Language (OWL) [
This paper presents a model-driven approach to develop rule-based Web
applications based on OWL and SWRL speci cations. The proposal applies
ModelDriven Development (MDD) or Model-Driven Engineering (MDE) to
automatically produce the implementation of a functional, rich Web architecture which
embeds a rule engine for inferencing tasks. Although other formalisms for
conceptual and rule modeling can be used in MDD of rule-based Web applications
[
Recently, a tool to bridge the gap between OWL ontologies and MDE has been presented, the TwoUse Toolkit 3 [27], which has been developed using Eclipse Modeling Project4. It implements the Ontology De nition Metamodel (ODM) [24] and provides a graphical environment for specifying OWL and SWRL models. Since it is deployed as an Eclipse plugin, other Eclipse-based tools for MDD can be straightforward applied enabling us to design a modeldriven process based on OWL and SWRL ontologies created with TwoUse.
In the proposed method, the functionality for the generated rule-based Web application is prede ned to enable end-users to create, retrieve, update and delete instances (CRUD). In contrast to current tools for automatic generation of CRUD systems that perform those functions on relational databases, our contribution is that this functionality is executed on the rule engine working memory, enabling the execution of a forward-chaining inference mechanism to drive the reasoning process.
To put our proposal into practice, a supporting tool has been developed
using MDD tools provided by the Eclipse Modeling Project. The resulting Web
application, based on the Model-View-Controller (MVC) architectural pattern,
embeds the Jess rule engine [
The rest of this paper is organized as follows: Section 2 introduces the modeldriven approach proposed and the supporting tool that implements it. Next, the mapping from OWL and SWRL to Jess is detailed in section 3. The architecture for the rule-based Web application generated is described in section 4. Some related work is reviewed in Section 5. Finally, the main conclusions and future work are summarized.
Process overview
The proposed approach uses OWL and SWRL ontologies created with TwoUse as source models for the model-driven process. We will focus on OWL DL sublanguage of OWL. Classes, properties, and individuals de ne the structure and content of data. SWRL rules describe logical dependencies between the elements of the ontology refereed in the rule's antecedent and consequent.
Fig. 1 shows the proposed MDD schema for rule-based Web applications, which is divided into two processes. The rst one (the bottom ow in Fig. 1) generates the implementation of the rule base in Jess, and the second one (the top ow in Fig. 1) produces the code for the Web architecture.
The development process starts with the speci cation of an OWL ontology of the problem domain enriched with SWRL rules, using the TwoUse editor. Such ontology is treated as a platform-independent model by the MDD process which produces two di erent results: (1) ontology and rules are transformed into a Jess rule base, a text le containing the set of templates, rules and facts in Jess syntax; (2) furthermore, a Web-based architecture is generated from the ontology and from an interaction and presentation model which is tightly coupled to the ontology. Web application code is based on the MVC architectural pattern, the JavaServer Faces (JSF) framework [13] and JBoss Richfaces components [16], and consist of a set of generated JavaBeans, JSF pages and con guration les.
Platform Independent
Models EMF IPnrteesraecnttiaotnio&n
OWL + SWRL TwoUse Toolkit for OWL & SWRL
Eclipse Modeling
M2M Transformations
Platform Specific Models Java and JSF Web model Jess Rule model
Default Presentation, Navigation, Functionality
M2T Transformations
JET
Code Rule-based Web application Java classes JSF pages
integration Jess rule base
Although the two MDD processes are executed independently, the nal result must integrate the rule base into the Web application. This is done by generating the appropriate calls to the Jess API (Application Programming Interface) in the Java code obtained, entailing to embed the Jess rule engine into the Web application.
The generated Web application bene ts of having the decision logic
externalized from core application code, since uncoupling the rules from the source
code increases scalability and maintainability of rule-based applications [
Tool support A tool supporting the proposed approach is being developed using Eclipse MDD tools and it is supported by the TwoUse toolkit for ontology edition. Using EMF5 (Eclipse Modeling Framework) we have de ned two metamodels for representing Jess and Java/JSF Web models, respectively.
Model-to-model (M2M) transformations are designed with ATL6 (Atlas Transformation Language). The rst M2M transformation (bottom ow in Fig. 1) maps an ontology and rule speci cation to a Jess platform-speci c model. The second ATL transformation (top ow in Fig. 1) transforms the ontology and the interaction and presentation model into a Java/JSF Web speci c model.
The outputs of both ATL transformations are the respective inputs of two model-to-text (M2T) transformations implemented in JET7 (Java Emitter Templates). As a result, the code for the rule-based Web application is obtained. On one hand, source les with Jess rule base and facts, and on the other hand, the Web application components, the con guration les, the Java classes, and a Jess-Engine Bean which uses the Jess API to embed the rule engine into the architecture. Moreover, a set of JSP/JSF web pages are generated composing the user interface which is based on the RichFaces framework to add AJAX capability to JSF applications. Required Java libraries (Jess, JSF, Richfaces,...) and default con guration are injected to provide presentation templates and style sheets for pages, prede ned navigation between them and default functionality for the generated Web application. 3
This section describes the transformation from OWL and SWRL to Jess. Since OWL semantics is richer than semantics of production rule systems such as Jess, only a part of OWL can be represented in Jess. To illustrate the subset of OWL supported by the proposed transformation, the family relationships example [15] was used. Fig. 2 shows the family related classes created with the TwoUse OWL graphical editor.
Domain concepts are represented as named classes, which can have subclasses. In the example the Person class has two subclasses, Man and Woman. Individuals in OWL are instances of classes declared as being a member of a speci c class through the type link. Cain, Abel, Enoch and Seth are individuals of Man class. OWL provides several class extension constructs to de ne unnamed anonymous classes. The \oneOf" expression enables the de nition of an enumerated class through the list of individuals that constitute the instances of the class. An example of enumerated class is ffemale, maleg.
In OWL two types of properties are distinguished: datatype properties, relations between instances of classes and primitive data types (e.g. integer or string); and object properties, relations between instances of two classes. Each property has a domain and a range. In the family example, the hasSex object property has a domain of Person and a range of ffemale, maleg, relating instances of the class Person to one of the possible enumerated instances. The default behavior in OWL indicate that a property can relate an instance of the domain to multiple instances of the range. To relate an individual to only one other individual a property is de ned as functional, as example hasSex.
It is possible to further constrain the range of a property with property restrictions. The \has-Value" restriction specify classes based on the existence of particular property values. A property restriction can be treated as an anonymous OWL class, which means that it is possible to de ne another OWL class as a subclass of a property restriction. In the example, Woman is a subclass of \hasSex has female". Similarly, Man is subclass of \hasSex has male".
The family ontology de nes several object properties to represent family relationships between individuals, as Fig. 3 shows. The hasBrother and hasUncle object properties have the domain of Person and the range of Man. hasParent has Person as domain and range. Those three properties are non-functional. Moreover, three property assertions are de ned, hasBrother(Cain, Abel), hasBrother(Cain, Seth) and hasParent(Enoch, Cain).
The generation of Jess code from OWL is supported by a model-to-model transformation which maps elements of the OWL metamodel to elements of a Jess metamodel. Fig 4 (a) shows the Jess model obtained from the family ontology, focusing on the mapping from OWL classes and properties to Jess templates and slots. The execution of a model-to-text transformation to this Jess model generates the code listed on Fig 4 (b). (deftemplate Person (slot id_Person) (slot hasSex (allowed-values male female)) (multislot hasBrother) (multislot hasParent) (multislot hasSibling) (multislot hasUncle) ) (deftemplate Man extends Person (slot id_Man) (slot hasSex (default male)) ) (deftemplate Woman extends Person (slot id_Woman) (slot hasSex (default female)) )
A summary of the ATL transformation rules de ning that mapping are as follows. Every OWL named class is mapped to a Jess fact template. A subclass relation is represented through the extends template property, allowing only simple inheritance of templates. OWL properties, both datatype and object ones, are mapped to slots. Each slot is added to the template corresponding to the domain class of the property. Functional properties generate slots (single-valued) whereas non-functional properties generate multislots (multi-valued). When the range of a property is an enumerated de ned through a \oneOf" OWL anonymous class, the enumeration literals obtained from the individuals linked to the enumeration are saved as a list of allowed-values for the slot. A \has-Value" restriction is transformed to a slot default value.
As Fig 4 shows, the style of the generated Jess code is quite di erent to
the Jess code obtained in other tools like the Protege JessTab [
Fig 5 (a) shows the Jess model obtained from the family ontology focusing on the mapping from individuals members of named classes to Jess facts de nitions. All individuals are considered di erent of each other. Each individual is mapped to a fact de nition. Each property assertion generates a value for a slot of the corresponding fact de nition. In the example, the assertions hasBrother(Cain, Abel) and hasBrother(Cain, Seth) generate the Cain fact de nition to have the hasBrother multislot with Abel and Seth values. The de acts sentence grouping all fact de nitions is loaded as the initial state of the Jess rule engine working memory.
(deffacts all_individuals_http://... "All individuals definitions ) (Man (id_Person Cain) (id_Man Cain) (hasBrother Abel Seth) ) (Man (id_Person Abel)
(id_Man Abel) ) (Man (id_Person Enoch) (id_Man Enoch) (hasParent Cain) ) (Man (id_Person Seth)
(id_Man Seth) )
To nish the description of the use case, an example of SWRL rule is dened to infer the uncle relationship between family members. This rule is shown in Fig. 6 and it derives the value of the hasUncle property: for those individuals of Person type (x1 ) who has other individual of Person type (x2 ) related through the hasParent property, and that second Person (x2 ) has an individual of Man type (x3 ) related through the hasBrother property, the rule derives a new assertion staying the hasUncle relation between x1 and x3 individuals.
The rule antecedent is mapped to a set of pattern matchings and conditional expressions. In the rule consequent, each individual property atom maps to a modify function that update fact slots. The following code is generated from the SWRL uncle rule.
Each variable in the rule antecedent, ?x1, ?x2 and ?x3, is mapped to a pattern matching allowing the rule engine to match facts for the variables. The third and fourth test conditional expressions are obtained from the individual property atoms of the SWRL rule antecedent. Two more test conditional expressions are added, the rst one checks that the three matched facts are di erent, and the second is necessary because without it the monotonic nature of the rule engine algorithm generates an in nite loop when the action has a modify function. 4
A second MDD process is applied (see Fig. 1) to generate a Web architecture that embeds rules into a Web application. The generated application is divided in two layers: business and user interface. The business layer is composed of a set of Java classes that we can di erentiate between the JavaBeans obtained from the named classes of the ontology, a set of helper classes implementing some necessary functionality, and a JessEngineBean class that implements the interaction with Jess through the Jess API, embedding the rule engine and the rule base into the Web application. The user interface layer is composed of a list of JSF web pages allowing end-users to interact with the system and accomplish the prede ned functionality. 4.1
Architecture of rule-based Web applications
Apache Tomcat business logic Java Classes
Jess Rule set rule engine working memory (facts)
Jess facts JSF + RichFaces
pages
The embedded rule engine manages the Jess rule base and a text le of persistent facts. Basically, the rule engine consists of three parts: the working memory which contains all the instances or facts, the rule set that includes the production rules, and the rule engine that checks what facts in the working memory match the rule conditions and executes the rules whose condition is matched as true. To make the facts persistent, they are stored on disk as a text le.
The Web application enables end-user to perform the most common functions for instance management: create, list, update and delete instances (CRUD). This functionality was prede ned as a design decision of the proposed approach. The code generation process is designed to implement these functions since they constitute the basic information management tasks that any information system should o er. Currently there are many tools that automatically generate CRUD Web applications code from di erent sources, like from databases such as NetBeans8, or from UML models such as MagicDraw M2Flex9. Those Web applications perform CRUD functions on relational databases. In contrast, our contribution provides a Web application where the information management functions are executed on the rule engine working memory, enabling the rule engine to run a forward-chaining inference mechanism that res the rules which conditions are evaluated as true and executes rule's actions to deduct new information or modify existing one.
Fig. 8 shows a screenshot of the resulting Web application for the family example, in concrete the list of all instances of Person charged on the rule engine working memory. The list contains the four individuals de ned in the OWL ontology and the three property assertions staying the brothers of Cain and the parent of Enoch. In addition, the HasUncle property has values for Enoch since the rule engine has derived those values ring the uncle rule. Using the Web application, end-users can add new persons, erase or modify persons using a form that shows all the properties of the person to edit. Some property values such as the HasUncle, are not editable by the user since it is the rule
engine who obtains those values. This restriction is de ned at design time using the interaction model, as described in next section. Fig 9 shows the metamodel proposed for de ning Web models based on Java/JSF architecture. An ATL transformation maps OWL models to Web models in accordance with this metamodel. Basically the structure of the information managed by the Web application is de ned from OWL classes, properties, and individuals. Each OWL named class is mapped to several elements: a JavaBean, a managed bean to be included in the con guration le, and two JSF pages, one for listing all instances of the class and other that shows all the individual's properties and their values enabling instance creation and edition.
Most of the user interface is prede ned as well as navigation links between
pages. However, some necessary features are included into an interaction and
presentation model which is used by the ATL transformation to obtain the Web
model. The edition of a speci c individual implies that some properties are
editable by the user, whereas other are derived by the rule engine inference
process. For example, hasBrother property of an instance of Person is editable
whereas the hasUncle value is not editable because it is obtained by a rule.
This kind of restriction must be modeled in the interaction and presentation
model that enables the speci cation of user interactivity and element's visibility
features, enabling user interface customization. For example, it makes it possible
to select what classes will appear in the application menu and what properties
are included as columns of the table listing all individuals of that class (see Fig.
8).
Some previous work proposes the generation of Jess rules from ontology and rule
models, such as OWL [20] and SWRL [25]. Those works focus on the de nition of
reasoners for OWL and Jess, where the main issue is to derive certain facts based
on the OWL and SWRL semantics, respectively. The most important di erence
between those works and our proposal is that they run the generated rule base in
a development tool such as the Protege JessTab [
The de nition of processes, techniques and models suitable for Web
application development is the goal of Web Engineering. Methodologies such as UWE
[17], WebML [
Currently the de nition of a model-driven methodology for creating
rulebased systems embedded in (semantic) Web applications is a working topic. In
[
This paper applies MDD to rich Web system development, incorporating a Jess rule engine for inferencing and deriving new information. OWL and SWRL formalisms are used as modeling languages by the model-driven approach.
To illustrate the proposed method and supporting tool, a simple and well known use case has been used. The approach is planned to be evaluated in several domains such as pest control in agriculture and medical diagnosis.
Since expressiveness in rule-based production systems such as Jess is poorer than OWL and SWRL semantics, only a subset of those formalisms is supported. Issues related with the combination of rules and ontologies have also an e ect on the proposed approach. For example, the semantics of OWL and SWRL adopts an open world assumption, while logic programming languages such as Jess are based on a closed world assumption. As a consequence, only DL-Safe SWRL rules [22] are transformed to Jess. DL-Safe SWRL rules are a restricted subset of SWRL rules that has the desirable property of decidability, by restricting rules to operate only on known individuals in an OWL ontology. Similarly, Jess rules only operate on facts in the working memory.
Other factor to take into account is the high time and e ort necessary for developing a MDD supporting tool, which makes any model-driven approach an appropriate solution only when is useful to provide a tool that can be used in the construction of many similar systems, in many domains. In contrast, some strengths are obtained, such as the drastic cost reduction in time and e ort for development rule-based Web applications since the tool makes all the hard work for us. Also, an incremental development is favored with this approach since changes in the model can be directly re ected in the system implementation.
Future work extends the generated Web application with semantic Web functionalities, such as semantic search based on ontology classes hierarchy as well as instance search. To avoid the semantic gap between OWL and the rule engine, a solution would be the use of a reasoner such as Pellet10 which directly interprets OWL and SWRL.
Acknowledgments. This work was supported by the Spanish Ministry of Education and Science under the project TIN2004-05694, and by the Junta de Andalucia (Andalusian Regional Govt.) project P06-TIC-02411. 10 http://clarkparsia.com/pellet 13. Geary, D., Horstmann, C.S.: Core JavaServer Faces. Prentice Hall, 2 edn. (2007) 14. Groenewegen, D.M., Hemel, Z., Kats, L.C.L., Visser, E.: WebDSL: a domainspeci c language for dynamic web applications. In: Harris, G.E. (ed.) OOPSLA Companion. pp. 779{780. ACM (2008) 15. Horrocks, I., Patel-Schneider, P., Boley, H., Tabet, S., Grosof, B., Dean, M.: SWRL:
at http://www.w3.org/Submission/SWRL/ (2004) 16. JBoss: RichFaces (2007), http://www.jboss.org/jbossrichfaces/ 17. Koch, N., Knapp, A., Zhang, G., Baumeister, H.: UML-based web engineering. an approach based on standards. In: Rossi, G., Pastor, O., Schwabe, D., Olsina, L. (eds.) Web Engineering: Modelling and Implementing Web Applications, pp. 157{191. Human-Computer Interaction Series, Springer London (2008) 18. Lima, F., Schwabe, D.: Application modeling for the semantic web. In: LA-WEB.
pp. 93{102. IEEE Computer Society (2003) 19. Linaje, M., Preciado, J.C., Sanchez-Figueroa, F.: Engineering rich internet application user interfaces over legacy web models. Internet Computing, IEEE 11(6), 53{59 (2007) 20. Mei, J., Bontas, E.P., Lin, Z.: OWL2Jess: A transformational implementation of the OWL semantics. In: Chen, G., Pan, Y., Guo, M., Lu, J. (eds.) ISPA Workshops.
Lecture Notes in Computer Science, vol. 3759, pp. 599{608. Springer (2005) 21. Moreno, N., Melia, S., Koch, N., Vallecillo, A.: Addressing new concerns in modeldriven web engineering approaches. In: Bailey, J., Maier, D., Schewe, K.D., Thalheim, B., Wang, X.S. (eds.) WISE. Lecture Notes in Computer Science, vol. 5175, pp. 426{442. Springer (2008) 22. Motik, B., Sattler, U., Studer, R.: Query Answering for OWL-DL with rules. Journal of Web Semantics 3(1), 41{60 (2005) 23. Object Management Group: Semantics of Business Vocabulary and Business Rules (SBVR). http://www.omg.org/spec/SBVR/1.0 (2008) 24. Object Management Group: Ontology De nition Metamodel. Version 1.0.
http://www.omg.org/spec/ODM/1.0/ (2009) 25. O'Connor, M.J., Knublauch, H., Tu, S.W., Grosof, B.N., Dean, M., Grosso, W.E.,
swrl. In: Gil, Y., Motta, E., Benjamins, V.R., Musen, M.A. (eds.) International
986. Springer (2005) 26. Paptaxiarhis, V., Tsetsos, V., Karali, I., Stamotopoulos, P.: Developing Rule-Based web applications: Methodologies and tools. In: Handbook of Research on Emerging
392. IGI Global (2009) 27. Parreiras, F.S., Staab, S., Winter, A.: TwoUse: integrating UML models and OWL ontologies. Tech. rep., Universitat Koblenz-Landau (2007) 28. Ribaric, M., Gasevic, D., Milanovic, M., Giurca, A., Lukichev, S., Wagner, G.:
395. Springer (2007) 29. Russell, S.J., Norvig, P.: Arti cial intelligence: a modern approach. Prentice-Hall,
30. Vdovjak, R., Frasincar, F., Houben, G.J., Barna, P.: Engineering Semantic Web