RDF Channel

A super-minimal RDF vocabulary for syndication inspired by RSS.

The namespace for this vocabulary is “http://www.eyrie.org/~zednenem/2002/rdfchannel/”. A schema is also available.

Property “current”

Indicates the current items in a channel. Any resource can have a “current” property (in which case it becomes an instance of Channel). The value of current should be a collection of resources (which become instances of Item). The collection may be an rdf:List, rdf:Seq, or rdf:Bag. For syntactic simplicity, rdf:List is preferred. Applications are advised to respect the order of Items presented in an rdf:List or rdf:Seq, but are not required to do so.

Example:

<rdf:Description rdf:about="http://example.org/">
    <current rdf:parseType="Collection">
        <rdf:Description rdf:about="http://example.org/455"/>
        <rdf:Description rdf:about="http://example.org/454"/>
    </current>
</rdf:Description>

A resource may have no more than one value for the current property at any given time.

Class “Channel”

Any resource which has property “current” is a Channel. It is not necessary to explicitly declare their type, although it is not incorrect to do so.

Note that only one Channel may be associated with a given URI reference. A service which offers multiple Channels must give them unique addresses (using rdf:about or rdf:ID).

Class “Item”

A generic class of resources which belong to a channel (that is, are part of the collection specified by “current”). There is no need to explictly identify the type of Items, as it can be deduced from context and doesn’t provide any useful information.

[@@ does Item serve any purpose? Since the members of the current collection can belong to any class, it is unclear what Item gets us]

Property “link”

When applied to an Item or Channel, indicates a resource to which this resource is linked. If declared, a user agent will use this address when a user requests to see the resource; otherwise, it will use the address of the resource.

For example, a web site which provides multiple Channels cannot use its address to identify the Channels, because they must have distinct addresses. Instead, it can give each Channel a distinct address and link them all to the site. A reader clicking on the channel’s name would be directed to the site, not the address of the Channel.

Property “icon”

When applied to a Channel, indicates an image which newsreaders may display when presenting the channel. The value will be a resource of type dctype:Image, which may have properties of its own.

A minimalist icon declaration:

<icon rdf:resource="URI"/>

A icon declaration including alt text and a link:

<icon>
    <dctype:Image rdf:about="URI">
        <dc:title>alt text</dc:title>
        <link rdf:resource="link URI"/>
    </dctype:Image>
</icon>

[@@ dc:title doesn’t seem quite right for alt text. is dc:description better?]

Other properties: title, description, etc.

Rather than define new properties for titles, descriptions, and so forth, RDF Channel recommends use of the Dublin Core. In particular, the properties dc:title, dc:description, dc:date, and dc:creator. Qualified Dublin Core also provides more specific variants, such as dcterm:issued and dcterm:modified for dates, and some classes, such as dctype:Image and dctype:Event.

The recommended format for dates is W3CDTF, a profile of ISO 8601.

Recommended XML syntax

The RDF/XML syntax is extremely flexible, which makes it complex to parse. Although it is recommended that tools use one of the freely available RDF/XML parsers to interpret RDF Channel files, it is also recommended that RDF Channels appear in this general format which is easily parsed by simple tools.

<rdf:RDF
    xmlns:rdf   ="http://www.w3.org/1999/02/22-rdf-sytax-ns#"
    xmlns:dc    ="http://purl.org/dc/elements/1.1/"
    xmlns:dctype="http://purl.org/dc/dcmitype/"
    xmlns       ="http://www.eyrie.org/~zednenem/2002/rdfchannel/">

<Channel rdf:about="channel URI">
    <link rdf:resource="site URI"/>
    <dc:title>channel title</dc:title>
    <dc:description>channel description</dc:channel>

    <icon>
        <dctype:Image rdf:about="image URI">
            <dc:title>alt text</dc:title>
            <link rdf:resource="image link URI"/>
        </dctype:Image>
    </icon>
    
    <current rdf:parseType="Collection">
        <Item rdf:about="item URI">
            <link rdf:resource="link URI"/>
            <dc:title>item title</dc:title>
            <dc:date>item date</dc:date>
            <dc:description>item description</dc:description>
        </Item>
        more Items
    </current>
</Channel>

</rdf:RDF>

The link, icon, dc:title, dc:description, and dc:date elements are optional. The order of child elements is not significant, except for the children of the current element. The Channel and Item elements may have different names, depending on the type of channel. XML processors should check each child of the root element for a “current” child; if one is present, that element describes a channel. Similarly, the children of the “current” element are always Items, and the child of “icon” is always a dctype:Image, no matter what they’re called. XML processors should ignore other elements they do not recognize.

Items are identified by item URI, but the link URI indicates what page to download if the user wishes to view the item. Note that item URI does not actually need to lead to anything.

Naturally, applications which create data only for RDF-aware processors are free to use any RDF representation they choose.

Relation to RSS, TDL, and others

RDF Channel is a generalization of RSS based around the concept of a channel as a list of items. Because RDF Channel defines what a channel is very minimally (a collection of resources), many different applications can be built from it.

For example, if we declare rss:channel to be a subclass of Channel, rss:item to be a subclass of item, and rss:items a subproperty of current, we can interpret an RSS feed in terms of RDF Channel. (rss:title and rss:description are already defined as subproperties of dc:title and dc:description.) The only tricky part is rss:link, which is usually a URI given as a literal, rather than a reference. Also, RDF Channel does not have an equivalent for rss:textarea, but no one uses that anyway.

Similarly, we can declare tdl:Weblog a subclass of Channel, tdl:Post a subclass of Item, and tdl:currentPosts a subproperty of current. (See Thread Description Language for definitions of those terms.)

The possibilities are endless. For example, RDF Channel could be used to build a job listings format:

<job:Listing rdf:about="http://jobs.example.com/">
    <dc:title>Current jobs available at jobs.example.com</dc:title>
    <current rdf:parseType="Collection">
        <job:Posting rdf:about="http://jobs.example.com/job/41939">
            <dc:title>Experienced documentation writer</dc:title>
            <dcterm:issued>2002-10-22t10:00-04:00>/dcterm:issued>
            <job:title>Technical Writer</job:title>
            <job:category rdf:resource="http://jobs.example.org/category/82"/>
            <job:employer rdf:resource="http://jobs.example.org/org/9213"/>
        </job:Posting>
        <job:Posting rdf:about="http;//jobs.example.com/job/41935">
           ...
    </current>
</job:Listing>