today's web applications will agree that navigation support on the one hand .... files are dynamically generated by monitoring user behavior within the system.
Optimized One-to-One Personalization of Web Applications using a Graph Based Model Georg Sonneck and Thomas Mueck Department of Computer Science and Business Informatics University of Vienna Rathausstr. 19/9, 1010 Vienna, Austria georg.sonneck,thomas.mueck@univie.ac.at Abstract Everybody who already experienced loosing his way in today’s web applications will agree that navigation support on the one hand and interaction support on the other hand are crucial topics in any but the most trivial web-based applications. Such applications should help end users to fulfill their tasks most efficiently. In this paper we present our approach to achieve optimized one-to-one personalization of web applications, thus, leading to applications which assist end users in the most effective way. Our approach relies on a graph based model describing the navigational structure of hypermedia systems and a fully extensible XML schema description that models the structure of the nodes in the graph. Starting from these components, process graphs can be identified that correspond to specific business tasks the web application can be used for. These process graphs can be optimized by restructuring the nodes using graph transformations. Finally one-to-one personalization of nodes within the optimized process graph can take place by matching user profiles to node descriptions.
1. Introduction Due to the high maturity of current web technology many people are confronted with more and more sophisticated internet and intranet applications. Very often such applications provide as much functionality as possible getting so complicated that less technically minded end users often loose their motivation to use them. On the contrary it is not a viable solution either to constrain the user interface of a large web application to the needs of the most casual end users. One solution to this problem of providing too complex or too constrained applications is personalization.
In general personalization of hypermedia systems addresses the modification of the link structure (e.g. by adding shortcut links or suppressing links) or the compression of information on a page. We believe, that within web applications these modifications are needed and relevant. However, in this publication we address additionally the modification of the data acquisition and the access of stored data. These two modifications play a particularly important role in the era of web applications where task-oriented, data-intensive interactions with end users take place. Within our model, the modification of the navigation is done by refining the graph based model by several subgraphs corresponding to specific tasks or business processes which can be handled by using the web application. These so-called process graphs can be optimized further by applying graph transformation patterns. The modification of the data acquisition and the access of stored data leading to one-to-one personalization is described as well. It relies on the node description and the presence of user profiles. In this publication we aim to present the whole system architecture and the above mentioned components to provide the reader with a complete picture of our model. The paper is structured as follows: This section describes the problem and summarizes related work. In section 2 the overall system architecture is described, leading to section 3 where the structure of user profiles is addressed. Section 4 discusses the internal representation of the nodes. Subsequently the overall navigational structure of web applications is presented in section 5. This model is used further to specify process graphs, being sub graphs of the navigational graph of the web application. Finally rules for the optimization of the personalized process graphs are developed and applied to an example. In section 6 one-to-one personalization by matching user profiles and node descriptions is described leading to the last section that contains the conclusions and issues for further research.
0-7695-1926-1/03/$17.00 (C) 2003 IEEE
1.1 Related Work Several research directions already exist in the field of personalization. For example, in [12], requirement perspectives for customizable web applications are proposed. Web sites are personalized automatically using models to cluster visitors to different groups, as shown in [1],[2]. A model to describe adaptive hypermedia is proposed in [4] which uses an XML-based model for the personalization process. This model is based on a graph model, but it does not specify personalization possibilities directly based on the graph structure. The XML description for nodes is more like a resource description of information fragments. In our approach the node structure represents the typical structures that occur in web applications (see section 4). Dissemination systems using, a form of the publish/subscribe mechanism, are proposed in [3] to achieve personalization and also to take access control structures into account. In this paper we are not relying on publish/subscribe mechanisms to achieve personalization. Another approach builds a so-called Unified View out of underlying XML resources (see [9]) and subsequently enables personalization by mapping the Unified View to External Views that are presented to the user. Several approaches exist that try to extract information out of independent information sources (see [11]) which plays an important role in personalization. In general, three adaptivity dimensions are considered starting from adaptive hypermedia, namely user’s behaviour, technology and external environment. In the field of web applications, however, analysis in close conjunction with end users performing specific tasks by using a web application is less frequent. From our point of view the identification of process graphs that correspond to tasks in the web application builds a strong basis for personalization in a first step. In a subsequent step even more user-centred one-to-one personalization can take place. In the area of web application design, several attempts have been made to model navigation by taking regular use cases and UIDs into account (see [10]). Audience driven approaches like WSDM [5] try to solve problems that occur by using data driven approaches. Attempts to personalize web applications during all design phases by using OOHDM[14] have also been made [13]. WebML[6], a modeling language for hypermedia systems, supports personalization by including the predefined entities Group and User into the structure model. In the hypertext model site views associated with different user groups can be defined. In our system an assignment of users to user groups takes place as well, but our personalization does not exclusively rely on user groups; it is rather based on skills user groups and single users possess. In [7] the conceptional modeling of user profiles is ad-
dressed, enabling one-to-one personalization. One significant difference between their work and ours is that our model relies fully on XML and does not evolve from entity relationship diagrams.
2 System Architecture
Figure 1. System Architecture Meta Information Repository: - Navigation, process graph - Node description - Transformation productions
3 4 5
Profile Repository 6
Personalization Server
2 9
Web Server
1
User
10
7 8
Application
System
Figure 1 shows the overall system architecture. It aims to give a complete picture of our approach to achieve optimized one-to-one personalization of web applications. In figure 1 a page request within our proposed system architecture is illustrated. The web server delivers the request to the personalization server (step 2), which retrieves meta information concerning the structure of the application from the meta information repository (steps 3 and 4). This includes the node description, the navigation and process graph, as well as the transformation productions. With the process graph and the transformation productions an optimization of the process graph can be performed by the personalization server. Subsequently to achieve oneto-one personalization of the node, the profile information about the user (e.g. domain specific knowledge) is retrieved from the profile repository (steps 5 and 6). With the node description and the profile information one-to-one personalization of the node description can take place. Afterwards the application components are requested from the application (steps 7 and 8) and are subsequently modified according to this node description leading to a resulting page which is returned to the user (steps 9 and 10). In this publication we describe the functioning of the graph transformations based on process graphs and node description. Afterwards we show how a matching between user profile information and components within the node description can be carried out starting from defined user profiles and node descriptions. This matching has the potential to offer one-to-one personalization of nodes within a process graph that has been optimized as well.
0-7695-1926-1/03/$17.00 (C) 2003 IEEE
3 The User Profile Repository User profiles usually store data about users in context with an application or a whole system. Very often these profiles are dynamically generated by monitoring user behavior within the system. We think, that the information necessary to offer one-to-one personalization within web applications cannot be captured in this way, because what is interesting in this context are for example user skills and qualifications, or special interests of users. Because of that we suggest that the profiles are explicitly generated by system administrators which can furthermore assign each user to specific user groups having the same qualifications or interests. All attributes that are stored for users and groups are so-called skills within our system. To get a fine tuning of the profile users can finally fill in identification forms. Figure 2 shows exemplified user profiles for two users; additionally one group is present within the repository. The corresponding Document Type Definition is described in more detail in [17]. Figure 2. Exemplified user profiles
Of special interest are the elements with name Skillinst which can appear within the elements Group and User. Each Skillinst element is assigned to a specific Skill (identified by the attribute ofSkill) and can specify a value for the Skill. This distinction is important because components within the node description will reference Skill elements as well. A Skill element has a type where ’Exist’ means that it is already sufficient, when the Skill occurs within a profile.
4 Internal Representation of the Nodes Figure 3 shows the XML schema [19] design describing the internal structure of nodes occuring within web applications.
A Node has the attributes name which identifies the node, type which can be either ’navigational’ - describing that the node is used for navigation purposes -, ’informational’ - this node-type presents information to the user -, or ’interactional’ - this node-type offers means of interaction. The third attribute is scope which can be ’normal’, meaning that the node has no additional functionality, ’stategiving’ - after a node with this scope has been visited the information inserted at this node is available at all other nodes of the application -, or ’configurational’ - nodes with this scope are state-giving and can additionally be reached by all nodes within the same process graph. An important distinction within the schema is that a node of type ’interactional’ incorporates a sequence of Events whereas nodes of type ’informational’ or ’navigational’ have a sequence of Structures. An Event has the attribute type which can be either ’insert’, ’update’, ’copy’ or ’delete’. We are of the opinion that these four primitives are the basic interactions ocurring in web applications. Another important novelty within the schema is that interactions which occur within a node of type interactional do not leave the node, but are designed with a sequence of two or more ComponentSteps. At least two ComponentSteps must be present representing the elements before and after the event. In this way we make a distinction between navigation which means that a transition between two nodes takes place and interactions which are modeled within the node. This is important, because the optimization (operating mainly on the navigation) and the one-toone personalization (changing the components within the ComponentSteps) can work separately. The ComponentChoice tag identifies two sets of Components which are interchangeable. In this way it can be used in the design phase by specifying different combinations of Components resulting in the same system functionality. In this publication we will not use the ComponentChoice tag. Important for one-to-one personalization is the distinction between several sub types of type ComponentType which can be instantiated inside a Component tag. Figure 4 lists predefined sub types of type ComponentType. We think that these types represent the most important components being present on interactional and navigational nodes of a web application. Nevertheless, because of the structure of our schema, it is easy to integrate new sub-types of type ComponentType and in this way to extend the functionality. The standalone type InteractioncomponentType exists to represent buttons that start the interaction. This type completes a FormType by adding the interaction component. To be able to show one-to-one personalization we need to show the internal structure of the types FormType and DatavisualizationType because these types handle data acquisition and the access of stored data, respectively. Figure
0-7695-1926-1/03/$17.00 (C) 2003 IEEE
Figure 3. XML schema design for node specification EventType
seq of
Event
Component Step
seq of
0..n
Node pool
seq of
Node
ComponentstructureType Component seq of Choice choice 1..n
2..n
Component Choice_left
seq of
Component
Component Choice_right
seq of
Component
1..n
1..n
Component
choice
1..n
seq of
Structure
ComponentstructureType Component Choice choice
0..n
1..n
Figure 4. Predefined ComponentTypes
5 shows the internal structure of these types. The real interaction components within FormType and InteractioncomponentType and the whole model of form submission are taken from theW3C specification XForms (see [18]) and are integrated within our types. In this way one element Formelement integrates a formcontrol out of the group xforms:formControls and additionally one element named Skillstructure. The type DatavisualizationType can incorporate several elements named Dataelement which in turn consist each of one element named Skillstructure. The element Skillstructure is used to identify which Skills a user or his group have to posses to be able to access the Formelement or Dataelement (see figure 6 for the internal structure of element Skillstructure). The sub-component incorporating a Skillstructure can be accessed by the user if one sub-element of Skillstructure matches with a skill of this user. The element Skillgroup is
seq of
Component Choice_left
seq of
Component
Component Choice_right
seq of
Component
1..n
1..n
Component
Figure 5. Internal structure of FormType and DatavisualizationType
used to model the fact that a specific combination of skills and not only one skill alone is a sufficient condition to be able to access this sub-component. Each Targetskill element refers to a Skill stored in the user profile repository. The additional attributes value and compareop allows one to compare a Skill with a needed Targetskill (compare operators are ’lt’ (), ’gt’ (), ’eq’ () and ’pres’ (which indicates that presence of the Skill is enough).
5. The Graph Based Model In this section we describe the graph based model which can be utilized to specify the relation between distinct parts
0-7695-1926-1/03/$17.00 (C) 2003 IEEE
Figure 6. Internal structure of element Skillstructure
Figure 7. Example of a navigational graph with a process view P11: INTS
P1: NAV
16
15
1 1 : su b
13
5.1 The Navigation Graph Figure 7 presents an example of a navigational graph, showing the basic structure of a web application. Each node represents a page of the web application and the arcs between nodes represent directed navigation possibilities between involved nodes. The bold graph represents a process view, which will be described in more detail in section 5.2. This high-level model represents exclusively the navigational structure of the web application. Furthermore there exists a super-sub node structure (e.g. nodes P7, P8 and P9) where accessed sub nodes replace only a part of the super node, which means that the navigation possibilities of the super node are still present. A practical example of this structure would be the use of a frame embedding several pages on one screen. As in [15] we define: Formally our model represents a labeled graph (over two fixed alphabets and for node and edge labels) which is a tuple , where is a set of nodes, is a set of edges, are the
P6: INTS
14
P10: INT
(or pages) of web applications. In the first subsection the basic model representing a navigational graph is described. Subsequently the structure of process graphs overlaying the navigational graph is addressed. The last subsection shows how the process graph can be optimized by using graph transformations. A more in depth description of the model and the transformation can be found in [15].
9
ub
P9: NAV
1
10: s
12: s ub
P7: NAV
P2: NAV
8 2 3
P3: INT
4
5
P4: INTS
6
7
P5: INTS
P8: INT
source and target functions, and and are the node and the edge labeling functions, respectively. is a set incorporating the first node of the web application, with and . In this publication the node and edge label ing alphabets for our graph model are: and , where · and ½ ¾ . The node labels correspond to the node types described in section 4, whereas the node label represents an interactional node where the insert event and no other events are defined, In the graph model all nodes must have a label. Figure 7 shows the graphical representation of an exemplified graph with , , . Edges are drawn as arrows from source to the target and the label of each node or edge is written after its identity, separated by a colon, e.g., node label of node is and edge label of edge is .
Ë
5.2 The Process Graph The whole graph in Figure 7 represents all navigation possibilities of the web application. In reality, however, groups of users - not to be confused with groups identified in the user profile repository - with identical navigation needs can be identified, because they try to complete specific tasks by using the web application. For each task a process graph representing the navigational structure within the process can be specified. Thus, the modification of the process graph changes already the functionality of the web
0-7695-1926-1/03/$17.00 (C) 2003 IEEE
application for a specific group of users, which can be seen as a means of personalization. Formally the process graph is a subgraph of , written , with , , , , , where the node labels are preserved. represents the node, where the process starts. The bold graph of figure 7 shows one possible process graph S of G, with , , and .
an edge from the adjacent node back to P1 is present, into the super-sub node structure. Figure 9. Graph Production PER1 to PER5 P1: NAV
PER1:
1 2
P1: NAV
PER2:
1 2
3
P2: INT
4
1:sub1
2
P2: INT
P1: NAV 1:sub1
P1: NAV
P3: INT
P3: INT
P1: NAV 1:sub1
2:sub2
P2: INT
P1: NAV 3
2:sub2
P2: INT
P3: INTS
P1: NAV
PER3:
P1: NAV
P3: INT
5.3 Optimization of the Process Graph The optimization of the process graphs representing user groups is based on graph transformations. As in [15] we are using the DPO (double pushout approach) [8] where graph morphism, graph productions, graph grammars, pushout, pushout complements as well as gluing condition are defined.
3
P2: INT
4
1:sub1
P2: INT
P3: INTS
P1: NAV 1:sub1
2:sub2
P2: INT
P3: INT
Figure 8. Process Graph S P8: INTS 10
P7: NAV
P1: NAV
P1: NAV
P1: NAV
11
PER4:
1:sub1
2
P2: INT
3
P3: INTS
1:sub1
P2: INT
P1: NAV 1:sub1
2:sub2
P2: INT
P3: INTS
1 P1: NAV
P1: NAV
9
P6: INTS
2 3
P3: INT
PER5:
P2: NAV
8
4
5
P4: INTS
1:sub1
2
P2: INT
6
3
P3: INF
1:sub1
P2: INT
P1: NAV 1:sub1
P2: INT
2:sub2
P3: INF
7
P5: INTS
Applying these to our example we define a grammar (for web application per sonalization), which is defined as , where is the start graph depicted in Figure 8. Graph corresponds to the process graph presented in figure 7 and described in section 5.2. In the following we describe one optimization possibility to clarify how the corresponding graph transformations (PER1-PER5) work: If a part of a process resembles the node structure shown in figure 9 on the left side, where a subsequent navigation from a node of type navigational (node label NAV) to two nodes of type interactional (node label INT) exists, these nodes in the graph will be transformed into the super-sub node structure where the backward navigation from P2 and P3 to P1 is no longer necessary (see Figure 9: PER1). The productions PER3 to PER5 of figure 9 transform all other nodes adjacent to P1, where
Further optimization possibilities in form of graph productions are described in [15]. Figure 10 shows the result of the optimization of the graph from figure 8. First the production transforms the nodes and , then production transforms the nodes and .
6 Exemplified One-to-One Personalization of a Node As example we take the web application for financial advisors who must maintain and control relevant customer information, in particular insurance contracts, income, marital status, birthday, and so on [16]. To be able to demonstrate one one-to-one personalization we take the user profile depicted in figure 2. The second thing which is necessary is a node (page) of the web application which is used to fill in insurance contracts. This node is of type ’interactional’, scope ’normal’ and has one sub-element Event with type ’insert’. Two ComponentSteps are defined which incorporate four Com-
0-7695-1926-1/03/$17.00 (C) 2003 IEEE
Figure 10. Optimized Graph P8: INTS
11
10
P7: NAV
P1: NAV
be not the case a user would be able to insert data, but would not be allowed to see the previously inserted data.
Figure 12. Exemplified Skillstructure for Component of type FormType
1
9
P6: INTS 2: sub1
P3: INT
8
P2: NAV 3: sub2
P4: INTS
4: sub3
P5: INTS
ponents each. These Components are of type ’InfoType’, ’DatavisualizationType’, ’FormelementType’ and ’InteractioncomponentType’ (see figure 13 which demonstrates a corresponding user interface). The whole structure of the DatavisualizationTypes and FormTypes of this node are illustrated in figure 11 and 12, respectively. The first Dataelement in figure 11 has no Skillstructure, thus, making it accessible to everyone, in contrast to the fifth Dataelement where a user needs a value greater 60 for Skill s2 to retrieve the element.
Figure 11. Exemplified Skillstructure for Component of type DatavisualizationType
Figures 13 and 14 show the content of the page for user u1 and u2. Comparing the two figures one can see the different, personalized content of the same page. For example user u1 (see figure 13) has sufficient skills to access all subcomponents of the node, whereas user u2 (see figure 14) is not allowed to change the content of M/P and the column Rate does not appear at all.
Figure 13. Representation of Componentstep 1 for user u1
InfoType DatavisualizationType
FormelementType
InteractioncomponentType
7. Conclusions and Further Work Normally the Skillstructure of the Formelements (see figure 12) will be more restrictive as the Skillstructure of the corresponding Dataelements (see figure 11). If this would
This paper aims to present an overview of our approach to achieve one-to-one personalization of web applications
0-7695-1926-1/03/$17.00 (C) 2003 IEEE
Figure 14. Representation of Componentstep 1 for user u2
[5]
[6]
[7]
[8]
on the one hand, and on the other hand to provide an optimization of the resulting graph whose pages will be accessed by users during the fulfillment of their tasks. In this way not only personalization issues are addressed, but the structure of the whole web application is improved by restructuring the nodes within process graphs. We show in this paper that the goal to provide one-toone personalization can be achieved by performing a match between information stored in the user profile and in the node description. To reach the second goal graph transformations are utilized resulting in a restructuring of process graphs which in turn leads to an optimization of the web application. Further research will address the identification of further personalization and optimization possibilities. An empirical study is currently done that tries to identify process graphs having a web application with an identified navigation graph. The results of this study will be presented in a follow up paper and will be used for the fine tuning of the proposed graph based model.
[9]
[10]
[11]
[12]
[13]
[14]
References [1] C. Anderson, P. Domingos, and D. Weld. Adaptive Web Navigation for Wireless Devices. In Proc. of IJCAI 2001, pages 879–884, Seattle, Washington, USA, Aug. 2001. [2] C. Anderson, P. Domingos, and D. Weld. Web Site Personalizers for Mobile Devices. In Proc. of IJCAI Workshop on Intelligent Techniques for Web Personalisation 2001, Seattle, Washington, USA, August 2001. [3] E. Bertino, E. Ferrari, and E. Pitoura. An Access Control Mechanism for Large Scale Data Dissemination Systems. In Proc. of RIDE 2001 Workshop, pages 43–50, Heidelberg, Germany, 2001. IEEE Computer Society. [4] M. Cannataro and A. Pugliese. XAHM: an XML-based Adaptive Hypermedia Model and its Implementation. In Proc. of the Third Workshop on Adaptive Hypermedia
[15] [16]
[17]
[18] [19]
(AH3), volume 2266 of Lecture Notes in Computer Science, pages 252–263. Springer, 2002. S. Casteleyn and O. De Troyer. Structuring Web Sites Using Audience Class Hierarchies. In Proc. of DASWIS 2001 workshop, ER 2001 conference, Yokohama, Japan, Nov. 2001. S. Ceri, P. Fraternali, M. Matera, and A. Maurino. Designing multi-role, collaborative Web sites with WebML: a conference management system case study. In Proc. of the First International Workshop on Web-Oriented Software Technology, Valencia, Spain, June 2001. S. Ceri, P. Fraternali, A. Maurino, and S. Paraboschi. Oneto-One Personalization of Data-Intensive Web Sites. In Proc. of WebDB 1999, pages 1–6, Philadelphia, Pennsylvania, USA, June 1999. H. Ehrig, R. Heckel, M. Loewe, A. Corradini, U. Montanari, and F. Rossi. Handbook of Graph Grammars and Computing by Graph Transformation, volume 1: Foundations, editor G. Rozenberg, chapter Algebraic Approaches to Graph Transformation, pages 163–200. World Scientific, 1997. M. Flehming. Data-Driven, XML-Based Web Management in Highly Personalized Environments. In Proc. of Int. Workshop on Information Integration on the Web, Rio de Janeiro, Brazil, April 2001. N. Guell, D. Schwabe, and P. Vilain. Modeling Interactions and Navigation in Web Applications. In Proc. of the ER Workshops 2000, volume 1921 of Lecture Notes in Computer Science, pages 115–127, Salt Lake City, Utah, USA, Oct. 2000. Springer. G. Huck, P. Fankhauser, K. Aberer, and E. Neuhold. Jedi: Extracting and Synthesizing Information from the Web. In Proc. of CoopIS 1998, pages 32–43, New York, USA, August 1998. IEEE Computer Society. G. Kappel, W. Retschitzegger, and W. Schwinger. Modeling Customizable Web Applications - A Requirements’s Perspective. In Proc. of the Kyoto Int. Conf. on Digital Libraries 2000, page 387, Kyoto University, Kyoto, Japan, Nov. 2000. G. Rossi, D. Schwabe, and R. Guimaraes. Designing Personalized Web Applications. In Procs. of the WWW10, pages 275–284, Hong Kong, China, May 2001. ACM. D. Schwabe, G. Rossi, and S. Barbosa. Systematic Hypermedia Application Design with OOHDM. In Proc. of Hypertext 1996, pages 116–128, Washington DC, USA, March 1996. ACM. G. Sonneck and T. Mueck. Optimization of Web Applications by Graph Transformations. submitted for publication. G. Sonneck and T. Mueck. Performance Tuning of an Intranet Application - A Case Study. In Proc. IPDPS 2002 (ICEC Workshop), page 223, Ft. Lauderdale, USA, 2002. IEEE Computer Society. G. Sonneck and T. Mueck. One-to-One Personalization of Web Applications using a Graph Based Model. In Proc. ICEIS 2003, Angers, France, April 2003. ICEIS Press. XForms. XForms 1.0 from the World Wide Web Consortium (W3C). http://www.w3c.org/MarkUp/Forms/, June 2002. XMLSchema. XML Schema 1.0 from the World Wide Web Consortium (W3C). http://www.w3.org/XML/Schema, August 2002.
0-7695-1926-1/03/$17.00 (C) 2003 IEEE
