=Paper=
{{Paper
|id=Vol-209/paper-4
|storemode=property
|title=Using WEESA to Semantically Annotate Cocoon
|pdfUrl=https://ceur-ws.org/Vol-209/saaw06-full07-reif.pdf
|volume=Vol-209
|dblpUrl=https://dblp.org/rec/conf/semweb/ReifG06
}}
==Using WEESA to Semantically Annotate Cocoon==
<pdf width="1500px">https://ceur-ws.org/Vol-209/saaw06-full07-reif.pdf</pdf>
<pre>
       Using WEESA to Semantically Annotate Cocoon Web
                        Applications

                                                       Gerald Reif, Harald Gall
                                           Department of Informatics, University of Zurich
                                                      Binzmuehlstrasse 14
                                                 CH-8050 Zurich, Schwitzerland
                                                        {reif,gall}@ifi.unizh.ch


ABSTRACT                                                                 not accessible by machines. To enable machines to support
The Semantic Web is based on the idea that Web applica-                  the user in solving information problems, the Semantic Web
tions provide semantically annotated Web pages. This meta-               proposes an extension to the existing Web that makes the
data is typically added in the semantic annotation process               semantics of the Web pages machine-processable [3]. The se-
which is currently not part of the Web engineering process.              mantics of the information of a Web page is formalized using
Web engineering, however, proposes methodologies to de-                  RDF meta-data describing the meaning of the content. The
sign, implement and maintain Web applications but lack                   existence of semantically annotated Web pages is therefore
semantic annotation. In this paper we show how WEESA, a                  crucial in bringing the Semantic Web into existence.
mapping from XML documents to ontologies, can be used in
Apache Cocoon Web applications to semantically annotate                  In [20, 21] we introduced WEESA, a technique to extend
Web pages. We introduce Cocoon transformer components                    existing XML-based Web engineering methodologies to de-
that use the WEESA mapping definition to automatically                   velop semantically annotated Web applications. The nov-
generate RDF meta-data from XML documents. We fur-                       elty of this approach is the definition of a mapping from
ther show how existing Cocoon Web applications can be                    XML elements/attributes to concepts defined in an ontology.
extended to Semantic Web applications and discuss the ex-                This mapping can then be taken to automatically generate
periences gained in an industry case study.                              RDF meta-data from XML content documents. WEESA can
                                                                         therefore be used to extend XML based Web applications to
                                                                         provide RDF meta-data in addition to HTML Web pages.
Categories and Subject Descriptors
H.3.5 [Information Systems]: Information Storage and
                                                                         The contribution of this paper is the integration of the WEESA
Retrieval; D.2 [Software]: Software Engineering
                                                                         meta-data generation into the Apache Cocoon Web develop-
                                                                         ment framework. For this purpose we developed two WEESA
General Terms                                                            enabled transformer components. We show how these trans-
Design                                                                   formers can be used to develop semantically annotated Web
                                                                         applications and discuss the experiences gained while imple-
Keywords                                                                 menting an industry case study.
Web Engineering, Semantic Web, Semantic Annotation, On-
                                                                         The remainder of the paper is structured as follows. Section
tology
                                                                         2 introduces WEESA. Section 3 presents the Apache Co-
                                                                         coon pipeline model. Section 4 discusses the association of
1.    INTRODUCTION                                                       HTML Web pages and RDF meta-data and Section 5 and 6
The increasing popularity of the WWW has lead to an expo-                shows the integration of WEESA into Cocoon transformers
nential growth in the number of Web pages available, which               and how this transformer can be used in XML based Web
makes it increasingly difficult for users to find required infor-        applications. Section 7 presents the case study, 8 discusses
mation. In searching the Web for information, one gets lost              the related work, and Section 9 concludes the paper.
in the vast number of irrelevant search results and may miss
relevant material. Current Web applications provide Web
pages in HTML format representing the content in natural                 2.   WEESA META-DATA GENERATION
language only and the semantics of the content is therefore              In this section we briefly introduce Web engineering and
                                                                         show how WEESA [21] can be used to engineer Semantic
                                                                         Web applications, that provide HTML content and machine-
                                                                         processable RDF meta-data.

                                                                         Web Engineering focuses on the systematic design, devel-
                                                                         opment, and maintenance of Web applications [6]. Most
                                                                         Web engineering methodologies are based on separation-of-
SAAW2006 1st Semantic Authoring and Annotation Workshop 2006 at the      concerns to define strict roles in the development process
5th International Semantic Web Conference, November 5-9, 2006, Athens,
Geogria, USA                                                             and to enable parallel development. A popular way to sepa-
                                                                         rate the content from the graphical design is the use of XML
and XSLT, where XML focuses on the content of the Web                       from the XML Schema to define the mapping to the ontolo-
page and XSLT defines the design.                                           gies. In this way, the same XML document that follows the
                                                                            XML Schema is used for the XSLT transformation to gen-
In order to develop Semantic Web applications, the tradi-                   erate HTML and for WEESA to generate RDF meta-data.
tional Web engineering techniques have to be extended by                    Therefore, the XML Schema can be seen as the contract the
the semantic annotation process. In this process, the Web                   content editor, responsible for writing the XML documents,
pages have to be semantically annotated with RDF meta-                      the layout designer, responsible for the graphical appear-
data. This enables machines to have access to the content                   ance, and the engineer defining the WEESA mapping have to
of the pages. Several tools such as the SHOE Knowledge                      agree on. Figure 1 shows the definition of the WEESA map-
Annotator [9], the CREAM OntoMat [7], and SMORE [12]                        ping at the design level of the Web application and how this
have been proposed to support the user when annotating                      mapping is used at instance level to automatically generate
existing Web pages. However, to manually annotate Web                       RDF meta-data and the HTML page from XML documents.
pages is only feasible if the number of Web pages is small
and the content does not change frequently.
                                                                            3.     COCOON PIPELINE CONCEPT
                                                                            In this section we introduce the concept of Apache Cocoon
To annotate dynamic Web pages, that obtain their content
                                                                            Web applications. Apache Cocoon [4] is a Web develop-
from a background logic such as a database, the annota-
                                                                            ment framework built around the concepts of separation-of-
tion process should be integrated in the engineering process
                                                                            concerns and component-based Web development. Cocoon
of the Web application. During the engineering of a Web
                                                                            uses component pipelines to build Web applications where
application, information items can be identified more easily
                                                                            each component on the pipeline is specialized on a particular
than in the generated HTML Web pages. Once the infor-
                                                                            operation.
mation item is identified, it is mapped to a concept defined
in the ontology. For example, the result of a database query
                                                                                                       Cocoon Pipeline
is mapped to a property in the ontology, to indicate that
a new RDF statement has to be generated with the query                                                         Generator                             XML Source

result as value for the property.                                                                      SAX Events


The aim of WEESA (WEb Engineering for Semantic web                                 Busines Logic:
                                                                                   XSP, JSP, Filter,          Transformer
Applications) is on the one hand, to integrate the annotation                      SQL, etc.
                                                                                                       SAX Events
process into the engineering process of the Web application.
On the other hand, to reuse the existing design artifacts of
                                                                                                              Transformer
XML based Web applications to develop Web applications
that provide semantic meta-data in addition.                                                           SAX Events        Schema valid XML document



In WEESA the structure of the XML document is used to                                                       XSLT Transformer                  XSL Stylesheet

identify XML elements/attributes which are mapped to con-                                              SAX Events            HTML
cepts in an ontology. This mapping definition can then
be taken to automatically generate RDF meta-data from                                                           Serializer                           HTML page
XML content documents. WEESA not only allows one-to-
one mappings but uses a more flexible approach to overcome
the gap between the information available in the XML doc-
ument and the information needed by the ontology. The                       Figure 2: Pipeline of a typical Cocoon Web applica-
content of several XML elements/attributes can be selected                  tion.
and further processed in Java methods to meet the seman-
tics of the concept in the ontology.
                                                                            Figure 2 shows the pipeline of a typical Cocoon Web appli-
                                                                            cation. A Cocoon pipeline consists of a generator, an arbi-
                      WEESA                                 Design Level    trary number of transformer, and a serializer. An HTTP
        XML Schema    mapping
                                      Ontology
                      definition
                                                                            request triggers the pipeline and causes the generator to
                                           uses concepts
              valid                                                         read XML from a data source and produces a stream of
                      generate                             Instance Level
                        via
                                   RDF description                          SAX1 events as output representing the XML document.
                      WEESA
                                                                            This output is the input of a transformer or a serializer. A
       XML document                         associate
                                                                            transformer takes the SAX events, does some transformation
                      generate
                      via XSLT     HTML Web page                            (e.g. XSLT transformation), and the results are again SAX
                                       Semantic Web page
                                                                            events. These events can then be taken by another trans-
                                                                            former or a serializer. In a typical Cocoon Web application,
                                                                            the business logic (e.g. SQL queries, Java code) is processed
                                                                            by the transformers at the beginning of the pipeline. The
     Figure 1: WEESA design and instance level.
                                                                            output of the business logic is a schema valid XML docu-
                                                                            ment that fulfills the Web engineering contract and has the
                                                                            structure the XSLT stylesheet was designed for. This doc-
At the design level of the Web application only the struc-                  ument is then taken by the XSLT transformer which uses
ture of the XML document is known and no XML instances
                                                                            1
are available. Therefore we use the structure information                       SAX: Simple API for XML
the XSLT stylesheet to produce the HTML page. The seri-         One of the strength of Cocoon is, that every component
alizer finally takes the SAX events and processes them into     is specialized on a specific task. This gives the developer
a character stream for client consumption.                      the flexibility to configure the components in the pipeline
                                                                according to his requirements. Therefore we decided, to split
4.   ASSOCIATING HTML AND RDF                                   up the pipeline to generate HTML pages with embedded
As shown in Figure 1, we have to perform two steps on the       RDF/XML.
schema valid XML document to generate the semantically
                                                                                                     Cocoon Pipeline
annotated Web pages: (1) The XSLT transformation has to
be performed to generate the HTML page. (2) The WEESA                                                        Generator                             XML Source

mapping has to be processed to generate the RDF meta-data                                            SAX Events

description of the Web page.                                                     Busines Logic:
                                                                                 XSP, JSP, Filter,          Transformer
                                                                                 SQL, etc.
Once we have generated the HTML page and its RDF meta-                                               SAX Events

data description we have to put them into relation. Unfortu-
                                                                                                            Transformer
nately, no standardized approach exists for associating RDF
descriptions with HTML. In [17] Palmer discusses several               Session
                                                                                                     SAX Events        Schema valid XML document

possible approaches. These techniques can be classified in                                                WriteDOMSession
                                                                                 DOM
the following categories:                                                                                    Transformer

                                                                                                     SAX Events        Schema valid XML document



Embedding RDF in HTML: With this association style                                                        XSLT Transformer                  XSL Stylesheet

   the RDF description is directly embedded in the HTML                                              SAX Events        HTML

   page. Several ways have been proposed such as adding
                                                                                                          WEESAReadDOM                     WEESA Mapping
   RDF/XML in the <script> element, using XML no-                                                        SessionTransformer                  Definition
   tations and CDATA sections, or adding RDF base64 en-                                              SAX Events        HTML + RDF

   coded in the <object> element. A detailed discussion
   of these methods can be found in [17].                                                                     Serializer                           HTML + RDF


     A recently proposed technique to embed RDF into
     HTML is RDFa [1]. RDFa is the current W3C work-
     ing draft for integrating RDF data into XHMTL doc-         Figure 3: Cocoon pipeline                                               for        the          WEESA
     uments and is not yet supported with the approach          HTML+RDF generation.
     presented in this paper.
Linking to an external RDF description: The RDF                 To split up the pipeline we use the WriteDOMSession trans-
     meta-data description is stored in an external doc-        former. This transformer takes the input document and
     ument and the HTML page references to its meta-            writes it first as DOM2 into the servlet session, and sec-
     data description. This reference can be done using         ond as SAX events to its output. This is how the pipeline
     the HTML <link> element [17] or using an common            is split up and the XML document can be reused later in
     HTML <a href=""> link [8].                                 the pipeline. After the HTML page is generated by the
                                                                XSLT transformer the WEESAReadDOMSession transformer
                                                                takes the DOM-XML from the session and uses the WEESA
In the following two sections we introduce a WEESA enabled      mapping definition to generate the RDF meta-data repre-
Cocoon transformer for both categories of association styles.   sentation in RDF/XML format. The WEESAReadDOMSession
                                                                transformer further embeds the generated RDF/XML in
5.   WEESA COCOON TRANSFORMER TO                                the <script> element which is then added in a user de-
                                                                fined element of the HTML page. This element is typi-
     GENERATE HTML+RDF                                          cally the <head> element. The serializer finally delivers the
One way to associate HTML and RDF is to embed the
                                                                HTML+RDF page to the client. The additional steps are
RDF/XML description in the <script> element within the
                                                                shown in Figure 3 as light gray pipeline components. The
HTML <head>. The HTML <script> element can be used
                                                                problems that comes with embedding the RDF meta-data
to include non-HTML media in HTML Web pages [10]. This
                                                                in the <head> element are discussed at the end of the this
section introduces the WEESAReadDOMSession transformer
                                                                section.
that can be used to realize this kind of RDF – HTML asso-
ciation.
                                                                The Cocoon framework uses the sitemap.xmap configura-
                                                                tion file to define the pipelines. Figure 4 shows a frag-
When developing Semantic Web applications that add the
                                                                ment of the sitemap file for the pipeline from Figure 3.
RDF meta-data to the HTML page we have to introduce
                                                                Lines 3-6 instruct Cocoon to start a servlet session. In
new steps to the pipeline discussed in Section 3. Since
                                                                line 9 the generator is instructed to read the XML docu-
we need the schema valid XML document for the XSLT
                                                                ment AlanisMorissetteUnplugged.xml from the content/
transformation and for the WEESA meta-data generation,
                                                                directory. In lines 14-17 the WriteDOMSession transformer
we have two options. We can either integrate WEESA in a
                                                                is defined to write the XML document to the session. The
modified XSLT transformer that generates RDF and HTML
                                                                dom-name parameter gives the DOM-object the name rdf in
or we can split up the pipeline and use a specialized trans-
                                                                2
former for the RDF meta-data generation.                            DOM: Document Object Model
                                                                                                                                                                       
1    < map:match pattern = " A l a n i s M o r i s s e t t e U n p l u g g e d . html " >                < page >
2       <! -- create the session -- >                                                                       < header >
3       < map:act type = " session " >                                                                         <! -- here goes the XML for the header -- >
4          < map:parameter name = " action " value = " create " / >                                         </ header >
5          < map:parameter name = " mode " value = " immediately " / >                                      < navigation >
6       </ map:act >                                                                                           <! -- here goes the XML for the n a v i g a t i o n -- >
7                                                                                                           </ navigation >
8        <! -- read the XML file -- >                                                                       < content >
9        < map:generate type = " file "                                                                        <! -- here goes the XML for the content -- >
10           src = " content / A l a n i s M o r i s s e t t e U n p l u g g e d . xml " / >                </ content >
11                                                                                                       </ page >
12       <! -- here comes the business logic ( if needed ) -- >                                                                                                          
13
14       <! -- write the XML document to the session -- >
15       < map:transform type = " writeDOMsession " >                                                    Figure 5: Sample XML document aggregated from
16          < map:parameter name = " dom - name " value = " rdf " / >                                    several parts.
17          < map:parameter name = " dom - root - element "
18                          value = " content " / >
19       </ map:transform >                                                                              that the business logic, typically processed at the beginning
20
21       <! -- do the XSLT t r a n s f o r m a t i o n -- >                                              of the pipeline, has to be computed once only for both the
22       < map:transform type = " xslt "                                                                 HTML and RDF generation. Embedding the RDF/XML
23                       src = " style / albumInfo . xslt " / >                                          meta-data in the <head> tag of a HTML document, how-
24
25       <! -- c o n f i g u r e W E E S A R e a d D O M S e s s i o n t r a n s f o r m e r -- >        ever, breaks HTML 4.01 and XHTML validity [19].
26       < map:transform type = " W E E S A R e a d D O M S e s s i o n " >
27
28
            < map:parameter name = " dom - name " value = " rdf " / >
            < map:parameter name = " trigger - element "
                                                                                                         6.     WEESA COCOON TRANSFORMER TO
29                                   value = " head " / >                                                       GENERATE RDF/XML
30          < map:parameter name = " position " value = " in " / >
31          < map:parameter name = " weesa - mapping - definition "                                      Another way of associating RDF and HTML to one another
32                                   value = " mapping / albumMapping . xml " / >                        is to use the <link> element in the <head> of the HTML page
33       </ map:transform >                                                                              to reference the corresponding external RDF/XML meta-
34
35         <! -- s e r i a l i z e the output -- >
                                                                                                         data description [17]. To generate this stand-alone RDF/
36      < map:serialize type = " html " / >                                                              XML description within Cocoon Web applications we devel-
37   </ map:match >                                                                                      oped the WEESA transformer.
                                                                                                    
                                                                                                         Cocoon Web applications that use the <link> element to
     Figure   4:     Pipeline    definition                                   using            the       associate RDF and HTML need two pipelines: one for the
     WEESAReadDOMSession transformer.                                                                    generation of the HTML page, and another for the WEESA
                                                                                                         meta-data generation. The pipeline for the HTML gener-
                                                                                                         ation is similar to the one introduced in Section 3. Only
     the servlet session. The use of the dom-root-element pa-                                            the reference to the RDF description has to be added in the
     rameter is explained below. Line 20 configures the XSLT                                             <head> of the HTML page. The reference looks as follows:
     transformer to use the XSLT stylesheet albumInfo.xslt.
     In lines 23-29 the WEESAReadDOMSession transformer is con-
     figured. The dom-name parameter tells which DOM-object                                                    <link rel="meta" type="application/rdf+xml"
                                                                                                                                href="AlanisMorissetteUnplugged.rdf"/>
     should be taken from the session, the weesa-mapping-def-
     inition parameter names the mapping file, and the trigger-
     element and position parameters tell that the generated                                             There are basically two ways of adding the <link> element
     RDF/XML should be placed in the HTML <head> element.                                                to the HTML page. One is to modify the Web application
     Finally, in line 32 the serializer is instructed to write the                                       to add the element in the business logic or in the XSLT
     XML stream as HTML to the consumer.                                                                 stylesheet. The other possibility is to use the AddRDFLink
                                                                                                         transformer we developed. This transformer is added to
     In praxis, most Web pages consist of several parts, for ex-                                         the pipeline for the HTML page generation between the
     ample a header, the navigation part, and a part with the                                            XSLT transformer and the serializer. The AddRDFLink trans-
     actual page content. A sample XML document following                                                former extracts the URL of the incoming request, replaces
     this structure is shown in Figure 5. Depending on the struc-                                        the ".html" suffix of the path with ".rdf", and adds the
     ture of the Web page, not all parts of the XML document                                             <link> with the ".rdf" URL in the <head> of the HTML
     have to be looked at when generating the RDF meta-data.                                             page.
     For example, only the <content> part contains information
     that is needed for the meta-data generation. In this case,                                          Since the AddRDFLink transformer searches for a ".html"
     we have to define the WEESA mapping only for the sub-                                               suffix in the URL and replaces it with ".rdf" it can only
     tree starting with the <content> element and we have to                                             be used in Web applications that obey the following naming
     inform the WriteDOMSession transformer only to write the                                            convention. The path in URLs that trigger the pipeline for
     subtree following the <content> element as DOM to the ses-                                          the HTML pages have the suffix ".html" such as:
     sion. This is done with the dom-root-element parameter in
     line 16 from Figure 4.                                                                                   http://www.mytunes.com/album.html?id=1234

     Including RDF/XML meta-data in the HTML page using                                                  The path in URLs that trigger the pipeline for the RDF
     the WEESAReadDOMSession transformer has the advantage                                               meta-data generation have the suffix ".rdf" such as:
     http://www.mytunes.com/album.rdf?id=1234                                             we use the event descriptions and the ticket shop and seman-
                                                                                          tically annotate the corresponding Web pages. Below we list
                           Cocoon Pipeline                                                the Web pages that make up the case study and discuss the
                                   Generator                             XML Source
                                                                                          meta-data the pages provide:

                           SAX Events

                                                                                          VIF Homepage: Entry point to the VIF Web application.
       Busines Logic:
       XSP, JSP, Filter,          Transformer                                                 It provides general information about the festival and a
       SQL, etc.
                                                                                              navigation bar to the features of the Web application.
                           SAX Events
                                                                                              The meta-data consists of the contact information of
                                  Transformer
                                                                                              the festival.

                           SAX Events        Schema valid XML document                    Program overview pages: List of events of the festival.
                                                                                              There is one list of all events and several lists for the
                                    WEESA                        WEESA Mapping
                                  Transformer                      Definition
                                                                                              events of a specific event category (such as concert,
                           SAX Events         RDF/XML
                                                                                              performing arts, etc.) The meta-data consists of the
                                                                                              events, location, and the category of the event.
                                    Serializer                            RDF/XML
                                                                                          Event description: Detailed information about the event.
                                                                                              It contains information such as the title, description,
                                                                                              location, date, etc. of the event. The meta-data re-
Figure 6: Cocoon pipeline for the WEESA RD-                                                   flects the event details provided by the Web page.
F/XML generation.
                                                                                          Ticket shop receipt: Receipt of the bought ticket. It is
                                                                                              the final acknowledgement of the shopping process in
                                                                                              the online shop containing all the details of the spe-
In the pipeline for the WEESA meta-data generation that
                                                                                              cific event. The meta-data reflects event details of the
uses the WEESA transformer the business logic is also pro-
                                                                                              bought ticket.
cessed at the beginning of the pipeline. The schema valid
XML document is sent to the WEESA transformer that takes
the mapping definition and processes the WEESA mapping.                                   When we chose the case study application we decided not to
The RDF/XML output of the transformer is then taken by                                    design a new Web application from scratch but to adopt an
a serializer and sent to the client. The pipeline is shown in                             existing one. This decision has the advantage that we are
Figure 6 and Figure 7 shows a snipped from sitemap.xmap                                   able to work out the differences between the design of tra-
that is used to configure the WEESA transformer. Again, the                               ditional Web applications and Semantic Web applications.
dom-root-element parameter defines the start element of
the XML subtree that should be considered for the WEESA                                   The VIF Web application was originally implemented using
transformation as described in the section above, and the                                 MyXML [13]. MyXML is a Web application framework that
weesa-mapping-definition parameter defines the mapping                                    is based on separation-of-concerns. For our case study we
definition to be used.                                                                    took the existing database and reimplemented the Web ap-
                                                                                        plication based on the Cocoon Web application framework.
< map:transform type = " WEESA " >                                                        To do so, we followed the steps introduced in Section 3.
   < map:parameter name = " dom - root - element "                                        We first defined the XML Schema as contract of the Web
                                            value = " content " / >
   < map:parameter name = " weesa - mapping - definition "
                                                                                          application. In the following steps we implemented the busi-
                   value = " mapping / artistMapping . xml " / >                          ness logic, designed the XSLT stylesheets, and defined the
</ map:transform >                                                                        Cocoon pipelines, as we would do for a traditional Web ap-
                                                                                        plication. To semantically annotate the Web application we
                                                                                          defined the WEESA mapping for each kind of Web page and
Figure 7: Configuration of the WEESA transformer.                                         added the WEESA enabled transformer into the pipeline, as
                                                                                          introduced in Section 5 and 6. Since WEESA follows the
Using the <link> element to associate RDF and HTML has                                    concept of separation-of-concerns all these steps could be
the advantage that the RDF description has to be generated                                performed in parallel.
on request only. This, however, has the drawback that the
schema valid XML document has to be generated a second                                    During the life cycle of a Web application a new version
time. Fortunately this does not have to be a big disadvan-                                of the used ontology may be issued or a new ontology be-
tage if the Cocoon caching mechanism can be used.                                         come the standard ontology to describe information in the
                                                                                          domain of the Web application. Therefore, WEESA was de-
7.     CASE STUDY                                                                         signed to enable the change of the used ontology without
We have evaluated the WEESA transformers in the annual                                    reimplementing the whole Web application. To demonstrate
Vienna International Festival3 (VIF) industry case study.                                 this flexibility we implemented the case study first with a
VIF is a database supported Web application that comprises                                self-defined VIF ontology and changed later to the iCalen-
a ticket shop, over 60 event descriptions, reviews, and an                                dar [11] ontology. We further did the implementation for
archive over the last 52 years. For the WEESA case study                                  both HTML – RDF association styles introduced in Sec-
                                                                                          tion 4. Figure 8 shows a snipped from the generated RDF
3
    http://www.festwochen.at                                                              graph that is based on the self-defined VIF event ontology.
                                                               Database Keys for RDF Resource Identifier: The
                                                               VIF case study further showed that database keys should
                                                               be accessible in the XML documents to be able to generate
                                                               unique resource identifiers for the RDF representation. The
                                                               database keys help to ensure that the same identifier is used
                                                               for the same resource throughout the whole Web application.

                                                               Well Formatted data in the XML document: Since
                                                               the RDF meta-data description of the Web pages is intended
                                                               to be machine-processable the literals used should store in-
                                                               formation in a well defined format. For example to repre-
                                                               sent time and date information the XML Schema xsi:time
                                                               respectively, xsi:date format should be used. This require-
                                                               ment should also be kept in mind when defining the XML
                                                               Schema as contract for a Web page. The schema should
                                                               force content editors to provide information split up into
  Figure 8: Snipped of the generated RDF graph.                logical units that are stored in a well defined format. For
                                                               example, to specify the begin and end time of an event, it is
                                                               better to have a specific XML element for the begin and end
                                                               time instead of an arbitrary string such as "from 11:00 to
                                                               12:00". Using arbitrary strings results in pattern matching,
In the following we list experiences gained while developing
                                                               when defining the WEESA mapping.
the case study:

Annotation by configuration: The change from a tra-            8.   RELATED WORK
ditional Web application to a WEESA Semantic Web appli-        To our knowledge not much work has been done to integrate
cation requires basically two steps: the WEESA mappings        the Semantic annotation process into Web engineering. In
have to be defined and the Cocoon pipelines have to be mod-    [18], the authors suggest an extension of the Web Site De-
ified. Both of these steps can be done by either writing new   sign Model (WSDM). In this approach object chunk entities
XML files (mapping definition) or modifying existing ones      which are artifacts in the Web application design process
(pipeline configuration). No Java programming is involved      are mapped to concepts in the ontology.
in these steps.
                                                               Many Web engineering methodologies have been proposed
In addition, the change between the two association styles     that use Semantic Web technologies such as ontologies and
of HTML and RDF, also could be done by only modifying          RDF to formalize engineering artifacts. The Extensible Web
the pipeline configuration. The WEESA mapping definitions      Modeling Framework (XWMF) [14] aims to use a machine-
remains the same.                                              processable format for the Web engineering artifacts to make
                                                               them exchangeable between the multitude of tools that are
Change of ontologies: We implemented the VIF case              involved in the Web application life cycle. The Semantic
study Semantic Web application for different ontologies. For   Hypermedia Design Method (SHDM) [16] heavily uses OWL
the change from one ontology to the other, only the WEESA      ontologies for domain and methodology specific issues. On-
mapping definition used had to be changed. The rest of         tologies are used for the conceptual model and the naviga-
the implementation remained untouched and no additional        tional model of the application domain. The SHDM further
programming effort was needed.                                 defines method specific ontologies for the abstract and con-
                                                               crete widget interface to model the user interface of the Web
Java Mapping Library: In the two paragraphs above              application. Despite these methodologies use engineering ar-
we argued, that no Java programming is involved to seman-      tifacts that rely on Semantic Web technologies, the actual
tically annotate a Cocoon Web application using WEESA.         Web application does not contain any semantic annotations.
This is true regarding the Web application. To not only
support one-to-one mappings from XML to the ontology           There is further related work in the area of Semantic annota-
Java methods are used in the WEESA mapping definition.         tion. CREAM/OntoMat [7] is a Semantic annotation frame-
WEESA provides a library of Java methods for common            work that offers several annotation methods such as man-
tasks. In some cases, however, the developer has to im-        ual annotation, authoring of annotated documents, semiau-
plement a Java method for a user-specific task. This user      tomatic annotation, and the annotation of dynamic pages.
specific method can be added to the library for later reuse.   This flexible approach is, however, not integrated in the Web
                                                               engineering process.
Free-Text and Mixed Content:             Since WEESA uses
the structure of the XML document to identify the concepts     In the area of interpreting XML as RDF data several ap-
that are mapped to the ontologies, free-text and mixed con-    proaches exist. In [15], XML documents are interpreted as
tent can not be annotated. Natural language understanding      RDF data via a RDF Schema to enable machines to in-
would be needed to do so. However, in our experience this is   terpret XML unambiguously as a set of statements in the
not a problematic limitation since the concepts that can be    RDF data model. The round-tripping tool between XML
found in many ontologies available today can also be found     and RDF [2] allows to directly interpret XML documents
in the structure of an XML document.                           with a RDF model using the XML schema as basis for de-
scribing how XML is mapped into RDF and back. In [5] the          [8] J. Hartmann and Y. Sure. An infrastructure for
idea is that every element/attribute name maps to a RDF               scalable, reliable semantic portals. IEEE Intelligent
property, viewing the structure of the XML document as re-            Systems, 19(3):58–65, May 2004.
lational model between parent nodes and their children. All
these approaches rely on the equality of the XML elemen-          [9] J. Heflin, J. Hendler, and S. Luke. Shoe: A blueprint
t/attribute names and those of the class/property names in            for the semantic web. In D. Fensel, J. Hendler,
the ontology. This, however, cannot be guaranteed, since              H. Liebermann, and W. Wahlster, editors, Spinning
ontologies are typically defined by third parties.                    the Semantic Web, pages 29–63. The MIT Press, 2003.
                                                                 [10] HTML 4.01: Definition of the script element, Last
9.    CONCLUSIONS                                                     visited March 2005. http://www.w3.org/TR/html401/
The success of the Semantic Web crucially depends on the              interact/scripts#edef-SCRIPT.
existence of semantically annotated Web pages. Current
                                                                 [11] iCalendar OWL ontology definition, April 7 2004.
Web engineering methodologies and frameworks, however,
                                                                      http://www.w3.org/2002/12/cal/ical.
lack techniques to provide semantic meta-data. To anno-
tate Web pages, information items have to be identified and      [12] A. Kalyanpur, J. Hendler, B. Parsia, and J. Golbeck.
mapped to the concepts that are defined in ontologies. Since          SMORE - semantic markup, ontology, and RDF
it is easier to identify these information items in structured        editor. Technical report, University of Maryland, 2003.
data-sources (e.g., databases, XML), which are available              http://www.mindswap.org/papers/SMORE.pdf.
while engineering the Web application, than in the gener-
ated HTML pages, we argue that the semantic annotation           [13] C. Kerer and E. Kirda. Web engineering, software
process should be integrated into the engineering process of          engineering and web application development. In 3rd
the Web application.                                                  Workshop on Web Engineering at the 9th World Wide
                                                                      Web Conference, pages 135 – 147, Amsterdam, the
In this paper we introduced Apache Cocoon transformer                 Netherlands, May 2000. Springer-Verlag.
components that can be used to generate semantic meta-
                                                                 [14] R. Klapsing and G. Neumann. Applying the resource
data out of existing Web engineering artifacts. These trans-
                                                                      description framework to web engineering. In
former use WEESA, a mapping from XML elements/attribu-
                                                                      Proceeding of the 1st International Conference on
tes to concepts in ontologies, to automatically generate RDF
                                                                      Electronic Commerce and Web Technologies: EC-Web
from XML documents and can therefore be used to develop
                                                                      2000, Lecture Notes in Computer Science.
Semantic Web applications. In this paper we further pre-
                                                                      Springer-Verlag, 2000.
sented the experiences gained while using WEESA for devel-
oping a Semantic Web application.                                [15] M. Klein. Using RDF Schema to interpret XML
                                                                      documents meaningfully. In S. Handschuh and
10.   REFERENCES                                                      S. Staab, editors, Annotation for the Semantic Web,
 [1] B. Adida and M. B. eds. RDFa Primer 1.0 -                        volume 96 of Frontiers in AI and Applications, pages
     Embedding RDF in XHTML, 16 May 2006.                             79–89. IOS Press, Amsterdam, 2003.
     http://www.w3.org/TR/xhtml-rdfa-primer/.
                                                                 [16] F. Lima and D. Schwabe. Application modelling for
                                                                      the semantic web. In Proceedings of the 3th
 [2] S. Battle. Poster: Round-tripping between XML and
                                                                      International Conference on Web Engineering (ICWE
     RDF. In International Semantic Web Conference
                                                                      2003), pages 417–426, Oviedo, Sapin, July 2003.
     (ISWC), Hiroshima, Japan, November 2004.
                                                                      Springer-Verlag.
 [3] T. Berners-Lee, J. Hendler, and O. Lassila. The             [17] S. B. Palmer. RDF in HTML: Approaches, June 2002.
     Semantic Web. Scientific America, 284(5):34–43, 2001.            http://infomesh.net/2002/rdfinhtml/index.html.
 [4] The Apache Cocoon project homepage, Last visited            [18] P. Plessers and O. D. Troyer. Annotation for the
     February 2005. http://cocoon.apache.org/.                        semantic web during website development. In 4th
                                                                      International Conference on Web Engineering, pages
 [5] M. Ferdiand, C. Zirpins, and D. Trastour. Lifting xml            349–353, Munich, Germany, July 2004.
     schema to owl. In 4th International Conference on
     Web Engineering, pages 354–358, Munich, Germany,            [19] W3C: Frequently Asked Questions about RDF: How
     July 2004.                                                       do I put some RDF into my HTML pages?, September
                                                                      2004. http://www.w3.org/RDF/FAQ#How.
 [6] M. Gaedke and G. Graef. Development and evolution
     of web-applications using the webcomposition process        [20] G. Reif. WEESA - Web Engineering for Semantic Web
     model. In Int. WS on Web Eng. at the 9th Int. WWW                Applications. PhD thesis, TU Vienna, 2005. http:
     Conf., Amsterdam, the Netherlands, May 2000.                     //seal.ifi.unizh.ch/fileadmin/User Filemount/
                                                                      Publications/reif-phdthesis05.pdf.
 [7] S. Handschuh and S. Staab. Annotation of the shallow
                                                                 [21] G. Reif, H. Gall, and M. Jazayeri. WEESA - Web
     and the deep web. In S. Handschuh and S. Staab,
                                                                      Engineering for Semanitc Web Applications. In
     editors, Annotation for the Semantic Web, volume 96
                                                                      Proceedings of the 14th International World Wide Web
     of Frontiers in Artificial Intelligence and Applications,
                                                                      Conference, pages 722–729, Chiba, Japan, May 2005.
     pages 25–45. IOS Press, Amsterdam, 2003.

</pre>