Rule-driven approach for adaptable e-learning content delivery

Rule-driven approach for adaptable e-learning content delivery Boyan Bontchev, Dessislava Vassileva Faculty of Mathematics and Informatics, Sofia University, 5, J. Baurchier blv., Sofia 1164, Bulgaria, [email protected], [email protected] Abstract: In recent years, the number of adaptive systems for e-learning content delivery increased immensely. Usually, such applications use adaptive engines to control adaptive content management. Therefore, it appears necessary to design and construct an adaptation engine in a way enabling it to be flexible and manageable. The present paper is aimed precisely at this problem. It describes formalization of an adaptation model for hypermedia learning courseware. Next, there is given a formal definition of both adaptive rules and adaptive process based on our model. We provide a way for adaptive engine’s construction, which is consistent with this formalization and follows a rule-driven approach. The benefit of this suggestion is separation of adaptive rules from business logic. This allows easy implementation of the system and possibility of editing adaptive rules at any time.

1. Introduction From learner point of view, the most effective e-learning systems are the adaptive ones. They do not just place materials on the web space as conventional hypertext systems do; they have the purpose to provide educational content in a way most satisfying student needs [1]. They are entirely oriented to individual user’s goals, preferences and knowledge [2]. Each adaptive hypermedia system (AHS) has its own decision mechanism and method of assuring adaptation. Some applications achieve it using one or several of the most widespread techniques such as adaptive navigation, structural adaptation, adaptive presentation and historical adaptation. Other of them focus on adaptability to learners’ current knowledge based on the theory of knowledge spaces or introduce additional level of system self adaptability based on the idea that different forms of learner model can be used to adapt content and links of hypermedia pages to given user. The above techniques facilitate adaptive presentation of information. They could be used for implementation of static adaptation or of dynamic one driven by an engine controlling the adaptation. The adaptation engines not only choose what adaptive technique to apply but also they manage the entire process of adaptation. There are various well-established ways for ensuring adaptation. Following these ways, the adaptation engine can be constructed by means of: • symbolic rules – this is one of the most illustrative methods for presenting adaptation. The adaptation is described by setting rules of type . The rules set conditions and actions to be implemented when these conditions are observed. For rules’ description, there can be used XML based languages such as RuleML [3], Semantic Web Rule Language (SWRL) [4] or others appropriate means as for example UML diagrams or first-order logic predicates. • case-based reasoning (CBR) [5] – an approach that stores a set of past situations with their solutions and, in similar or same cases, uses them or a similar solution. There are four phases of implementation: retrieve, reuse,

revise and retain. Usually this approach is used to assess learner knowledge and perform instructional tasks [6]. Disadvantages of CBR are that: o it is dependant on the cases and suffers from a lake of reuse/repurposing of the instructional strategy (it is depend from the cases). o high implementation complexity and lack of interoperaility. • IMS Learning Design (IMS LD) [7] – this is a metalanguage for learning scenarios description maintained by IMS Global Learning Consortium. The language is represented through XML notation. It allows scenarios to be separated from learning materials. Adaptation can be provided by defining conditions for the presentation of learning content and sequencing of learning activities. The most prominent implementations of IMS LD are the IMS LD engine for playing LD called CopperCore [7] and, also, the RELOAD editor which can be used to author learning designs in IMS LD format. Disadvantages of IMS LD are that: o pre-defined adaptation – learners’ assessment and/or feedback cannot affect the choice of a pedagogical strategy. More self-adaptation is not feasible. o implementation -IMS LD imposes higher complexity. The main problem described in this article concerns various ways for an effective and flexible construction of adaptation engine, with easy control over adaptation based on declarative rule description. After investigating several approaches described over, we chose the apparatus of symbolic rules as they do not suffer from drawbacks stated over because of their high level of independence, selfadaptation and interoperability and, also, low implementation complexity. Therefore, we find them most suitable among the three means given above, for implementing our conceptual model of self-adaptive hypermedia system. As well, implementation based on symbolic rules is most universal regarding possible redevelopment targeted to other adaptation models. The paper is structured as follows: it provides a brief description of our triangular conceptual model of AHS used further for determining the adaptation

process and featuring main functionalities of the engine for adaption control. In order to facilitate creation of a clearer specification of the adaption engine, we will describe adaption engine functionality in a formal way. Based on this formalization, next we will offer two ways for construction of the adaption engine – one by using Drools rule engine [8] and another one by rule description in SWRL [4]. Finally, we conclude that both these ways allow software construction assuring flexibility, easy expandable functionality and improved adaptations.

2. Our conceptual model of AHS The AHS model described in details in [9] follows a metadata-driven approach, explicitly separating narrative storyboard from the content and adaptation engine (AE). Fig. 1 represents the triangular structure of our model which refines the AHAM reference model [10] by dividing in three each one of the learner’s (or, generally speaking – user’s), domain, and adaptation models. This is a new hierarchical organizational model for building AHS. At first level, the model is based on a precise separation between learner, content and adaptation model, while at second level each of these sub-model is divided into three others sub-models [11] for different purposes of effective and flexible adaptability.

Fig. 1: Principal structure of the triangular conceptual model. Fig. 1 represents the triangular structure of the model. Unlike other approaches, in the learner model we separate goals and preferences from shown knowledge and performance, as the first sub-model is used for personalization while the second one is used for adaptive content selection. The model of learning style (such as activist, reflector, pragmatist and theorist) is detached as another learner sub-model because it is used for used for adaptive navigation throughout the narrative storyboard. While the learning style can be determined in the very beginning of the learning explicitly by the learner or by appropriate pre-tests, other tests should be exercised during the e-learning process in order to assess prior or gained knowledge and performance results of each individual student. The domain model is composed of domain ontology, content itself (granulized in learning objects (LOs) according to the SCORM standard) [12] and LO’s metadata (LOM) [11] and ontology metadata. The ontology forms a logical taxonomy for the knowledge domain built during the content composition process by the author and is used for browsing and searching of LOs. The content LOs are placed by the instructor on course pages, while pages represent

nodes within course storyboard graph. Content pages delivery is controlled by the adaptation engine (AE) for choosing most appropriate content for presenting it to the user with given learning model. Instead of choosing dynamically a page (i.e. node of the storyboard graph) with its content, we propose choice of best working path within the graph for specific learner with given learning style on one hand, and shown prior knowledge and performance on the other. The adaptation model (AM) captures the semantics of the pedagogical strategy employed by a course and describes the selection logic and delivery of learning activities/concepts. AM includes a narrative storyboard submodel supporting course story-board graphs, which may differ for different learning styles. It consists of control points (CP) and work paths (WP). Moreover, AM should provide a schema of storyboard rules used for controlling the e-learning process. Storyboard rules determine sequencing of the course pages upon inputs from learner sub-models and are separated from the narrative storyboard as in order to be used independently. The narrative metadata sub-model maps rules to storyboard pages such as rules for passing a CP (e.g., as threshold level of assessment performance at that CP) or for returning back to the previous CP. The core of our model is the adaptation engine (AE) which is responsible for generating the actual adaptation outcomes by manipulating link anchors or fragments of the pages’ content before sending the adapted pages to a browser. The AE uses an event-driven mechanism for controlling the storyboard execution based on the storyboard rules applied to the inputs from the learner model. AE selects the best storyboard WP within the graph by evaluating weight coefficient of the pages within the WP for the given learner style [13]. The AE is responsible for performing all necessary adaptation mechanism for content delivery to a specific learner. This includes content selection, content hiding, link annotation, link hiding, etc. When learner starts a new course, adaptive engine finds the best path for him/her in the course graph. The best path is that one with the highest weighed score. For a particular user, the best path is calculated by a sum of multiplications between page parameters values and weights of their correspondent learner’s characters. This path is stored for learner as current work path. When learner asks for the next page, adaptive engine may hide objects that are not important for this user. It may also select proper link annotations. As many users are passing through the courses, adaptive engine has to remember user tracks. If a user abandons the work path determined by AE (by clicking on a link leading to another page outside of the path), the AE continues tracking pages the user has passed through giving the user ability to return back to the path by adding the link “Return to the WP” to each of the pages. As well, AE may store some statistics of learner feedbacks to determine which pages are useful for which kind of users. This gives the adaptation engine ability to learn from their skills and perform better estimations for paths for further learners.

3. Formal specification of the model In this chapter we will give a formal description of adaptation process based on the triangle model. For description of formal model can be used Object Constraint Language [14] like in the Munich Reference Model [15], descriptive language for specification like in GAHM or predicate logic like in the Dexter Hypertext Reference Model [16, 17]. In

this paper for the formal model description will be used predicate logic [18]. It is extension of propositional logic with separate symbols for predicates, subjects and quantifiers. Its formulas contain variables which can be quantified. Predicate logic uses a wholly unambiguous formal language interpreted by mathematical structures. This enables for clearer adaptive process understanding and more precise adaptive rules description. We claim that an adaptive hypermedia system can presents like a quadruple (LM, DM, AM, AE). Every element of it presents a sub-model of the triangular model and its core - adaptive engine. For each of the items in the set (LM, DM, AM, AE) will be defined predicates that describe main functionalities of respective sub-model: • LM presents the learning model. For user’s learning style can be defined by constants. The predicate that shows the level of belonging of a user to given learning style is: o user_learning_style(user_id, learning_style, value) where learning_style={theorist, activist, pragmatist, reflector}. Predicates representing knowledge and performance of the learner are for example: o user_knows_learning_object(user_id, lo_id) similar to the above predicates, it returns true if the user with identificator user_id knows learning object with identificator lo_id, o user_performance(user_id, subject_id, control_ point_id, value) as value={pass, fail, notReach} – the test result value can be pass if the student passes test in related control point successfully, can be fail else and notReach if the learner is not doing this test. • DM defines predicates related with the domain model. This predicates can be divided into two groups. The first group presents hierarchical links in particular domain graph. The second group presents that a particular test question belongs to a given learning object and the answers for a question together with its assessment points (value). • AM includes predicates representing functionalities from the adaptation model such as: o graph composition o subject content o page sequencing and page link annotation presented by relevant predicates:
link_pages(current_page_id, next_page_id)
link_pages_annotation(learning_style, link_id, annotation) • AE defines predicates related to the triangular model core – adaptation engine: o next_cp_path(user_id, subject_id, previous_cp_id) – it defines the path for student with user_id to next control point o sub_precondition(subject_new_id, subject_old_id) – it describes preconditions or the courses (subject_old_id) that need to know to start a new subject subject_new_id. o precondition_subject(subject_new_id) – it returns true if all preconditions are realized. o user_precondition(user_id, subject_id) – it checks if user user_id is realized all necessary preconditions to start the subject with subject_id. Once we have defined the predicates describing main functionalities of the triangular model we can begin giving adaptive rules. They can be presented by defining relationships between the predicates. The adaptive rules can

be divided into three main groups in accordance to their purpose: • starting rules - these rules describe learner knowledge and the initial conditions for starting a new course. If the user knows all learning objects contained in a domain/subject, then she/he knows that domain/subject – (1), (2): (1) ∀useri ∃domainj(∀lok domain_lo(domainj , lok)∧ user_knows_learning_object(useri , lok))→ user_knows_domain(useri, domainj) (2) ∀useri ∃subjectj(∀lok lo_4_subject(subjectj , lok)∧ user_knows_learning_object(useri , lok)) → user_knows_subject(useri , subjectj) If the learner knows all subjects, which participate in precondition for given subject, then the learner can start learning it – (3), (4): (3) ∀subjectj ∃useri(user_knows_subject(useri, subjectj) ∧ sub_precondition(subjectk , subjectj)) → user_precondition(useri, subjectk) (4) ∀useri(user_precondition(useri, subjectj))→ next_cp_path(useri, subjectj, null) •

pass-through graph rules – consist of rules for the graph crawling. If the learner passes or not the test at a control point, she/he continues respectively forward (5) or backward (6): (5) ∃k(user_performance(useri, subjectj, control_pointk, pass)) → next_cp_path(useri, subjectj, control_pointk) (6) ∃k(user_performance(useri, subjectj, control_pointk, fail)) → next_cp_path(useri, subjectj, control_pointk-1)

•

rules updating learner model – this rules are related to learner knowledge and performance. If the learner passes all control point’s tests for particular subject then the learner knows this subject – (7): (7) ∀k(user_performance(useri, subjectj, control_pointk, pass)) → user_knows_subject(useri , subjectj) If the learner passes particular control point’s test then she/he knows learning objects contained in the selected control point path – (8): (8) ∀k ∃i(user_performance(useri, subjectj, control_pointt, pass) ∧ page_4_cp_path(pathm, paged) ∧ lo_4_page(paged, lok) → user_knows_learning_object(useri , lok)Construction of the adaptation engine

4. Construction of the adaptation engine In this chapter, we will present a proposal for construction of adaptation engine by means of symbolic rules. For realizing such a goal, the most suitable means to be used are a rule description language such as SWRL [4] and RuleML [18] and its execution engine, or a rule execution platform such as Drools [8], Jess [18], Java Rules Engine [19], Jena-2 [20], etc. We have chosen to present our rules both through Drools and SWRL. Motives to select exactly them are that on the one hand, for Drools and SWRL, there are available very good and convenient graphical editors and tools for presentation, editing and reviewing rules such as Protégé for SWRL [4] and RuleFlow for Drools [8]. On the other hand, SWRL aims to be the standard rule language of the Semantic Web, which will allow interoperability between different rule

engines. Also, Drools is an open source rule engine written in Java language and JSR 94 compliant, which enables it to be embedded and used in a Java based application. Moreover, Drools can reduce complexity of components that implement the business rules logic in Java applications, and it is easy to maintain or extend the business logic by declarative programming. 4.1. Execution rules in Drools The Drools is an open source rules Java engine provides an application for managing rules called Business Rules Management System (BRMS), which allows to create, modify, delete, branch and persist rules. Adapting the Rete algorithm to an object-oriented interface allows for more natural expression of business rules with regards to business objects. Drools expresses business logic rules in a declarative way. The Drools architecture is based on three main components: production memory that stores the rules, working memory that stores the facts and the inference engine. The rules can be written using a non-XML native language – Drools Rule Language (DRL) [8], a XML native language as an alternative of DRL which allows capturing and managing rules as XML data and in a spreadsheet format (supported formats are Excel and CSV). Drools development platform comes in two flavors: as an Eclipse plug-in Drools IDE and as Web application Drools BRMS [8]. The Drools IDE provides developers with an environment to edit and test rules in various formats, and integrate it deeply with their applications from within Eclipse. The IDE has a textual/graphical rule editor, a RuleFlow graphical editor, a domain specific language editor. Other advantages of the Drools are: • it separates your application from conditions which control the flow o rules are stored in separate files o changing rules does not require to recompile or to redeploy the whole application o putting all rules into one place makes it easier to control or manage the flow of the application • problems are not solved using a complicated algorithm, but via rules, which are easier to read and understand than code • Drools is supported by an active community and gaining popularity among Java developers

rule "Pass the test in control point on level k" when UserPerformance(user_i:user_id, subject_j:subject_id, control_point_k:control_point_id, value==”pass”) then eval(NextCpPath(user_i, subject_j, control_point_k)); end; where in the section when is described the left hand side of formulas (6) and in the section then is described right hand side of (6). Similarly, there can be rewritten all the other rules. Thereby, all the formulas formally defined by predicates should be converted to DRL rules. The resulted DRL rules are used by the inference engine together with the facts (e.g., data about both the learning model and the adaptation model) as shown in fig. 3. The inference engine itself contains a pattern matcher which produces agenda of rules to be executed for given facts. This agenda is executed by an execution engine which may execute some actions for giver rules and produce some result facts.

Predicates

Convertor

Facts

DRL Rules

Pattern Matcher

Agenda

Execution Engine

Inference Engine Adaptable Content Delivery

Fig. 3: Principal structure of the rule engine.

Fig. 2: Structure of a sample Drools’ rule [8]. The structure of a Drools’ rule (fig. 2) includes one or more attributes providing a declarative way to influence the behavior of the rule, one or more conditions (in when section), and a list of actions (in then section). For example, the rule (6) given within the previous chapter can be written as Drools’ rule like this:

4.2. Execution rules in SWRL SWRL [4] is intended to be the rule language of the Semantic Web. The specification was submitted by the National Research Council of Canada, Network Inference, and Stanford University in association with the Joint US/EU ad hoc Agent Markup Language Committee. SWRL is based on OWL and all rules are expressed in terms of OWL concepts. A SWRL file is an OWL ontology, whose axioms are extended with rule axioms. It thus extends the set of OWL axioms to include Horn-like rules and enables Horn-like rules to be combined with an OWL knowledge base. The SWRL rules can be described through Abstract Syntax, XML Concrete Syntax and RDF Concrete Syntax. SWRL allows users to write Hornlike rules expressed in terms of OWL concepts to reason about OWL individuals. The rules can be used to infer new knowledge from existing OWL knowledge bases.

The SWRL Specification does not impose restrictions on how reasoning should be performed with SWRL rules. Thus, investigators are free to use a variety of rule engines to reason with the SWRL rules stored in an OWL knowledge base. They are also free to implement their own editing facilities to create SWRL rules. In common with many other rule languages, SWRL rules are written as antecedent-consequent pairs. In SWRL terminology, the antecedent is referred to as the rule body (rule_eml:_body tag) and the consequent is referred to as the head (ruleml:_head tag). The head and body consist of a conjunction of one or more atoms. At present, SWRL does not support more complex logical combinations of atoms. SWRL also supports literals, built-in predicates, which greatly expand its expressive power. For example our rule (7) can be written in SWRL XML Concrete Syntax like that: user_i subject_j control_point_k result

user_i subject_j , where in the tag is described the left hand side of formulas (6) and in the section is described right hand side of (7). Similarly, can be written and our other rules. Moreover, for our rules description in SWRL, we can use the Protégé-OWL editor, through SWRL Tab plug-in. Protégé provides a possibility the rules to be described in a way very similar to first-order logic predicates, which removes necessity from rewriting them. After we have SWRL rules, rule engine is needed to process them. As the most suitable for this purpose can be stated the Jess rule engine in view of the fact that in Protégé, through the button SWRLJessTab can to be transfer all SWRL rules to Jess. This is a rule engine for Java platform and can be embedded in Java-based application. The priority of the combination between SWRL rules and Jess, over the Drools is in interoperability support. 4.3. Comparison between Drools and Jess rule engines Now, we will do a comparison between the two rules engines selected above (Drools and Jess) for construction of our adaptive engine. More, we will compare to them some other popular rule engines, namely Jena-2 [20] and Algernon [21]. For the purpose of comparison we have defined 10 criteria as given in table 1. Here, rules tools are for creating and editing of rules through a convenient and easy way. The table describes rule engines properties for each defined criterion.

Table 1: Rule engine comparison. Criteria Interoperability

Rules tools

JSR94 Support

Maturity level

Drools

No

yes (special IDE, RuleFlow)

yes

Jess

No

no

Jena-2

Yes

Algernon

No

Rule Engines

Algorithm

Availability

Mode of working

Classes and instances

++++

ReteOO, forward chaining

open source

run from JVM

Java objects

yes

+++

enhanced Rete, forward chaining

commercial with academic license

shell or batch, plug-in in Protégé

CLIPS file

no

no

+

forward chaining, backward chaining

open source

run from JVM

Protégé database/ CLIPS files from Protégé

yes (trough Protégé)

no

+

forward chaining, backward chaining

open source

plug-in in Protégé or stand-alone

RDF file (Protégé format)

As we see in table 1, both Drools and Jess have the highest maturity level and support JSR 94 specification. Drools outweighs Jess especially because of availability of very good means for rule creating and editing. However, the combination of Jess and Protégé fills this gape and adds possibility for interoperability between SWRL rules.

5. Conclusions Adaptive e-learning platforms tend to open one of the most promising research areas in next several years. In this paper, there was introduced a conceptual approach for self adaptive hypermedia applications using triangular conceptual model.

The main benefit of the proposed model is in assuring strong independence of any of the building models and, at the same time, in facilitating a flexible adaptation of content delivery. It can be supported by different system architectures not limiting application of various adaptation techniques, such as adaptive presentation, navigation support and content selection. The adaptive process for e-learning content delivery was formalized through usage of predicates and relationships between them. On the base of such predicates, there were built formal rules controlling the adaptation process and executed by the adaptation engine. For describing the rules, two approaches have been considered – Drools Rule Language and SWRL. Both the approaches are supported by rule engines which executes rules described in correspondent language. It has been stated, that both of them are suitable for constructing an adaptation engine supporting the conceptual model. This is thanks to the fact they do support rules defined by first order logic predicates. The main innovation of the proposed approach for adaptive engine construction is that unlike others it is based on a strong separation of adaptation rules from business logic. Thus, it enables easy implementation and rules modification, which allows a flexible adaptation process. There have been compared several rule engines according to some preliminary selected criteria. Based on this comparison showing the weaknesses and advantages of the rule engines, we may choose Drools for the ongoing implementation of the adaptation engine. The choice of Drools is strongly influenced by the facts it provides advanced rule management tools with sophisticated GUI, detailed documentation, and open source license. Moreover, Drools is supported by a steadily growing community of end users. Next, the adaptation engine is going to be integrated and tested within a adaptive e-learning platform providing an authoring tool for construction of learning courseware as SCORM compliant learning objects and, also, an instructor tool for structuring the narrative storyboards and planning the instructional design – both developed at Sofia University [9,11,13].

References [1] Dagger, D., Wade, V., Conlan, O.: Personalisation for All: Making Adaptive Course Composition Easy. Special issue of the Educational Technology and Society journal, IEEE IFETS, 2005. [2] Brusilovsky P.: Adaptive Hypermedia: An attempt to analyze and generalize. Proc. of First International Conf. on Multimedia, Hypermedia and Virtual Reality 1994. Brusilovsky P. & Streitz N. (Eds.) LNCS 1077, Springer Verlag, pp.288-304. [3] Yevgen Biletskiy, Harold Boley, Girish R Ranganathan. RuleML-based Learning Object Interoperability on the Semantic Web, Interactive Technologies and SMART Education, Emerald, volume 5 issue 1, pp. 39-58, 2008 [4] Jing Mei, Harold Boley: Interpreting SWRL Rules in RDF Graphs. Electr. Notes Theor. Comput. Sci. 151(2), 2006, pp. 53-69 [5] Zongmin Ma (Ed), Web-Based Intelligent e-Learning Systems: Technologies and Applications (ISBN 159140-729-3), Chapter IX, pp. 175-193 [6] Guin-Duclosson, N., Jean-Daubias,S., Nogry S.: The AMBRE ILE: How to Use Case-Based Reasoning to Teach Methods, Lecture Notes in Computer Science, ISBN 978-3-540-43750-5 , Volume 2363/2002, pp. 782791

[7] Adriana J. Berlanga , Francisco J. García and Jorge Carabias: Authoring Adaptive Learning Designs Using IMS LD, Lecture Notes in Computer Science, Volume 4018/2006, ISBN 978-3-540-34696-8, pp. 31-40 [8] Proctor, M., Neale, M., Frandsen, M., Griffith S., Tirelli, E., Meyer, F., and Verlaenen, K.: Drools 4.0.5., http://downloads.jboss.com/drools/docs/4.0.5.19064.GA/ html_single/index.html, January 2008. [9] Vassileva D., Bontchev B.: Self adaptive hypermedia navigation based on learner model characters, Proc. of IADAT-e2006, Barcelona, Spain, July 12-14, 2006, pp.46-52. [10] De Bra P., Houben G.-J., Wu H.: AHAM: A Dexterbased Reference Model of Adaptive Hypermedia. Proceedings of the tenth ACM Conf. on Hypertext and hypermedia, ISBN: 1-58113-064-3, pp. 147-156. [11] Vassileva D., B. Bontchev: Modelling reusable adaptive hypermedia for e-learning platforms, Proc. of IADATe2004, Bilbao, Spain, July 7-9, 2004, pp. 225-229. [12] Rey-López, M.,Fernández-Vilas A.,Díaz-Redondo R., Pazos-Arias J.: Providing SCORM with adaptivity. Proceedings of the 15th international conference on World Wide Web, ISBN:1-59593-323-9, pp.981-982. [13] Vassileva, D., B. Bontchev, S. Grigorov. Mastering Adaptive Hypermedia Courseware, Proc. of 6th Int. Conf. on Emerging eLearning Technologies and Applications ICETA2008, September 11-13, Slovakia, 2008 [14] Richters M., Gogolla M.: On Formalizing the UML Object Constraint Language OCL, LNCS Vol. 1507, 1998, ISBN: 3-540-65189-6, pp. 449 - 464. [15] Koch N., Wirsing M.: The Munich Reference Model for Adaptive Hypermedia Applications. Proc. of the Int. Conf. on Adaptive Hypermedia and Adaptive WebBased Systems, 2002, ISBN: 3-540-43737-1, pp. 213 – 222. [16] Halasz, F., Schwartz, M.: The Dexter hypertext reference model. Communications of the ACM, Vol. 37, Issue 2, pp: 30 - 39, 1994, ISSN:0001-0782. [17] Ohene-Djan, J., Gorle, M., Bailey, C. P., Wills, G. B. and Davis, H. C. (2003) Understanding Adaptive Hypermedia: An Architecture for Personalisation and Adaptivity. In: Workshop on Adaptive Hypermedia and Adaptive Web-Based Systems AH2003, August 26-30, 2003, Nottingham, UK. [18] E. J. F. Hill, “Jess, the Rule Engine for the Java Platform”, http://www.jessrules.com/jess/docs/70/, Sandia, National Laboratories, October 2007. [19] Selman, D., Majoor, J., "The Java Community and Rule Engine Standards", http://www.w3.org/2004/12/rulesws/paper/107/ [20] Sun-Young Heo, Eun-Gyung Kim, "A Study on the Improvement of Query Processing Performance of OWL Data Based on Jena2," ichit, Int. Conf. on Convergence and Hybrid Information Technology, 2008, pp.678-681 [21] Crawford J., B. Kuipers. Algernon—a tractable system for knowledge-representation, ACM SIGART Bulletin archive, ISSN:0163-5719, Vol. 2, Issue 3, June 1991, pp.35-44

Acknowledgments The work reported in this paper is supported by the ADOPTA project funded by the Bulgarian National Science Fund under agreement no. D002/155.