Simple Worldwide Aggregation Using XSLT

Abstract

Since XSLT 1.0 was released in 1999 it has been possible to easily aggregate and syndicate information over the web using XML. This is a case study of how our web site uses standard Extensible Stylesheet Language Transformations (XSLT) to make information available to others and to pull information from around the world into our web pages in an unattended fashion.

This presentation describes the XML principles involved and the XSLT facilities used and presents in detail a freely-available generic example aggregation stylesheet that anyone can download and modify for their own use on their own web sites.

The presentation is a mini tutorial/workshop for people to see code and ask questions about how to get XML and XSLT working to implement aggregation in their environments.

Two opportunities for information aggregation and publishing

Crane Softwrights Ltd. writes and delivers training materials and licenses these materials to companies and training organizations around world. The course schedule page is updated weekly or more often and aggregates the delivery dates of the licensees who are delivering Crane's material.

The Crane website is written in XML and static HTML is created from the XML source and uploaded to a third-party ISP. For most pages the HTML vocabulary is used in the XML instance for the prose of the page, interspersed with placebo elements that are replaced during the transformation process. These placeholders indicate where tables of information, translated to HTML tables from lengthy XML instances, belong.

To reduce human error and the time taken to incorporate the lengthy tables, XSLT passes through the HTML and replaces the placebo elements with information from multiple source XML documents, both local and remote.

Aggregation

Each licensee can have a private web page accessible using standard HTTP. This page is a simple XML document and is private only in the nature that its address is not public knowledge. Crane accesses the private web page to obtain the information needed for inclusion in the schedule.

Licensees are given a RELAX-NG model of our expectations for the information instance.

No notification is necessary from licensees regarding changes to their information instance. Licensees are welcome to notify Crane of the update in order to trigger immediate incorporation of the information on the schedule page, but this is optional, as the aggregation process simply obtains the most recent version of the document whenever it runs.

Publishing

There are a number of aggregation and resource sites in our markup community, and some have requested to include on their site the schedule of upcoming deliveries of Crane's material. We have created two versions of our course information from which other aggregators can choose.

For a long time a simple colloquial XML vocabulary was used to capture sufficient information for inclusion on a remote site. A sample XSLT stylesheet is available to transform the colloquial XML into an HTML table, though sites are not at all obliged to use the one provided for example.

A growing number of sites are using Rich Site Summary (RSS) because of the various vocabularies used in an RSS instance are already supported in software and transformations. By including a new stylesheet in the web site creation workflow, both the colloquial instance and the RSS instance of the schedule information are available at any time to any site wanting to publish the course calendar.

Parallels for other companies

This model of aggregating information from different sources and of publishing information for unattended access can be applied in many candidate corporate and organizational scenarios.

For example, branch offices could routinely (even daily or hourly) update private web pages on Intranet locations with the information for which they are responsible, and the head office could aggregate these XML instances into a whole that is then published on the Intranet for the branch offices to download again for comparison purposes against the total corporate behavior.

For example, sales people can engage automated tools to upload figures at the end of their respective days of work for the main office to aggregate at their leisure and convenience.

For example, military bases around the world could continually maintain in their own time zones a number of XML instances in unpublished directories for direct access by central commands at any time of the day for real-time summary reports.

XSLT 1.0

Tree construction paradigm

Unlike the Document Object Model (DOM), the basic paradigm of XSLT is the construction of a result tree, in result parse order, from the nodes of the source tree, the nodes of the stylesheet tree and any nodes created by instruction elements in the stylesheet tree.

Multiple input trees

The key to aggregation in XSLT is the use of the document() function to create multiple source trees. The first argument to the function is a Universal Resource Identifier (URI) indicating the location of an XML document. By opening up the XML document as a source node tree, the transformation process can incorporate information from that document in the result.

Relative URI string values point to files in the same or a relative subdirectory, relative to the base URI of the node supplied in the second argument, or if the second argument is absent, the base URI of the stylesheet node in which the instruction is found. When the first argument is a node set instead of a string, the second argument is ignored and a relative URI value is relative to the base URI of the node from which the string value is evaluated.

Most processors support the http: URI scheme, though a processor is not obliged to do so. By pointing to XML documents maintained by licensees on their own web sites, the trees are created in memory with which the result tree is constructed.

Part of the maintenance of licensee information is maintaining a local control XML instance with the local information about the licensee, and a URI pointing to the licensee's XML information instance with the information for which the licensee is responsible. This allows the licensee to update and maintain the information at their own pace and schedule, without having to convey the information to us for maintenance purposes.

In the running example associated with this paper, the licensee information is a short XML file named lic.xml associating a unique identifier with each licensee, the URI of the information file, and the URI of a backup copy of the information file. In this locally-run example, the info= attributes point to local files but would, in a real-world situation, be values like info="http://www.mycompany.com/europe/agg/sched.xml" and info="http://www.mycompany.com/asia/agg/sched.xml".

<?xml version="1.0" encoding="iso-8859-1"?>
<licensees>
  <licensee id="self" info="self.xml"
            backup="backup/self.xml"/>
  <licensee id="other1" info="other1.xml"
            backup="backup/other1.xml"/>
  <licensee id="other2" info="other2.xml"
            backup="backup/other2.xml"/>
</licensees>

Note two important differences in XSLT 1.0 between document(string(xpath-addr),.) and document(xpath-addr,.):

the string cast in the first example will return only the value of the first node addressed by the XPath address and will not address all nodes when addressing all licensee sub-trees in the main control document
using a string-valued first argument utilizes the base URI of the second argument for relative URI address resolution, while a node-valued first argument ignores the second argument and uses the base URI of the each respective node of the first argument as the basis for relative URI address resolution

A final observation is that the stylesheet can detect when the creation of a source tree from a file fails, by returning an empty node-set instead of the root node of the created tree. Unfortunately, though, there is no communication of why the tree could not be made. The two most typical reasons are that there was no information returned from the URI supplied, or the information returned was not well-formed XML. Either way the information from the given licensee is either inaccessible or unusable in the creation of the schedule information.

Date comparison

Comparing dates is important in scheduling applications, so as to properly distinguish events that are either upcoming or in the past.

The XPath 1.0 data model does not have a date type in the set of data types. XSLT 1.0 does not have any date functionality in the built-in function library. Furthermore, the only greater-than/less-than comparisons in XPath 1.0 are based on numeric values, not text string values.

We handle this by using the 10-character ISO format CCYY-MM-DD string for all dates, and converting these strings to numbers by using translate(.,'-','') which removes all dashes from the string. The remaining string of digits can be converted to a number for greater-than/less-than purposes.

Connectivity issue

But what if the web pages of one or more of the licensees are not available at the time of the schedule generation? It would not be desirable to publish the schedule with no licensee information.

We prepare for such eventualities by continually refreshing backup copies of the licensee XML instances locally, every time a successful access is made to the licensee file. Thus, should the access fail by being either inaccessible or not well-formed, the backup copy from the last successful access can be used in its place.

The pseudo-code is as follows:


if( build tree from URI is successful )
then
   write copy of built tree to backup file using XML syntax
else
   build tree from backup XML file
end-if
return root node of the tree that was built

XSLT 1.0 does not provide any instruction for the instantiation of multiple result trees, but most XSLT processors have such extension instructions. Though each processor's extension instruction is composed differently, the fallback mechanism of XSLT 1.0 allows a single stylesheet to "take turns" trying different extension functions until one is successfully executed by the processor in use.

The stylesheet result-file.xsl illustrates how this is done by first checking for the XT processor, then if that is not successful falling back to trying the Saxon processor (this can be done for an arbitrary number of processors, and the design pattern can be used for any kind of extension instruction):

<?xml version="1.0" encoding="iso-8859-1"?>
<!--
 $Id: aggregation.xml,v 1.8 2005/04/11 02:37:19 G. Ken Holman Exp $

 Parameters: filename - required href for result tree serialization
             content - required content for the file
             indent - indentation of result
             method - optional method for serialization (default XML)

 Pro-forma:

    <xsl:call-template name="file:result-file">
      <xsl:with-param name="filename" select=""/>
      <xsl:with-param name="contents">
      </xsl:with-param>
      <xsl:with-param name="method" select="'xml'"/>
      <xsl:with-param name="indent" select="'no'"/>
      <xsl:with-param name="encoding" select="'iso-8859-1'"/>
    </xsl:call-template>

-->
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:file="http://www.CraneSoftwrights.com/ns/result-file"
                xmlns:xt="http://www.jclark.com/xt"
                xmlns:saxon="http://icl.com/saxon"
                extension-element-prefixes="xt saxon"
                exclude-result-prefixes="saxon xt"
                version="1.0">

<xsl:template name="file:result-file">
  <xsl:param name="filename">
    <xsl:message>Missing a filename for outputing a result tree.</xsl:message>
  </xsl:param>
  <xsl:param name="contents">
    <xsl:message>Missing the content for outputing a result tree.</xsl:message>
  </xsl:param>
  <xsl:param name="method" select="'xml'"/>
  <xsl:param name="indent" select="'no'"/>
  <xsl:param name="debug"/>
  <xsl:param name="encoding" select="'utf-8'"/>
  <xsl:if test="$debug">
    <xsl:message>Writing: <xsl:value-of select="$filename"/></xsl:message>
  </xsl:if>
  <xt:document href="{$filename}" method="{$method}" indent="{$indent}"
               encoding="{$encoding}">
    <xsl:copy-of select="$contents"/>
    <xsl:fallback>
      <saxon:output href="{$filename}" method="{$method}" indent="{$indent}"
                    encoding="{$encoding}">
        <xsl:copy-of select="$contents"/>
        <xsl:fallback>
          <xsl:message terminate="yes">Unsupported file writing</xsl:message>
        </xsl:fallback>
      </saxon:output>
    </xsl:fallback>
  </xt:document>
</xsl:template>

</xsl:stylesheet>

In the example associated with this paper, the assembly task is responsible for creating a local copy of all remote licensee information, whether from the licensee in real time, or from the backup copy of the last successful access:

<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:file="http://www.CraneSoftwrights.com/ns/result-file"
                exclude-result-prefixes="file"
                version="1.0">

<!--
     Assembly of remotely-maintained course delivery information files
     into an aggregate delivery schedule

     The input is a set of licensees with respective pointers to XML
     information files.
-->

<xsl:import href="result-file.xsl"/>

<xsl:output indent="yes"/>

<!--wrap the results-->
<xsl:template match="licensees">
  <deliveries>
    <xsl:apply-templates select="licensee"/>
  </deliveries>
</xsl:template>

<!--obtain the information for each licensee-->
<xsl:template match="licensee">
  <xsl:variable name="info" select="document(@info)"/>
  <xsl:choose>
    <xsl:when test="$info">
      <!--successful retrieval!  Add the content to the result tree-->
      <xsl:copy-of select="$info"/>
      <!--make a backup of the contents in case there is no access next time-->
      <xsl:call-template name="file:result-file">
        <xsl:with-param name="filename" select="@backup"/>
        <xsl:with-param name="contents">
          <xsl:copy-of select="$info"/>
        </xsl:with-param>
      </xsl:call-template>
    </xsl:when>
    <xsl:when test="document(@backup)">
      <!--unsuccessful retrieval, but backup file has already been made-->
      <xsl:message>
        <xsl:text>Using backup information for lic="</xsl:text>
        <xsl:value-of select="@id"/>"<xsl:text/>
      </xsl:message>
      <xsl:copy-of select="document(@backup)"/>
    </xsl:when>
    <xsl:otherwise>
      <!--unsuccessful retrieval and no backup made from any previous try-->
      <xsl:message terminate="yes">
        <xsl:text>Missing any kind of information for lic="</xsl:text>
        <xsl:value-of select="@id"/>"<xsl:text/>
      </xsl:message>
    </xsl:otherwise>
  </xsl:choose>
</xsl:template>

</xsl:stylesheet>

Implementation

For ease of integration of our own schedule with those of our licensees, we made ourselves one of our own licensees. Any special handling can be done by adding a reserved attribute to our own information structure that is not documented to the licensees.

We published a RELAX-NG model of the information we expect our licensees to maintain for themselves, such as how they want to spell their company name, in what location are they based, and on what days and in what locations they will be teaching which courses. We supply unique identifiers for each of the courses for them to use, so that when we aggregate their information with ours, these references become valid IDREF values.

Here is a licensee file from the example associated with this paper:

<?xml version="1.0" encoding="iso-8859-1"?>
<licensee>
  <name>Other Company One Name</name>
  <location>London, England</location>
  <deliveries>
    <delivery date="2004-08-20" ref="c1" days="3">
      <location>Paris, France</location>
    </delivery>
    <delivery date="2004-08-28" ref="c2" days="1">
      <location>Brussels, Belgium</location>
    </delivery>
  </deliveries>
</licensee>

The data flow from the licensee to our schedule page is as follows using an XSLT 1.0 processor:

Note that in XSLT 2.0 it is possible to do both the aggregation and web page generation in a single pass by placing the aggregated schedule in a result tree fragment and then pushing the result tree fragment through the stylesheet.

The stylesheet that presents the assembled aggregation in the example associated with this paper uses a simple table for each course.

<?xml version="1.0" encoding="iso-8859-1"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
                xmlns:saxon="http://icl.com/saxon"
                extension-element-prefixes="saxon"
                exclude-result-prefixes="saxon"
                version="1.0">
<!--
     Create the schedule HTML page summarizing all courses and their deliveries
-->

<xsl:param name="info"/><!--filename of information file-->
<xsl:variable name="dels" select="document($info,/)/*/*/deliveries/delivery"/>

<xsl:template match="sched">
  <html>
    <head>
      <title><xsl:value-of select="title"/></title>
      <body>
        <xsl:apply-templates/>
      </body>
    </head>
  </html>
</xsl:template>

<xsl:template match="sched/title">
  <h1><xsl:apply-templates/></h1>
</xsl:template>

<xsl:template match="course">
  <xsl:apply-templates/>
  <xsl:variable name="coursedels" select="$dels[@ref=current()/@id]"/>
  <xsl:if test="$coursedels">
    <table border="1">
      <tr>
        <td align="center">Date</td>
        <td align="center">Location</td>
        <td align="center">Company</td>

      </tr>
      <xsl:for-each select="$coursedels">
        <xsl:sort select="translate(@date,'-','')"/>
        <tr>
          <td><xsl:value-of select="@date"/></td>
          <td><xsl:value-of select="location"/></td>
          <td><xsl:value-of select="../../name"/></td>
        </tr>
      </xsl:for-each>
    </table>
  </xsl:if>
</xsl:template>

<xsl:template match="course/title">
  <h2><xsl:apply-templates/></h2>
</xsl:template>

<xsl:template match="course/desc">
  <xsl:apply-templates/>
</xsl:template>

<xsl:template match="*" priority="-1">
  <xsl:copy>
    <xsl:copy-of select="@*"/>
    <xsl:apply-templates/>
  </xsl:copy>
</xsl:template>

</xsl:stylesheet>

The result is a simple display of all of the information aggregated from the remote locations:

Publishing for the purposes of aggregation

Crane also publishes the information about our own deliveries of our training for those sites who wish to make it available to their visitors.

This information is made available in two vocabularies: a colloquial XML vocabulary designed many years ago for our own use, and an RSS instance utilizing a number of vocabularies recognized by different sites. These are static instances created as a byproduct of our aggregation stylesheets, not "feeds" that are generated on the fly.

Other aggregators wishing to include our information need only access the information at their convenience without requiring our permission. The page with all of the information required is available through a link on our home page. Example stylesheets are provided to transform both example instances into the same table format. Aggregators are not obliged to use the example stylesheets, but for some it made the decision easy to include our data on their site.

Consider the situation earlier this year when Crane had two publicly-subscribed offerings in June. Two examples follow illustrating how the same information is made available in the two vocabularies.

Colloquial XML vocabulary

The following is an example instance capturing the information about Crane's deliveries of their own material using a colloquial XML vocabulary that succinctly captures the minimum amount of information using simple element names and no namespaces:

<?xml version="1.0" encoding="utf-8"?>
<crane upcoming="http://www.CraneSoftwrights.com/schedule.htm" past="http://www.CraneSoftwrights.com/training/pastsch.htm" date="2004-01-31T12:00:00-04:00">
   <course id="i2ubl" syllabus="http://www.CraneSoftwrights.com/schedule.htm#i2ubl">
      <title>Introduction to the Universal Business Language (UBL)</title>
   </course>
   <course id="i2xim" syllabus="http://www.CraneSoftwrights.com/training/i2xim/i2ximsyl.htm">
      <title>Introduction to XML Information Modeling</title>
   </course>
   <course id="xslintro" syllabus="http://www.CraneSoftwrights.com/schedule.htm#xslintro">
      <title>Introduction to XML, XSLT and XSL-FO</title>
   </course>
   <course id="i2xslfo" syllabus="http://www.CraneSoftwrights.com/training/i2xslfo/i2xslfosyl.htm">
      <title>Introduction to XSL-FO</title>
   </course>
   <course id="i2xslt" syllabus="http://www.CraneSoftwrights.com/training/i2xslt/i2xsltsyl.htm">
      <title>Introduction to XSLT and XPath</title>
   </course>
   <course id="pfux" syllabus="http://www.CraneSoftwrights.com/training/pfux/pfuxsyl.htm">
      <title>Practical Formatting Using XSL-FO</title>
      <deliveries>
         <delivery date="2004-06-17" status="register" info="http://www.3b2.com/index.php?section=events&amp;sub=xml_training" registration="https://www.3b2.com/secure/xml_training_form.html">
            <length>Two days</length>
            <location>Birmingham, England</location>
         </delivery>
      </deliveries>
   </course>
   <course id="ptux" syllabus="http://www.CraneSoftwrights.com/training/ptux/ptuxsyl.htm">
      <title>Practical Transformation Using XSLT and XPath</title>
      <deliveries>
         <delivery date="2004-06-14" status="register" info="http://www.3b2.com/index.php?section=events&amp;sub=xml_training" registration="https://www.3b2.com/secure/xml_training_form.html">
            <length>Three days</length>
            <location>Birmingham, England</location>
         </delivery>
      </deliveries>
   </course>
   <course id="puubls" syllabus="http://www.CraneSoftwrights.com/schedule.htm#puubls">
      <title>Practical Use of UBL Schemas</title>
   </course>
   <course id="pxid" syllabus="http://www.CraneSoftwrights.com/training/pxid/pxidsyl.htm">
      <title>Practical XML Information Description</title>
   </course>
   <course id="pxim" syllabus="http://www.CraneSoftwrights.com/training/pxim/pximsyl.htm">
      <title>Practical XML Information Modeling</title>
   </course>
   <course id="xmlcorp" syllabus="http://www.CraneSoftwrights.com/training/xcorpsyl/xcorpsyl.htm">
      <title>XML in the Corporation</title>
   </course>
   <course id="xmlstyle" syllabus="http://www.CraneSoftwrights.com/training/xmlstyle/xmlstsyl.htm">
      <title>XML Models, Stylesheets and Transformations</title>
   </course>
   <course id="xmltown" syllabus="http://www.CraneSoftwrights.com/schedule.htm#xmltown">
      <title>XML Town Hall</title>
   </course>
</crane>

RSS 1.0 vocabulary

The following is an excerpt from the RSS 1.0 instance created for the information. Note the extensive use of namespaces, and the duplication of information in different namespaces for different RSS readers that support alternative structures that are available:

RDF vocabulary components
Dublin Core metadata
Crane's own namespace for information components
an events module describing different kinds of events that might be held
a geographical location system based on latitude and longitude
a calendaring module describing different kinds of dates and durations
RSS 1.0 vocabulary components (using the default namespace)

<?xml version="1.0" encoding="utf-8"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" 
  xmlns:dc="http://purl.org/dc/elements/1.1/" 
  xmlns:csl="http://www.CraneSoftwrights.com/ns/rss" 
  xmlns:ev="http://purl.org/rss/1.0/modules/event/" 
  xmlns:geo="http://www.w3.org/2003/01/geo/wgs84_pos#" 
  xmlns:ical="http://www.w3.org/2002/12/cal/ical#" 
  xmlns="http://purl.org/rss/1.0/">
   <channel rdf:about="http://www.CraneSoftwrights.com/training/crane-courses.rss">
      <title>Crane Softwrights Ltd. Publicly-subscribed Training</title>
      <link>http://www.CraneSoftwrights.com/training/crane-courses.rss</link>
      <description>
This includes both a calendar of upcoming deliveries of publicly-subscribed 
training and a catalogue of all training courses offered by Crane Softwrights 
Ltd.

A calendar entry describes an event, while a catalogue entry describes a course.  
Use the shared value of the respective course identifier elements when matching 
a catalogue entry with all of its associated calendar entries.
</description>
      <dc:date>2004-01-31T12:00:00-04:00</dc:date>
      <items>
         <rdf:Seq>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:ptux:2004-06-14"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:pfux:2004-06-17"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:pxid"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:pxim"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:puubls"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:xmlcorp"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:xmlstyle"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:i2xslt"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:i2xim"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:i2xslfo"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:i2ubl"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:xmltown"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:xslintro"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:ptux"/>
            <rdf:li rdf:resource="urn:CraneSoftwrights.com:entry:pfux"/>
         </rdf:Seq>
      </items>
   </channel>
   <item rdf:about="urn:CraneSoftwrights.com:entry:ptux:2004-06-14">
      <title>2004-06-14 PTUX Birmingham, England</title>
      <description>2004-06-14/2004-06-16 - Practical Transformation Using XSLT 
and XPath - Birmingham, England</description>
      <link>http://www.3b2.com/index.php?section=events&amp;sub=xml_training</link>
      <ev:type>Hands-on training</ev:type>
      <geo:Point>
         <geo:lat>60.16</geo:lat>
         <geo:long>24.95</geo:long>
      </geo:Point>
      <ev:location>Birmingham, England</ev:location>
      <ev:organization>Crane Softwrights Ltd.</ev:organization>
      <ev:startdate>2004-06-14</ev:startdate>
      <ev:enddate>2004-06-16</ev:enddate>
      <ical:dtstart>
         <ical:date>2004-06-14</ical:date>
      </ical:dtstart>
      <ical:dtend>
         <ical:date>2004-06-16</ical:date>
      </ical:dtend>
      <ical:duration>P3D</ical:duration>
      <dc:title>2004-06-14/2004-06-16 - Practical Transformation Using XSLT and XPath - Birmingham, England</dc:title>
      <dc:subject>Extensible Stylesheet Language Transformations (XSLT)</dc:subject>
      <dc:subject>XML Path Language (XPath)</dc:subject>
      <csl:course-id>ptux</csl:course-id>
      <csl:syllabus rdf:resource="http://www.CraneSoftwrights.com/training/ptux/ptuxsyl.htm"/>
      <csl:length csl:quantity="3" csl:unit="day">Three days</csl:length>
      <csl:status>register</csl:status>
      <csl:registration rdf:resource="https://www.3b2.com/secure/xml_training_form.html"/>
   </item>
   ...
   <item rdf:about="urn:CraneSoftwrights.com:entry:ptux">
      <title>Practical Transformation Using XSLT and XPath</title>
      <description>
"Practical Transformation Using XSLT and XPath" overviews the entire scope of 
the Extensible Stylesheet Language Transformations (XSLT) 
http://www.w3.org/TR/xslt and the XML Path Language (XPath) 
http://www.w3.org/TR/xpath W3C Recommendations, used for transforming structured 
information (e.g. XML to XML, XML to HTML, XML to WML, XML to text, etc.). The 
objectives of the course are to understand the role and utility of the 
Recommendations, to overview all the constructs of the Recommendations (the two- 
and three-day deliveries cover every element, every attribute, and every 
function), to design and develop XSLT scripts, and to efficiently navigate the 
available documentation and resources. The relationship of XSLT to XSL is 
explained, though details of XSL Formatting Object semantics are not included.

This hands-on course combines the use of lectures and exercises to convey the 
material. For the practical exercises, attendees are invited to bring a personal 
computer (with a USB port or CD-ROM drive) and their own XSLT environment or 
they can use public-domain XSLT software that will be made available for either 
a Java-based or a Windows-based environment (see syllabus link above for 
details).

This course runs in either a one-day, two-day or a three-day format, the three-
day being preferred. The one day is more of an introduction with exercises than 
a comprehensive tutorial as it is not long enough to cover every construct. The 
two-day format is for those with a very firm foundation in XML syntax and 
constructs as the content is covered quickly and exercises are given over the 
break periods only. The three-day format covers is ideal and is the recommended 
length. This length includes additional lecture material than the two-day, with 
time allocated on the XSLT and XPath perspectives of XML syntax and on the 
exercises.

</description>
      <link>http://www.CraneSoftwrights.com/schedule.htm#ptux</link>
      <dc:title>Practical Transformation Using XSLT and XPath</dc:title>
      <dc:subject>Extensible Stylesheet Language Transformations (XSLT)</dc:subject>
      <dc:subject>XML Path Language (XPath)</dc:subject>
      <csl:course-id>ptux</csl:course-id>
      <csl:syllabus rdf:resource="http://www.CraneSoftwrights.com/training/ptux/ptuxsyl.htm"/>
      <csl:past rdf:resource="http://www.CraneSoftwrights.com/training/pastsch.htm#ptux"/>
   </item>
   ...
</rdf:RDF>