Applying the Resource Description Framework to Web Engineering Reinhold Klapsing and Gustaf Neumann Information Systems and Software Techniques University of Essen, Universitatsstrae 9, D{45141 Essen, Germany Tel.: +49 (0201) 183 4078, Fax: +49 (0201) 183 4073
fReinhold.Klapsing,
[email protected] http://nestroy.wi-inf.uni-essen.de/
Published in Proc. of the 1st International Conference on Electronic Commerce and Web Technologies: EC-Web 2000, September 2000.
c Springer-Verlag
Abstract. Generally, a multitude of tools is used for the management of
a Web application life cycle. It is highly desirable to provide an exchange format for such tools to enable interoperability. This paper presents an eXtensible Web Modeling Framework (Xwmf), which applies the Resource Description Framework (RDF) to Web engineering to provide an interoperable exchange format. Our proposed framework makes use of one and the same (meta- ) data model to specify the structure and content of a Web application, to make statements about the elements of a Web application, and to reason about the data and metadata. Xwmf is extensible, because schemata de ning additional vocabulary to integrate new design artifacts can be added. The Xwmf tools are able to convert the Web application (metadata) description into the corresponding Web implementation.
1 Introduction Approaches for the structured and formal development of Web applications can be summarized by the term Web engineering (see for example [10,15]). Web engineering should provide artifacts to manage a Web application life cycle. A formal model for de ning a Web application should be expressed in an interoperable format that can be exchanged easily, so that a developer can use the suitable tool for each phase of a Web application life cycle. The exchange of (parts of) a Web application model is also necessary for the distributed development of a Web application. This paper presents such a formal Web application description model called the eXtensible Web Modeling Framework (Xwmf). Xwmf is an application of the Resource Description Framework (RDF) [4,9] or, more precisely, Xwmf consists of an extensible set of RDF schemata and descriptions. RDF [4] is an open standard available from the World Wide Web Consortium (W3C), providing
a model for processing metadata, which is expressed in an interoperable and machine-understandable format, that can be exchanged on the Web. In Xwmf, metadata is used to describe the properties and the relationships of Web resources. The distinction between \data" and \metadata" depends on the application domain. Xwmf applies a (meta-) data model to de ne the Web resources and to make statements about the resources of a Web application. This formal model results in machine-understandable content and metadata descriptions of a Web application. Design concepts and the nal product are described by one and the same graph-based data model. The basic model of Xwmf is extensible, thus a Web developer can introduce new design artifacts corresponding to unforeseen requirements. Xwmf bridges the gap between high-level Web design concepts and the low-level le-based Web implementation model. A Web application is modeled in terms of classes and objects in contrast to les. XWMF supports the separation of layout and content information and the reuse of artifacts. We have developed exemplary tools (the Xwmf tools) which are able to automatically convert a Web application description into the corresponding Web implementation. Additionally, the tools implement a query system that supports querying the Web application metadata but also the data of the application. The remainder of this paper is structured as follows. Section 2 discusses related Web engineering approaches and tools. Section 3 describes the components of Xwmf. Section 4 discusses the Web object composition model of Xwmf. The implementations of the supporting Xwmf tools are presented in Sect. 5. A discussion in Sect. 6 concludes the paper.
2 Related Work Xwmf avoids the constraints of a le-based approach for the modeling of Web
applications. There are several (Web) design approaches that provide more sophisticated abstractions than the le-based Web implementation model. Examples include OOHDM [14] and RMM [8]. These approaches are mainly used for the design phase of the life cycle of a Web application. In contrast to the approaches above Xwmf provides a standardized exchange format for a Web application design as a foundation to support the whole life cycle of a Web application. The Web Object Oriented Model (WOOM) [5] provides a generative model for describing Web applications in terms of objects arranged in a directed acyclic graph (DAG). For each object a transformer method is used to convert the object into its Web implementation. In the Web object composition model of Xwmf, objects are also arranged in a DAG. In contrast to WOOM, Xwmf assigns a property to classes which provides information used to convert objects into its Web implementations, in order to avoid that modeling information is hidden in a transformer method and, thus, not part of the Web application model. Like the objects in WOOM the objects in WebComposition [7] encapsulate the conversion into a Web implementation in a dedicated method. A WebComposition application model is expressed in XML [2] and thus in a standardized
Rescource Description Framework (RDF) RDF Model and Syntax Specification
RDF Schema Specification provides vocabulary for
Web Object Composition Schema
Generic Web Engineering Schemata Extension Schemata Additional Schemata e.g. Content Management Schema e.g Access Control Schema e.g. Navigation Schema
provide vocabulary for
Web Application Description(s)
Web Application Schemata
C1
Instance
Additional Schemata e.g. Content Management Schema e.g Access Control Schema e.g. Navigation Schema
Instance
Web Object Composition Schema
Extension Models
Web Object Composition Schema
Web Object Composition Schema
Instance
Extension Models
provide vocabulary for
C2
S1
Additional Schemata e.g. Content Management Schema e.g Access Control Schema
C3
e.g. Navigation Schema
S3
Extension Models
S2
S4
Additional Schemata e.g. Content Management Schema e.g Access Control Schema e.g. Navigation Schema
provide high-level concepts for
converted to
eXtensible Web Modeling Framework (XWMF) Web application (implementation) This is for example an html, xml, xhmtl file or cgi script code or client side code such like ECMA-Sciript composed out of complexons and simplexons
This is for example an html, xml, xhmtl file or cgi script code or client side code such like ECMA-Sciript composed out of complexons and simplexons This is for example an html, xml, xhmtl file or cgi script code or client side code such like ECMA-Sciript composed out of complexons and simplexons
Web Resources (XML, HTML, Scripts, ...)
Fig. 1. eXtensible Web Modeling Framework programming language independent exchange format. In Xwmf the standardized RDF is applied, thus it is possible to reason about the data and metadata of a Web application, which is not directly supported if XML is used. Many commercial tools do exist for Web authoring, Web development, and Web site management. However, many of these tools are rather self-contained and thus dicult to integrate with other tools in the development process. The following section presents a model applying a standardized exchange format, which can be used to integrate Web engineering tools.
3 eXtensible Web Modeling Framework Xwmf (see Fig. 1) is an extensible set of RDF schemata and RDF descriptions de ning the properties of a Web application. On the top of Fig. 1 RDF is shown. RDF provides the vocabulary necessary to create new RDF schemata and descriptions. The generic Web engineering schemata shown in the middle of Fig. 1 are expressed by using the RDF vocabulary. The generic schemata de ne application independent vocabularies to support Web engineering tasks. The generic Web object composition schema (Wocs) provides the vocabulary
to de ne structure and content of a Web application in terms of objects. The
Wocs vocabulary and the corresponding model are described in Sect. 4. Xwmf
is extensible because additional generic Web engineering schemata can be included. Such extension schemata can provide vocabulary for various application areas such as advanced navigation modeling, access control modeling, or content management. The generic Web engineering schemata and RDF provide the vocabulary used to create Web application schemata. A Web application schema is used to specify high-level application-speci c concepts for the design of a Web application. The vocabulary provided by RDF, the generic Web engineering schemata, and the Web application schemata is used to create Web application descriptions. A Web application description de nes the objects, relationships of the objects, and (extension) properties attached to objects. The Web application descriptions can be automatically converted into the Web application.
4 Web Object Composition Model The Web object composition model (Wocm) is an object-based formal (meta) data model for designing structure and content of a Web application. Wocm gives an abstract view of the Web application not constrained by the le-based Web implementation model. Wocm de nes the constructs Simplexon and Complexon which are arranged in an directed acyclic graph (DAG), with simplexons being the leafs. Complexons are used to de ne the structure of a Web application while simplexons de ne the content and the content representation. Components are special Complexons representing a physical resource of a Web application. Figure 2 shows an example of a DAG. We chose to map the structure of a Web application to a DAG because the content of a Web implementation is represented by units of markup. Markup is arranged as a tree. A DAG is able to express a set of trees in one and the same graph. We discuss the modeling constructs de ned by Wocm in the following subsections in more detail. C1 Component
C2 Component
C3
S1
C4
S5
S2 hasPart Complexon
S3
S4
Fig. 2. DAG of a Component
Simplexon
Fig.3. Complexon (Employee)
4.1 Complexons Complexons are containers for simplexons and complexons. Circular containment is not allowed. Complexons support separation of concerns in the way that they allow to de ne the structure of a Web application independently from the organization of the les of a Web application. The containment relationship is modeled with the property hasPart which is de ned by Wocs. Figure 3 shows the de nition of the complexon class Employee (in abbreviated RDF/XML syntax). The complexon instance i1EmployeeHtml of type Employee has the predicate hasPart referring to a sequence of instances of simplexons. The type concept allows to query the model to show all instances of a certain type (of type Employee for example).
4.2 Simplexons A simplexon class is used to de ne an abstract data type. In addition a simplexon class de nes the Web implementation for objects of that class. Thus the separation of concerns (separate content from its Web implementation) is supported because an object's content can be de ned independently from its Web implementation. A Web application developer de nes which predicates a simplexon should have. Figure 4 shows the de nition of the simplexon class Contact and the property name which is assigned to the simplexon class Contact. A property is de ned independently from a simplexon class and the same property can be assigned to many simplexon classes. This property-centric approach enables multiple use of already de ned properties in di erent contexts. For simplexons,
Fig. 4. Class Contact with an assigned Property subclassing is supported. The subclassing relationship allows the developer to model property inheritance. Figure 5 shows an example where the simplexons HtmlContact and WmlContact inherit the property name. Figure 6 shows the corresponding RDF/XML serialization de ning the subclass relationship of class Contact and HtmlContact by the predicate subClassOf. A simplexon class which should be instantiated must have a predicate implementation. The value of the predicate implementation is used to convert a simplexon into the Web implementation model. The predicate implementation can be respeci ed by a subclass to re ne the Web implementation model in regard of the properties a subclass adds. Wocs de nes any markup or string as a value for the property implementation.
Contact name, ...
HtmlContact
WmlContact
name, ... implementation view
name, ... implementation view
Fig.5. Property Inheritance by means of Subclassing
HTML
]]>
Fig. 6. Simplexon Class HtmlContact
Thus, for example, HTML [13], XML [2], WML [16] are allowed. In addition to model (parts of) Web pages, simplexons can be used to model (parts of) program code for the client side (e.g. ECMAScript [6]) or server side (e.g. XOTcl [12]). Markup or program code at any granularity are allowed as value of the property implementation. Thus ad-hoc design is supported by de ning a whole (parameterized) Web page with a single simplexon. A more sophisticated design is achieved by de ning a simplexon per concept embodied in a Web page and by composing these simplexons by a complexon. The XML element var can be used as a placeholder inside a value of the property implementation. For example name is used as a placeholder for a value of the predicate name of an instance of class HtmlContact. Figure 6 shows an example with several placeholders. De ning a part of a Web Reinhold Klapsing +49 (201) 183 4078 +49 (201) 183 4073
[email protected]
Fig. 7. Simplexon Instance i1Contact
Fig. 8. Web Implementation of i1Contact
resource is done by instantiating a simplexon class. The Web implementation is generated by merging the values of an object via the var-construct with the value of the property implementation de ned by the class an object is related too. Reuse is supported because (many) objects related to a simplexon class are using the same Web implementation (value of the property implementation). Figure 7 shows the object i1Contact which is an instance of the class HtmlContact. Figure 8 shows the Web implementation (in this case HTML) of the object i1Contact, composed of values of the object and the value of the predicate implementation of class HtmlContact (see Fig. 6). Figure 3 shows the usage of
the simplexon instance i1Contact as part of the complexon Employee. An object HtmlContact
WmlContact
name, ... implementation view
name, ... implementation view
instance of
instance of
i1Contact name: Reinhold ... ... : ... ... : ...
Reinhold Klapsing +49 (201) 183 4078 +49 (201) 183 4073
[email protected]
Fig.9. Multiple Types of an Object Fig. 10. Simplexon Instance with Multiple Types may be an instance of more than one simplexon class. This indicates that the object has all the characteristics that are to be expected of an object of each super class. This, in conjunction with the view property, which is de ned in Wocs, allows to de ne di erent views for an object according to the context (see Sect. 4.3) in which an object is used. Additionally, object reuse is supported because only one object has to be de ned for possibly many views. Figure 9 shows the object i1Contact which is an instance of the simplexon classes HtmlContact and WmlContact and Fig. 10 shows the corresponding RDF/XML serialization syntax (note: in contrast to the examples above no abbreviated RDF syntax is used because multiple type predicates are not expressible in abbreviated RDF syntax). The simplexon class HtmlContact de nes, for the predicate view, the value HTML (see Fig. 6), thus the instance i1Contact may be used in an HTML context. In the same way the class WmlContact de nes the view WML thus the instance i1Contact may also be used in a WML context.
4.3 Components
A component is a special complexon representing a physical entity (e.g. a Web page stored in a le) of a Web application. A component is a complexon with an isComponent predicate. A Web application consists of a set of components. For each component the corresponding complexons and simplexons are arranged in a tree, where the complexon which has an assigned isComponent predicate is the root container (see Fig. 2). More precisely, the complexon having an isComponent predicate is a representative for the whole component (tree composed of complexons and simplexons). Wocs de nes an URI as an allowed value of an isComponent predicate which gives a reference to where a component should be stored. Additionally, for a component the value of the (optional) predicate isView de nes in which context the simplexons of a component have to be instantiated. A component must have a predicate isView if it contains simplexons which are instances of more than one class. Figure 11 shows the complexon instance i1EmployeeHtml which is also a component. After the generation process this component will be stored in the le /htdocs/Klapsing.html. The value HTML of the predicate isView de nes the context in which the simplexons of the component have to be interpreted. The
context HTML de nes that the implementation of the simplexon class HtmlContact (and not of the simplexon class WmlContact) has to be used during the generation process.
HTML
Fig.11. Complexon which is also a Component
... Reinhold Klapsing +49 (201) 183 4078 +49 (201) 183 4073
[email protected] 31 Dec 2000
Fig. 12. Integrating Extension Schemata
4.4 Integrating Extension Models Integrating extension models into Xwmf is supported by utilizing XML namespaces [3]. An XML namespace refers to the corresponding RDF schema which de nes the vocabulary used to apply the extension model. To extend Wocm, properties are assigned to complexons, simplexons, and components. Figure 12 shows the RDF/XML serialization syntax of the extension of the simplexon object i1Contact. The predicate expires de nes the expiration date of the information represented by that object. A content management software can query the model by means of the property expires to determine which information became obsolete. The property expires is de ned in the RDF schema http://.../schema/cm.rdf. The content management schema is bound to the XML namespace pre x cm. Note the possibility to store an extension description separated from the Wocm description. Thus, a content management tool only needs to operate on the content management description, possibly stored on a remote system.
5 Implementation We developed a set of tools to create (GraMTor), process (Web application generation tools) and analyze (WebObjectBrowser, RDF-Handle) the RDF description of a Web application. The Web application generation tools are written in the object-oriented scripting language XOTcl [12]. For reading RDF models we developed an RDF parser which uses the TclXML parser [1]. The RDF parser
produces the triples of an RDF model. The RDF-Handle operates on the triples and provides an interface to modify an RDF model and to store the model in triple notation and RDF/XML serialization syntax. Additionally, the RDFHandle provides an interface to query an RDF model. The query interface is used by the WebObjectComposer to analyze the Web application description. The WebObjectComposer generates XOTcl classes and objects representing the simplexons, complexons and components of a Web application and is able to generate the corresponding Web implementation. GraMTor is an RDF editor for the graphical development of RDF models. GraMTor is able to save RDF models in di erent formats including the triple notation and the XML/RDF serialization syntax. The WebObjectBrowser provides a graphical interface which shows the class hierarchy and the objects of a Web application as a graph. A developer can browse the simplexons, complexons, and components to analyze the current state of the classes and objects. The main parts of the GraMTor and the WebObjectBrowser are written in XOTcl. The graphical user interfaces have been developed with the Motif version of Wa fe[11] which provides a Tcl interface for the XToolkit.
6 Conclusion, Future Work and Acknowledgements Web engineering is a complex task that makes it necessary to use a multitude of artifacts for the development of a Web application. In this paper we presented Xwmf which provides a vocabulary de ned by a set of RDF schemata that can be used to describe Web applications. Xwmf enables inter-operation of various Web engineering artifacts by applying a standardized machine-understandable exchange format. Both data and metadata of a Web application are represented in one and the same graph-based model. Machine-supported reasoning about data and metadata is enabled. In order to meet the requirements of additional Web engineering tasks Xwmf can be extended by new generic Web engineering schemata. Xwmf provides concepts of a higher-level for the de nition of a Web application than the le-based Web implementation model by supporting the de nition of concepts in Web application schemata. To support not only ad-hoc development but also more sophisticated designs the grade of granularity of concepts is left to the developer. The content of a Web resource is separated from the presentation layout. For the same content di erent views can be speci ed. Xwmf supports any text-based implementation language, including HTML and XML in its various applications. Adaption of the Web application to new Web implementation technologies is supported as the access to the implementation de nitions in the design model is granted. Reuse is supported as a Web implementation template is shared by (possibly many) objects. This also supports maintenance, as a modi cation of a Web implementation template results in a modi cation of the Web representation of all objects related to the template. Xwmf supports modularity as extension descriptions can be separated from a
Wocm. Distributed development and control of a Web application are supported as extension descriptions can be stored on a remote system. We plan to support more sophisticated navigational user guidance by de ning vocabulary for guided tours. This together with the Xwmf query system will allow such tasks as generating a guided tour of all resources of a certain type. To support a wider range of reuse of concepts and Web implementation templates we plan to develop a repository mechanism and to extend the Xwmf tools accordingly. Future versions of the tools and a longer version of this paper can be obtained from the XWMF home page [17] We thank Wolfram Conen and Eckhart Koppen for many useful discussions regarding Xwmf. Alexander Block developed signi cant parts of the GraMTor and the RDF-Handle as part of his diploma thesis. Fredj Dridi is author of a tool called Inspector. The WebObjectBrowser is a re-adjustment of this tool.
References 1. St. Ball: The "native" TclXML parser. http://www.zveno.com/zm.cgi/in-tclxml/. 2. T. Bray, J. Paoli, C. M. Sperberg-McQueen: Extensible Markup Language (XML) 1.0. W3C, 1998. http://www.w3.org/TR/1998/REC-xml-19980210. 3. T. Bray, D. Hollander, and A. Layman: Namespaces in XML. W3C, 1999. http://www.w3.org/TR/1999/REC-xml-names-19990114/. 4. D. Brickley, R.V. Guha: Resource Description Framework (RDF) Schema Speci cation. W3C, 1999. http://www.w3.org/TR/1999/PR-rdf-schema-19990303. 5. F. Coda, C. Ghezzi, G. Vigna, F. Garzotto: Towards a Software Engineering Approach to Web Site Development. In 9th International Workshop on Software Speci cation and Design (IWSSD). IEEE, 1998. 6. ECMA General Assembly: ECMAScript Language Speci cation. Standard ECMA262, ECMA, 1998. http://www.ecma.ch/stand/ECMA-262.htm. 7. H.-W. Gellersen, R. Wicke, M. Gaedke: WebComposition: an object-oriented support system for the Web Engineering Lifecycle. In 6th International World-Wide Web Conference, volume 29 of Computer Networks and ISDN Systems, pages 1429{ 1437. IW3C2, 1997. 8. T. Isakovitz, E. A. Stohr, P. Balasubramanian: RMM: A Methodology for Structured Hypermedia Design. Communications of the ACM, 38(8):34{44, 1995. 9. O. Lassila, R. R. Swick: Resource Description Framework (RDF) Model and Syntax Speci cation. W3C, 1999. http://www.w3.org/TR/1999/REC-rdf-syntax19990222. 10. S. Murugesan, Y. Deshpande: Web Engineering. In International Conference on Software Engineering (ICSE99), pages 693{694. ACM, 1999. 11. G. Neumann, St. Nusser: Wa fe- An X Toolkit Based Frontend for Application Programs in Various Programming Languages. In USENIX Winter 1993 Technical Conference, 1993. 12. G. Neumann, U. Zdun: XOTcl, an Object-Oriented Scripting Language. In Proceedings of 7th Usenix Tcl/Tk Conference (Tcl2k), 2000. 13. D. Raggett, A. Le Hors, I. Jacobs: HTML 4.01 Speci cation. W3C, 1999. http://www.w3.org/TR/1999/REC-html401-19991224. 14. D. Schwabe, G. Rossi, S. D.J. Barbosa: Systematic Hypermedia Application Design with OOHDM. In Hypertext 1996. ACM, 1996.
15. L. A. Shklar, J. G. Davis, S. Murugesan, C. F. Enguix: International Workshop Web Engineerung '99: Eighth International World Wide Web Conference. http://budhi.uow.edu.au/web-engineering99/web engineering.html, 1999. 16. Wireless Application Protocol Forum: WAP WML - Version 1.2. Approved speci cation, WAP-Forum, 1999. http://www1.wapforum.org/tech/ terms.asp?doc=SPEC-WML-19991104.pdf. 17. XWMF-Home-Page http://nestroy.wi-inf.uni-essen.de/xwmf/.
