Abstract

XML's three most important companions are XML Namespaces for combining XML names from different vocabularies; XML Schema for defining XML vocabularies; and XSL Transformations (XSLT) for transforming XML data into other structures, either another XML vocabulary, or something else entirely. These technologies are the basic toolbox for any Web-based technology today.

Name Spaces

• Names are one form of identification
• Names in XML are not suitable for identification
  • they are local to their context (where they are defined)
  • if the context is uniquely identified, the names would be, too
• Name Spaces: Put names into spaces
  • how to identify the space? Web things are identified by URIs

URI Philosophy

• Uniform Resource Identifier (URI) uniquely identify resources
• URIs often provide access information
  • pretty clear in http://dret.net/lectures/xml-fall06/
  • less clear in urn:ietf:rfc:2648 (RFC 2648)
  • very (and purposely) unclear in tag:9327493874329 (RFC 4151)
• URIs often return resource representations
  • the resource itself is never returned (how to return a lecture?)
  • some representation often is useful (HTML, PDF, maybe video/audio)
  • the resource exists and is useful without a representation!
• URIs are much more than just addresses of HTML pages

The Namespace Problem

• People assume that URIs point to Web pages
  • a namespace name (a URI) may point to a Web page
  • it may also have no Web page associated with it
  • it may even use a URI scheme which cannot be retrieved
  • but it is still possible to compare URIs!
• People assume some standardized content format
  • friendly namespaces provide HTML portals (XHTML)
  • some namespaces just give you the schema (SOAP)
  • less friendly namespaces provide minimal information (XSLT)
  • very unfriendly namespaces may return a 404 or even use inaccessible schemes
  • but they all are valid, because no resource representation is required!
• Namespaces are used by comparing URIs
  • anything else maybe useful, but is not strictly required
  • when searching for a namespace definition, use Google (string search)

Declaring Namespaces

• Using a namespace means referencing names from it
  • unfortunately, there is no really standard way of writing these names
  • (the Clark notation is useful: {http://www.w3.org/1999/xhtml}html)
  • Namespaces are declared and then used
• xmlns-prefixed attributes are used for declaring namespaces
  • Default: html xmlns="http://www.w3.org/1999/xhtml"
  • Prefix: xhtml:html xmlns:xhtml="http://www.w3.org/1999/xhtml"
• Namespace declarations are inherited and can be overwritten
  • the default namespace can be undeclared
  • Namespace declarations can be used in a myriad of ways

Unhealthy Namespace Usages

• Namespaces can be (and are) used in very weird ways
  • these are syntax variations of identical structures
  • without a good (i.e., conforming) parser, interpretation is very hard
  • copy/paste can become hard or impossible
• Namespaces can be neurotic, psychotic, borderline, or normal
• Each of the insane cases complicates processing
• None of these has any real technical inaccuracies
• XML should be used with humans in mind

Unhealthy Namespace Usages in Practice

<neurotic>
 <prefix:elem xmlns:prefix="http://ns1.com/">
  <prefix:child>content</prefix:child>
 </prefix:elem>
 <prefix:elem xmlns:prefix="http://ns2.com/">
  <prefix:child>content</prefix:child>
 </prefix:elem>
</neurotic>

<borderline>
 <prefix1:elem xmlns:prefix1="http://ns1.com/">
  <prefix1:child>content</prefix1:child>
 </prefix1:elem>
 <prefix2:elem xmlns:prefix2="http://ns1.com/">
  <prefix2:child>content</prefix2:child>
 </prefix2:elem>
</borderline>

<psychotic xmlns:prefix1="http://ns1.com/" xmlns:prefix2="http://ns1.com/">
 <prefix1:elem>
  <prefix2:child>content</prefix2:child>
 </prefix1:elem>
 <prefix2:elem>
  <prefix1:child>content</prefix1:child>
 </prefix2:elem>
</psychotic>

Elements and Attributes

• Namespaces often apply to elements and attributes
  • if the name has no prefix, it has no namespace or the default namespace associated
  • if the name has a prefix, the prefix must be bound to a namespace name
  • names like this are called Qualified Names (QNames)
• Applications should interpret QNames
  • naïve implementations will break when processing unhealthy instances
  • the mechanics of implementing namespaces are not very hard

Other Usages

• Increasingly, QNames are used in content
  • XSLT was the first specification using this
  • many other technologies have followed

<xsl:template match="section" xmlns:mathml="http://www.w3.org/1998/Math/MathML/">
 <xsl:if test="exists(.//mathml:*)">

• Technically, everything is well-defined
  • for processing, the namespace bindings must be known
  • copy/paste on a textual basis may not work or even work wrong

Any URI is Possible

• A namespace name is a URI, that's all!
  • it may not be accessible (because of the URI scheme)
  • when retrieving it, nothing may be returned
  • when retrieving it, something may be returned
• The only important thing is the name
  • the name is mentioned in the documentation
  • if you know the documentation, you known the name
  • shared names mean shared knowledge

Namespace Definitions

• Namespaces can be defined by a DTD (XHTML)
• Namespaces can be defined by an XML Schema (SOAP)
• Namespaces can be defined by RELAX NG (XHTML 2.0)
• Namespaces can be defined by prose (XSLT)
• If schemas are provided, additional information is required
  • it is unlikely that a namespace can be fully described by a schema
  • additional constraints and semantics are specified in prose

Fixed or Extensible?

• Can a namespace change over time?
  • may your document become outdated? extended? replaced?
  • this should be clearly documented in the namespace definition
• The XML XML Namespace was widely believed to be defined by XML
  • xml:lang and xml:space defined by XML
  • xml:base was added by XML Base
  • xml:id was added by xml:id
• When defining namespaces, plan ahead and publish everything
  • dependencies, change management, and versioning issues are important
  • there still is no accepted standard for namespace descriptions

Namespace Descriptions

Erik Wilde, Structuring Namespace Descriptions, 15th International World Wide Web Conference (WWW2006), Edinburgh, UK, May 2006.

XML Schemas

• Probably the most awkward name choice in the XML arena
  1. I use an XML (pause) schema to validate my XML documents
  2. I use an XML (no pause) Schema to validate my XML documents
• DTDs were not good enough (no datatype support)
  • B2B applications need datatypes
  • XML Schema also introduced a whole new type layer into XML schemas

Schema-Validation and Applications

XML Schema vs. DTD

Simple Types

Schemas in Practice

• Schemas define which markup to expect
  • XML Schemas do so with a lot of pitfalls and complications
  • without tools, using XML Schema is really hard
• Schemas define which content to expect
  • simple types can be used for validation and may carry semantics
  • depending on how good the type design is, typed content is useful
• Schemas will not cover all application semantics
  • some constraints cannot be defined in a schema
  • application semantics and pragmatics also are not defined in the schema

XML Schema vs. DTD

<!ELEMENT people (customer | employee | temporary_employee)* > <!ELEMENT customer (name, address) > <!ATTLIST customer %added; > <!ELEMENT name (#PCDATA)> <!ELEMENT address (#PCDATA) >

<xs:element name="people"> <xs:complexType> <xs:choice minOccurs="0" maxOccurs="unbounded"> <xs:element ref="customer"/> <xs:element ref="employee"/> <xs:element ref="temporary_employee"/> </xs:choice> </xs:complexType> </xs:element> <xs:element name="customer"> <xs:complexType> <xs:sequence> <xs:element ref="name"/> <xs:element ref="address"/> </xs:sequence> <xs:attribute name="added" type="xs:anySimpleType" use="required"/>

Origin

• XML should be used for Web publishing
  • XML vocabularies have no inherent formatting
  • browsers must be able to render XML documents
  • CSS was available, but tailored to HTML's needs
• XML was meant to be used for any vocabulary
  • CSS was too limited (unable to change the document's structure)
  • a true programming language was required
• Extensible Stylesheet Language (XSL) was created for XML formatting
  1. documents are transformed using XSLT
  2. the formatted result uses XSL Formatting Objects (XSL-FO) for page description
  3. an XSL-FO processor renders the formatted document
  • today, only XML → XSL-FO → PDF has survived

Client-Side XSLT

• XSLT was designed as a client-side language
  1. the browser loads an XML document
  2. the browser loads the associated XSLT
  3. the browser processes the XSLT and renders the results
• Client-side languages have severe constraints
  • the runtime environment must be well-defined
  • security issues are very important
• XSLT is a very autistic language
  • no access to the system whatsoever (not even date/time)
  • no access to files
  • additional documents may be read through URIs
  • output goes to standard out and then somewhere

XSLT Processors

• XSLT is an interpreted language
  • the XSLT document is read and executed
  • internal optimizations are used to improve performance
• XSLT processors are ubiquitous
  • MSXML, Firefox (TransforMiiX), XML Spy, Saxon
• XSLT execution can be expensive
  1. JVM starts up and reads the Saxon jar
  2. Saxon's XML parser reads the the XSLT and the XML
  3. Saxon's Java code executes the XSLT instructions

XML, XSLT, and HTML

<?xml-stylesheet type="text/xsl" href="book.xsl"?>
<book>
 <author>Erik Wilde</author>
 <author>David Lowe</author>
 <title>XPath, XLink, XPointer, and XML: A Practical Guide to Web Hyperlinking and Transclusion</title>
 <date>July 2002</date>
 <publisher>Addison Wesley</publisher>
 <isbn>0201703440</isbn>
</book>

 <xsl:template match="/">
  <html>
   <body>
    <xsl:for-each select="/book/author">
     <xsl:value-of select="."/>
     <xsl:choose>
      <xsl:when test="position() = last() - 1"> and </xsl:when>
      <xsl:otherwise>, </xsl:otherwise>
     </xsl:choose>

<html>
   <body>Erik Wilde and David Lowe, <em>"XPath, XLink, XPointer, and XML: A Practical Guide to Web Hyperlinking and Transclusion",</em> Addison Wesley, July 2002, ISBN: 0201703440.
   </body>
</html>

XSLT Processing Model

XML Toolbox

• XML is just a syntax for trees
• There are many tools to work with these trees
• XML Namespaces let you identify well-known parts of it
• XML Schema lets you check a tree for validity
• XSLT lets you restructure trees into other trees
• Using XML tools, life in an XML-centric world gets easier