is a W3C draft Recommendation for embedding Semantic Web statements into ordinary HTML Web pages. This example illustrates how RDFa can integrate HTML into the self-describing Semantic Web:

Mary is exploring the Web using a browser that has been enhanced with capabilities for interpreting RDFa. Her browser knows to look through each Web page that she browses, picking out information from the RDFa, and helping her to use it. For example, the page might contain the following HTML, which represents an -style contact listing. (This example is adapted from one in ):

    <p class="contactinfo" 
          xmlns:contact="http://www.w3.org/2001/vcard-rdf/3.0#"
          about="http://example.org/staff/joseph">
        My name is
        <span property="contact:fn">
            Joseph Smith
        </span>
        I'm a
        <span property="contact:title">
            distinguished web engineer
        </span>
        at
        <a rel="contact:org" href="http://example.org">
            Example.org
        </a>.
        You can contact me
        <a rel="contact:email" href="mailto:joe@example.org">
            via email
        </a>.
    </p>

Even though this document is of media type application/xhtml+xml, which is not a member of the RDF family of media types, an RDFa-enabled user agent can extract RDF from this document. This document conveys as RDF a set of semantic Web statements about the Web resource http://example.org/staff/joseph. The predicates are all named with the same base URI http://www.w3.org/2001/vcard-rdf/3.0#, for which the shorthand prefix contact is established in the HTML. Using this syntax, the RDFa carries triples for relationships such as the full name of the contact (http://www.w3.org/2001/vcard-rdf/3.0#fn), which is Joseph Smith, the e-mail address (http://www.w3.org/2001/vcard-rdf/3.0#email) which is mailto:joe@example.org, and so on.

An RDFa-enabled user agent can extract these triples and use them to help Mary work with the data they contain, or to integrate with other Semantic Web information. Indeed RDF is designed for such use because, as discussed above in , Semantic Web triples are inherently self-describing. If a user agent needs more information about the processing of the email triple it can, like Amy's user agent, do an HTTP GET http://www.w3.org/2001/vcard-rdf/3.0 and use the results to get more information. With luck, that information will lead the agent to automatically discover that, in the example, mailto:joe@example.org can indeed be used to send mail to the person named Joseph Smith. The browser can then offer Mary the option to send e-mail to Joe, or to add Joe to her address book.

Good Practice: RDFa SHOULD be used to make information conveyed in HTML self-describing.

Note: at this time, drafts of the specification are available, but the media-type registration for HTML itself has not been updated to reflect RDFa. As described in TAG Finding , conventions like RDFa are normative only if provided for in the applicable specification for the media-type in which they are used. Thus, for RDFa to be fully integrated with , the HTML and/or XHTML media-type registrations must be be updated. Use of RDFa is in any case encouraged in the interim until that happens.

Using GRDDL to bridge from XML to RDF

RDFa provides a standard means of encoding RDF information in XHTML documents, but many other XML variants lack that capability. Furthermore, RDFa requires explicit encoding of each triple in the XHTML instance, and that may in some cases be impractical. provides a standard means of extracting useful RDF statements (triples) from a broad range of XML document formats. Each GRDDL-enabled XML document links to a transformation that, when applied to the document, produces RDF triples. Typically, the same GRDDL transformation can be used on entire families of similar XML documents.

For example, assume that Albert uses a GRDDL-enabled user agent to retrieve an XML document containing the following fragment:

<employees xmlns="http://example.org/employeeNS">
  <employee name="Bob Smith">
    <email>BobSmith@example.org</email>
  </employee>
</employees>

Note that, unlike the earlier examples, this is neither in HTML nor in RDF; we can assume that http://example.org/employeeNS is a namespace created by some particular business for use in its own busines documents. Albert's agent has no built in knowledge of this namespace, and so can not do much with it. Now assume that Albert instead retrieves a different document. Most of the markup and data in it is identical to the first, but this document is GRDDL enabled:

<employees xmlns="http://example.org/employeeNS"
              xmlns:grddl="http://www.w3.org/2003/g/data-view#"
              grddl:transformation=
                    "http://example.org/GRDDL_For_employeeNS.xsl>
  <employee name="Bob Smith">
    <email>BobSmith@example.org</email>
  </employee>
</employees>

Albert's user agent is GRDDL aware, so it transforms the <employees> information to RDF using the supplied GRDDL_For_employeeNS.xsl transformation. If Albert is lucky, that transformation produces RDF triples that the agent understands, or that the agent can dynamically discover how to process using the techniques described above in . As in the earlier examples, Albert's user agent offers to send mail to Bob Smith.

Good Practice: GRDDL SHOULD be used to integrate XML documents into the self-describing Semantic Web.

Self-describing XML documents

Section described how GRDDL can be used to integrate XML documents with the RDF-based Semantic Web. This section describes a related technique for creating new, self-describing XML formats.

Given that a Web document is of media type application/xml, or in the family of media types application/____+xml, recursive processing from the root element down may be applied to determine not just the overall nature of the document, but also the meaning in context of its sub-elements. Doing this, however, requires understanding of the semantics of each named element. Although a few specific XML variants such as application/xhtml+xml may be directly supported by some user agents, no user agent can build in support for the ever growing set of XML languages used for Web representations. This section describes how namespace documents, discoverable from the XML tag names in the markup, can be used to make such languages self-describing, and to enable automated processing of them.

When XML namespaces are used , each XML element is named with a qualified name, consisting of a prefix and a local name. In the following example, the root element has the qualified name <inventory:inventoryItem>:

   <inventory:inventoryItem 
        xmlns:inventory="http://example.org/inventoryNamespace">
     <inventory:itemNumber>
         87354
     </inventory:itemNumber>
     <inventory:quantityAvailable>
         152
     </inventory:quantityAvailable>
   </inventory:inventoryItem>

Qualified names map to expanded names such as {http://example.org/inventoryNamespace,inventoryItem}, comprised of a namespace name URI (http://example.org/inventoryNamespace) and a local name (inventoryItem). The namespace name URI serves at least two roles: the most obvious and the most widely understood is to distinguish expanded names in one namespace from those in another; the other role, and the one that's most important for purposes of this finding, is that it provides Web identification for the namespace itself. The namespace is a Web resource, and like any other resource, it can and should provide representations using HTTP. A user agent processing an XML document can retrieve descriptions of the namespaces used in that document, and can use that retrieved information to determine how to correctly process the XML markup. The W3C TAG is currently working on a finding that will describe best practices for creating such representations of namespaces. Drafts of the finding, which are available at , recommend the use of as a preferred means of documenting namespaces. RDDL is itself extensible, but it is commonly used to suggest XML Schemas (in any of several languages), XSLT Stylesheets, etc. that are usable with markup from the namespace being described.

Example: assume that user Bob is browsing the Web, and that he follows a link to a resource that returns the XML above as its representation. Bob's browser uses to retrieve the representation, to determine its character encoding, and to discover that its Content-type is application/inventory+xml. Of course, it's very unlikely that Bob's browser has built in knowledge of the inventory XML language, but the Content-type makes clear that the representation can be interpreted as XML with Namespaces. The root element tag is from namespace http://example.org/inventoryNamespace, which uses the http scheme, so Bob's browser does an HTTP GET from that URI. What comes back is a RDDL document containing the following <rddl:resource> element:

<rddl:resource
   xlink:role="http://www.w3.org/1999/XSL/Transform"
   xlink:arcrole="http://www.w3.org/1999/xhtml"
   xlink:href="http://example.org/InventoryToBrowsableHTML.xslt"
   xlink:title="Transform Inventory XML to HTML for Browsing">
</rddl:resource>

This designates a stylesheet (http://example.org/InventoryToBrowsableHTML.xslt) that can be applied to format the inventory XML as HTML — the browser automatically retrieves and applies the stylesheet, producing HTML that is rendered on the screen. Without any manual intervention from Bob, his browser automatically displays the inventory record in a format that's convenient to read and print. Bob's browser may also be enabled for XML validation, in which case it can look in the RDDL for a link to a schema to be used for validating inventory markup, and can use that to check the document.

Bob's browser has, like Amy's in the RDF example shown earlier, extended itself for processing of the inventory markup language. Unless the RDDL provides a link to one or more executable program that processes inventory records, it's unlikely that Bob's browser can automatically discover everything that one might reasonably want to know about processing inventory markup. Still, even the limited automatic function described above is very useful, and RDDL is an extensible framework that can be easily adapted to provide new kinds of information about namespaces. Note that because RDDL documents are themselves XML, GRDDL can be applied to derive RDF statements from them (see ). In this way, self-describing XML documents can be integrated with the self-describing Semantic web. describes this technique in more detail.