Contents

• Overview of RDF
• RDF Resources at W3C
• RDF Specifications
  • RDF Model and Syntax Specification
  • RDF Schema Specification
  • Related W3C Documents
• General: News, Articles, Papers on RDF
• Software Tools for RDF
• Other RDF Resources

Overview of RDF

This RDF document currently provides information and references for both the Resource Description Framework (RDF) Model and Syntax Specification and the Resource Description Framework (RDF) Schema Specification. References are given for articles/papers, in addition to RDF software. A more complete RDF reference collection, in many respects, is "Dave Beckett's Resource Description Framework (RDF) Resource Guide."

"RDF (Resource Description Framework) is a framework for metadata; it provides interoperability between applications that exchange machine-understandable information on the Web. RDF emphasizes facilities to enable automated processing of Web resources. RDF metadata can be used in a variety of application areas; for example: in resource discovery to provide better search engine capabilities; in cataloging for describing the content and content relationships available at a particular Web site, page, or digital library; by intelligent software agents to facilitate knowledge sharing and exchange; in content rating; in describing collections of pages that represent a single logical 'document'; for describing intellectual property rights of Web pages, and in many others. RDF with digital signatures will be key to building the 'Web of Trust' for electronic commerce, collaboration, and other applications." [from the W3C FAQ document]

Resource Description Framework (RDF) "provides a more general treatment of metadata. RDF is a declarative language and provides a standard way for using XML to represent metadata in the form of statements about properties and relationships of items on the Web. Such items, known as resources, can be almost anything, provided it has a Web address. This means that you can associate metadata with a Web page, a graphic, an audio file, a movie clip, and so on. RDF provides a framework in which independent communities can develop vocabularies that suit their specific needs and share vocabularies with other communities. In order to share vocabularies, the meaning of the terms must be spelled out in detail. The descriptions of these vocabulary sets are called RDF Schemas. A schema defines the meaning, characteristics, and relationships of a set of properties, and this may include constraints on potential values and the inheritance of properties from other schemas. The RDF language allows each document containing metadata to clarify which vocabulary is being used by assigning each vocabulary a Web address. The schema specification language is a declarative representation language influenced by ideas from knowledge representation (e.g., semantic nets, frames, predicate logic) as well as database schema specification languages and graph data models. RDF uses the idea of the XML namespace to effectively allow RDF statements to reference a particular RDF vocabulary or 'schema'. [From the W3C Metadata Activity page]

The Resource Description Framework (RDF) is a specification governing the interoperability of applications in terms of metadata property sets. It is being developed under the authority of the W3C in the context of the W3C Metadata activity. The draft specifications from W3C confirm that "RDF will use XML as the transfer syntax in order to leverage other tools and code bases being built around XML..." The collaborative RDF effort is based upon several other metadata initiatives; the working group responsible for the draft is composed of "key industry players including DVL, Grif, IBM, KnowledgeCite, LANL, Microsoft, Netscape, Nokia, OCLC, Reuters, SoftQuad and University of Michigan." "RDF metadata can be used in a variety of application areas such as: (1) in resource discovery to provide better search engine capabilities; (2) in cataloging for describing the content and content relationships available at a particular Web site, page, or digital library; (3) by intelligent software agents to facilitate knowledge sharing and exchange; (4) in content rating for child protection and privacy protection; (5) in describing collections of pages that represent a single logical "document"; (6) for describing intellectual property rights of Web pages." [press release October 3, 1997]

"RDF is the result of a number of metadata communities (including Dublin Core, PICS, Digital Signatures) bringing together their needs to provide a robust and flexible architecture for supporting metadata on the Internet and WWW. RDF will use the new XML as its main carrier syntax." [from the DSTC page, where the Resource Description Framework is listed as a Resource Discovery Unit 'Special Project']

RDF Resources at W3C

• Resource Description Framework (RDF). W3C Main Page

• RDF FAQ Document, from W3C

• W3C Metadata Activity Statement. Explains W3C's plans for RDF and metadata in detail. Work on Metadata is part of W3C's Technology and Society Domain.

• RDF Interest Group. "The RDF Interest Group was established in August 1999 as an open forum for W3C Members and non-Members to discuss issues relating to W3C's Resource Description Framework." See the RDF IG Charter and the archives of the RDF-Interest mailing list ['www-rdf-interest@w3.org'].

• [August 30, 2002] "Resource Description Framework (RDF): Concepts and Abstract Data Model." Edited by Graham Klyne (Clearswift and Nine by Nine) and Jeremy Carroll (Hewlett Packard Labs). Series editor: Brian McBride (Hewlett Packard Labs). W3C Working Draft 29-August-2002. Version URL: http://www.w3.org/TR/2002/WD-rdf-concepts-20020829/. Latest version URL: http://www.w3.org/TR/rdf-concepts/. Produced by the W3C RDF Core Working Group as part of the W3C Semantic Web Activity. The Resource Description Framework (RDF) is a data format for representing metadata about Web resources, and other information. This document defines the abstract graph syntax on which RDF is based, and which serves to link its XML serialization to its formal semantics. It also describes some other technical aspects of RDF that do not fall under the topics of formal semantics, XML serialization syntax or RDF schema and vocabulary definitions (which are each covered by a separate document in this series). These include: discussion of design goals, meaning of RDF documents, key concepts, character normalization and handling of URI references... The normative documentation of RDF falls broadly into the following areas: (1) XML serialization syntax [RDF/XML Syntax Specification (Revised)]; (2) formal semantics [RDF Model Theory]; (3) RDF vocabulary definition language (RDF schema) [RDF Vocabulary Description Language 1.0: RDF Schema], and (4) this document, which covers the following: discussion of design goals, meaning of RDF documents, key concepts, abstract graph syntax, character normalization, and handling of URI references..."

• [September 12, 2001] RDF Test Cases. W3C Working Draft 12-September-2001. Version URL: . Latest Public Version URL: http://www.w3.org/TR/rdf-testcases/. Edited by Art Barstow (W3C) and Dave Beckett (ILRT, University of Bristol). The document describes the RDF Test Cases deliverable for the RDF Core Working Group as defined in the WG's Charter. It describes the test cases that will fullfill (when the test cases are completed) that deliverable but it does not contain the test cases themselves; the test cases are available at http://www.w3.org/2000/10/rdf-tests/rdfcore/. Background: "The W3C RDF Interest Group and other members of the RDF community have identified issues/ambiguities in the RDFMS Specification and the RDFSchema Candidate Recommendation. These issues have been collected and categorized in the RDF Issue Tracking document. The RDF Core Working Group uses this issue list to guide its work..."

• W3C 'www-rdf-logic@w3.org' mailing list, and archives. The list provides "a forum for technical discussion concerning the design of logic-based languages for use on the Web. W3C provides the www-rdf-logic forum as a home for detailed technical discussion of all approaches to the use of classical logic on the Web for the representation of data such as inference rules, ontologies, and complex schemata. The logic list, through association with the RDF Interest Group, also serves as a mechanism to provide input into W3C's Semantic Web activities, in particular relating to future directions for the Resource Description Framework."

• W3C 'www-rdf-specs@w3.org' mailing list, and archives

• "Introduction to RDF Metadata." By Ora Lassila. W3C NOTE 1997-11-13. NOTE-rdf-simple-intro-971113.html. [cache]

• W3C Contacts for RDF/Metadata Activity [2000-10-02]:

  • Ralph Swick, W3C Metadata Activity Leader
  • Eric Miller and Bob Schloss, RDF Model and Syntax Chairs emeritus
  • Eric Miller, RDF Schema Chair
  • David Singer, RDF Schema Chair emeritus
  • Dan Brickley, RDF Interest Group Chair

W3C RDF Specifications

[February 10, 2004]   W3C Recommendations: Resource Description Framework (RDF) and Web Ontology Language (OWL).    The World Wide Web Consortium has announced "final approval of two key Semantic Web technologies, the revised Resource Description Framework (RDF) and the Web Ontology Language (OWL). RDF and OWL are Semantic Web standards that provide a framework for asset management, enterprise integration and the sharing and reuse of data on the Web. These standard formats for data sharing span application, enterprise, and community boundaries, since different types of users can share the same information even if they don't share the same software." The Resource Description Framework (RDF) is a "language for representing information about resources in the World Wide Web. It is particularly intended for representing metadata about Web resources, such as the title, author, and modification date of a Web page, copyright and licensing information about a Web document, or the availability schedule for some shared resource. However, by generalizing the concept of a 'Web resource', RDF can also be used to represent information about things that can be identified on the Web, even when they cannot be directly retrieved on the Web. Examples include information about items available from on-line shopping facilities (e.g., information about specifications, prices, and availability), or the description of a Web user's preferences for information delivery." The W3C RDF Recommendation is presented six parts: Primer, Concepts, Syntax, Semantics, Vocabulary, and Test Cases. The OWL Web Ontology Language is "intended to be used when the information contained in documents needs to be processed by applications, as opposed to situations where the content only needs to be presented to humans. OWL can be used to explicitly represent the meaning of terms in vocabularies and the relationships between those terms. This representation of terms and their interrelationships is called an ontology. OWL has more facilities for expressing meaning and semantics than XML, RDF, and RDF-S, and thus OWL goes beyond these languages in its ability to represent machine interpretable content on the Web. OWL is a revision of the DAML+OIL web ontology language incorporating lessons learned from the design and application of DAML+OIL." W3C has published the OWL Recommendation in six documents: Use Cases, Overview, Guide, Language Reference, Test Cases, and Language Semantics and Abstract Syntax.

RDF Recommendations 2004-02:

• RDF Primer
• RDF Concepts and Abstract Syntax
• RDF/XML Syntax Specification (Revised)
• RDF Schema
• RDF Semantics
• RDF Test Cases
• See also: Resource Description Framework (RDF) Model and Syntax Specification. W3C Recommendation 22-February-1999.
• See also: Resource Description Framework (RDF) Schema Specification. W3C Proposed Recommendation 03-March-1999,

Short list [2002-11], substituting for subsequent material that needs editing:

• RDF Primer (W3C Working Draft 11 November 2002)
• RDF Semantics (W3C Working Draft 12 November 2002)
• RDF Vocabulary Description Language 1.0: RDF Schema (W3C Working Draft 12 November 2002)
• RDF/XML Syntax Specification - Revised (W3C Working Draft 8 November 2002)
• Resource Description Framework (RDF): Concepts and Abstract Syntax (W3C Working Draft 08 November 2002)
• RDF Test Cases (W3C Working Draft 12 November 2002).

General: News, Articles, Papers on RDF

• [March 29, 2005]   W3C Releases Survey of RDF/Topic Maps Interoperability Proposals Working Draft.    An initial public working draft from the W3C RDF/Topic Maps Interoperability Task Force (RDFTM) presents A Survey of RDF/Topic Maps Interoperability Proposals. This specification, initiated by the W3C Semantic Web Best Practices and Deployment Working Group (SWBPD) with the support of the ISO Topic Maps Committee (ISO/IEC JTC1/SC34), is part of the W3C Semantic Web Activity. The document "contains a survey of existing proposals for integrating RDF and Topic Maps data and is intended to be a starting point for establishing standard guidelines for RDF/Topic Maps interoperability." The W3C Resource Description Framework (RDF) is a model developed by the W3C for representing information about resources in the World Wide Web. Topic Maps, a project of ISO/IEC JTC1/SC34, is a standard for knowledge [representation and] integration, developed by ISO. The primary goal of this W3C endeavor is to "achieve interoperability between RDF and Topic Maps at the data level. This means that it should be possible to translate data from one form to the other without unacceptable loss of information or corruption of the semantics. It should also be possible to query the results of a translation in terms of the target model and it should be possible to share vocabularies across the two paradigms." According to the Background statement for the Working Draft, the RDF and Topic Maps specifications "were developed in parallel during the late 1990's within their separate organizations for what at first appeared to be very different purposes. The results, however, turned out to have a lot in common and this has led to calls for their unification." While unification of RDF and Topic Maps has to date "not been possible, for a variety of technical and political reasons, a number of attempts have been made to uncover the synergies between RDF and Topic Maps and to find ways of achieving interoperability at the data level. There is now widespread recognition within the respective user communities that achieving such interoperability is a matter of some urgency. Work has therefore been initiated by the Semantic Web Best Practices and Deployment Working Group of the W3C with the support of the ISO Topic Maps committee to address this issue." This Working Draft "consists of a summary and analysis of the major existing proposals for achieving data interoperability between RDF and Topic Maps. RDF-Schema and OWL are considered relevant to this work to the extent that the classes and properties they define are supportive of its goals. However, it is explicity not a goal of the current work to enable the general use of RDF Schema and OWL with Topic Maps, although this issue may be addressed later.

• [December 03, 2003] "Styling RDF Graphs with GSS." By Emmanuel Pietriga. From XML.com (December 03, 2003). ['Visualising RDF graphs is a hard problem, as they can quickly become unwieldy. This article introduces a solution in the form off GSS (Graph Style Sheets), an RDF vocabulary for describing rule-based style sheets used to modify the visual representation of RDF models represented as node-link diagrams.'] "RDF models describe web resources using subject-predicate-object triples. Combined together, these triples form a graph structure, which cannot be easily conveyed by textual syntaxes such as RDF/XML, Notation 3 or N-Triple because of their one-dimensional nature. Visual editors such as IsaViz and RDF Author represent models as editable node-link diagrams, making the graph structure easier to understand compared to textual serializations. However, visual representations are not fully satisfying and have their own problems: diagrams can quickly become big and over-cluttered, and some editing tasks can be more difficult to achieve when dealing with a visual representation of the model. The first version of IsaViz offered partial solutions to these problems, such as a zoomable user interface combined with enhanced navigation capabilities... GSS (Graph Style Sheets) is an RDF vocabulary for describing rule-based style sheets used to modify the visual representation of RDF models represented as node-link diagrams. Possible modifications include changing the visual aspect of nodes and links (color, shape or icon, font, etc.), but also hiding parts of the graph or changing the layout of some elements. GSS draws many of its instructions from existing W3C Recommendations, namely, CSS and SVG. GSS features a cascading mechanism; its transformation model is loosely based on that of XSLT... the graph stylesheet is made of a set of rules. The left-hand side of a rule is called the selector, while the right-hand side is called the styling instruction set. Given the set of rules defined in a stylesheet (or several cascading stylesheets), the program in charge of styling RDF models (called a GSS engine) walks the entire graph, including resources, literals, and properties, and evaluates relevant rules on them. If the selector of a rule matches the current node (or arc) in the graph, the corresponding set of styling instructions is applied to the node or arc. Conflicts between rules matching the same node or arc are resolved, first, by giving higher priority to rules in the stylesheet applied last, and, second, to the most specific selector if both are in the same stylesheet... GSS stylesheets can be combined together with ease thanks to the cascading mechanism and the RDF language's capability to merge models. What we need now are stylesheets for all widely-used vocabularies..."

• [July 22, 2003] "XML Watch: Tracking Provenance of RDF Data. RDF Tools Are Beginning to Come of Age." By Edd Dumbill (Editor and publisher, xmlhack.com). In IBM DeveloperWorks (July 21, 2003). ['When you start aggregating data from around the Web, keeping track of where it came from is vital. In this article, Edd Dumbill looks into the contexts feature of the Redland Resource Description Format (RDF) application framework and creates an RDF Site Summary (RSS) 1.0 aggregator as a demonstration.'] "A year ago, I wrote a couple articles for developerWorks about the Friend-of-a-Friend (FOAF) project. FOAF is an XML/RDF vocabulary used to describe -- in computer-readable form -- the sort of personal information that you might normally put on a home Web page, such as your name, instant messenger nicknames, place of work, and so on... I demonstrated FOAFbot, a community support agent I wrote that aggregates people's FOAF files and answers questions about them. FOAFbot has the ability to record who said what about whom... The idea behind FOAFbot is that if you can verify that a fact is recorded by several different people (whom you trust), you are more likely to believe it to be true. Here's another use for tracking provenance of such metadata. One of the major abuses of search engines early on in their history was meta tag spamming. Web sites would put false metadata into their pages to boost their search engine ranking... I won't go into detail on the various security and trust mechanisms that will prevent this sort of semantic vandalism, but I will focus on the foundation that will make them possible: tracking provenance... To demonstrate, I'll show you how to use a simple RSS 1.0 document as test data. Recently I set up a weblog site where I force my opinions on the unsuspecting public... Though RSS feeds of weblogs and other Internet sites are interesting from a browse-around, ego-surfing perspective, I believe the real value of a project like this is likely to be within the enterprise. Organizations are excellent at generating vast flows of time-sequenced data. To take a simple example, URIs are allotted for things like customers or projects, then RSS flows of activity could be generated and aggregated. Such aggregated data could then be easily sliced and diced for whoever was interested. For instance, administrators might wish to find out what each worker has been doing, project managers might want the last three status updates, higher-level management might want a snapshot view of the entire department, and so on. It is not hard to imagine how customer relationship management (CRM) might prove to be an area where tools of this sort would yield great benefits... The simple example demonstrated in this article only scratches the surface of provenance tracking with RDF. On the Web, where information comes from is just as important as the information itself. Provenance-tracking RDF tools are just beginning to emerge, and as they become more widely used they will no doubt become more sophisticated in their abilities. The Redland RDF application framework is a toolkit that's definitely worth further investigation. It has interfaces to your favorite scripting language; it runs on UNIX, Windows, and Mac OS X..."

• [April 21, 2003] "Thinking XML: Introducing N-Triples. A Simpler Serialization for RDF." By Uche Ogbuji (Principal Consultant, Fourthought, Inc). From IBM developerWorks, XML zone. April 8, 2003. ['RDF/XML isn't the only representation of an RDF model. The W3C developed N-Triples, a format for an RDF representation that is especially suited for test suites. Here, Uche Ogbuji introduces N-Triples using examples converted from RDF/XML.'] "In an earlier article, I used the heading "Repeat after me: There is no syntax". RDF's traditional XML syntax is often maligned, but luckily it is not what makes RDF tick, and the emergence of alternative serializations has always been inevitable. One problem with XML as a serialization syntax is that it is so flexible that it can be difficult to compare desired versus actual results in the process of automated testing. Whether in regression testing or conformance testing, it is often useful to try to normalize XML to some form so that simple text comparisons give meaningful results. The XML community developed XML canonical form for such purposes, and the W3C RDF working group required the same sort of form for RDF while it was developing RDF conformance test suites. One option is to define a canonical form of RDF/XML that matches any graphs, and then canonicalize the resulting XML according to the relevant W3C recommendation. Instead, I think the RDF working group chose the right course in developing a simple and strictly-defined textual format for RDF graphs. This format is named N-Triples, and is incorporated into the RDF Test Cases working draft. In this article I introduce N-Triples, using examples converted from RDF/XML... I do not cover a few nuances; for example, a very strict set of characters is allowed in the syntax, and you must be careful to escape any characters outside these ranges. Some characters (in URI references) must be escaped using URI conventions, and others use an N-Triples convention with a leading backslash. If you are writing code to read or write N-Triples, be sure to see the specification for these details. One of several efforts aimed at a simple triples-based representation for RDF includes N3, which is pretty popular and is the source of some of the ideas in N-Triples. But N-Triples has the advantage of being written into a formal specification, and because of its use in the standard RDF test cases, will probably be implemented by all RDF processors..."

• [April 17, 2003] "Intellidimension Application Shows Power of RDF." By Jim Rapoza. In eWEEK (April 17, 2003). "Intellidimension Inc.'s RDF Gateway 1.0 is one of the first applications to address the use of the Resource Description Framework standard, which makes it possible to have metadata interoperate across Web sites and enable everything from powerful search agents to extensive cross-site agent applications. RDF is also the core technology behind the World Wide Web Consortium's semantic Web project, whose goal is to build a Web where the meaning of Web content is understandable to machines. However, adoption of RDF has been slow, especially when compared with XML, on which RDF is based. This is where RDF Gateway, released last month, comes in by providing a powerful server-based system for creating, deploying and managing RDF applications. In tests, eWEEK Labs used RDF Gateway to build a wide variety of Web applications that incorporated and understood RDF, providing a level of content interactivity that would be the envy of most enterprise portals and Web services. RDF Gateway runs as an all-in-one Web server, application server and database, with the database designed to handle RDF content. This works well and makes the product easy to deploy, but we would prefer a more modular approach that would make it possible, for example, to use the database in conjunction with another Web server and application server... The sample applications that Intellidimension provides on its site were a great help in developing for RDF Gateway. We especially liked the sample portal package, which made it possible to build a powerful, interactive information management portal with a slew of user customization options. This portal also showed how well RDF Gateway can make use of RSS (RDF Site Summary), probably one of the most common uses of RDF on the Web today. RSS is used by many Web sites to create summaries of their site content that can be easily used for syndication. With this application, it became easy for users to create customizable news sites by combing RSS feeds from a variety of Web and internal sources..."

• [March 07, 2003] "The Social Meaning of RDF." By Kendall Grant Clark. From XML.com (March 05, 2003). ['The W3C is about to undertake a discussion of what the social meaning of RDF is -- what the real world import is of an RDF statement. Kendall Clark previews the debate and recent related discussion.'] "RDF is frequently described as a tool for representing knowledge, but therein lies a hornet's nest of deeply conceptual questions, better left undisturbed if you can help it. Sometimes, however, the hornet's nest has to be overturned because it is necessary to address the deep conceptual questions directly. The formal blessing of RDF specifications, especially 'RDF Concepts and Abstract Syntax', is a case in point. In what remains of this column, I review some of the vigorous debate surrounding one troublesome section of this document, section 4... there remain significant issues to be resolved before RDF Concepts progresses in the W3C recommendation process. There are at least two different kinds of difficulty. First, these issues (knowledge representation, the relation of formal and social systems, the meaning of meaning, and so on) are simply very difficult. If they were easy, we would have had something like RDF a long time ago, or at the least there would be even more unemployed philosophers and logicians around. Second, these issues cut across areas internal to the institutional politics of the W3C and its constitutents..." See W3C Social Meaning Discussion - Agenda.

• [March 04, 2003] "Tip: Use 'rdf:about' and 'rdf:ID' Effectively in RDF/XML. Minimize Confusion in Specifying Resources." By Uche Ogbuji (Principal Consultant, Fourthought, Inc). From IBM developerWorks, XML zone. February 2003. ['The combination of RDF and XML allows for several different approaches to specifying resources, and sometimes the rules for interpreting the syntax can be troublesome. In this tip, Uche Ogbuji uses examples to illustrate the various behaviors of the rdf:ID and rdf:about attributes, and shows how to use XML Base to control these behaviors.'] "This tip covers the RDF/XML syntax specification of 23-January-2003. You may want to review the latest W3C RDF primer if you are not familiar with recent RDF specifications. In RDF/XML, the subjects of statements are organized into node elements, which use attributes such as rdf:about and rdf:ID to set the subject for a collection of statements about that subject. Rules govern how the actual RDF subject URIs are constructed from these attributes, but there is plenty of room for confusion, and even instability, in the parsing results from environment to environment, if you're not careful. This tip offers some practices that can help minimize such errors and confusion... The behavior of rdf:about with respect to relative URIs also applies to similar attributes such as rdf:resource. The behavior of rdf:ID is similar to that of rdf:bagID and the like. Throughout your RDF/XML files, you should be acutely aware of any base URIs that are in effect so you can be sure you understand the process by which the RDF model is generated. As for choosing between rdf:ID and rdf:about, you will most likely want to use the former if you are describing a resource that doesn't really have a meaningful location outside the RDF file that describes it. Perhaps it is a local or convenience record, or even a proxy for an abstraction or real-world object (although I recommend you take great care describing such things in RDF as it leads to all sorts of metaphysical confusion; I have a practice of only using RDF to describe records that are meaningful to a computer). So rdf:about is usually the way to go when you are referring to a resource with a globally well-known identifier or location..." See "RDF/XML Syntax Specification (Revised)." W3C Working Draft 23-January-2003 and the "RDF Primer," W3C Working Draft 23-January-2003.

• [February 12, 2003] "Building Metadata Applications with RDF." By Bob DuCharme. From XML.com (February 12, 2003). ['The Python RDFlib library gives Bob DuCharme a "lightbulb moment" with RDF.'] "The real test of any technology's value is what kinds of tasks are easier with it than without it. If I hear about some new technology, I'm not going to learn it and use it unless it saves me some trouble. Well, being a bit of a geek, I might play with it a bit, but I'm going to lose interest if I don't eventually see tangible proof that it either makes new things possible or old things easier. I've played with RDF for a while and found some parts interesting and other parts a mess. During this time, I continued to wonder what tasks would be easier with RDF than without it. I came across some answers (for example, various xml-dev postings or some documentation on the Mozilla project), but they usually addressed the issue in fairly abstract terms. The first time I tried the RDFLib Python libraries, the lightbulb finally flashed on. RDFLib lets you generate, store, and query RDF triples without requiring you to ever deal directly with the dreaded RDF/XML syntax. And you can do all this with a minimal knowledge of Python..."

• [February 07, 2003] "BrownSauce: An RDF Browser." By Damian Steer. From XML.com (February 05, 2003). ['One of RDF's problems, as Damian Steer points, is that it's rather easier to produce than it is to consume. So Damian set out to produce the nearest thing he could to a generalized RDF browser that would make a decent job out of displaying arbitrary RDF information.'] "BrownSauce [a SourceForge Project] is an RDF browser. It attempts, armed with no more than a knowledge of RDF and RDF Schema, to present all RDF data as intelligibly as possible. RDF is biased in favor of the data producer. Consumers may have to deal with all, some, or none of the expected properties or classes, and they may have to be aware that entirely unknown properties and classes are possible and legitimate. BrownSauce is an attempt to deal with all that is thrown at it... BrownSauce attempts to improve on the triples approach. The problem is that such a display is too fine grained, but it has advantages: it will work with large documents or even sources where no single document is available (e.g., databases). So how to can an application find the obvious patterns in RDF data? RDF, unlike XML, has no mechanisms for expressing data structure; indeed, it is a semi-structured data format, so such information would only be a partial help. Having said that, the reader may be aware of RDF Schema. Don't be fooled by the name: RDF Schemas describe properties and classes, but cannot state that 'Houses have addresses'... When one looks at RDF data it is apparent that there are regular patterns. These are captured in BrownSauce using a simple rule: start at a node and work outward, passing over blank nodes... Currently BrownSauce can only browse documents. From the outset, however, the plan was to extend browsing to other sources such as databases with web interfaces. The code is in place and may well be added in the near future..."

• [December 03, 2002] "RDF Update." By Shelley Powers. From XML.com. November 27, 2002. ['RDF has recently seen several new draft specifications released by the W3C. Shelley Powers, author of O'Reilly's upcoming book on RDF, has read through the new specs and reports on their highlights.'] "The W3C working group tasked to update and clarify the RDF specification recently released six new working drafts. The group is collecting comments, concerns, and corrections, which will be incorporated into the documents. At the end of November [2002], in preparation for submitting the documents for review as Candidate Recommendations, the working group will begin its final review... Rather than signalling an increase in complexity of the RDF specification, the documents actually clarify it, primarily by separating its different aspects instead of keeping them bundled together in a confusing jumble of syntax, concept, and semantics. Additionally, two of the documents were written with very specific goals in mind: the Test Cases document aids RDF tool developers; the RDF Primer provides an introduction to RDF which is less formal than the specification itself... In this article I examine the purpose and scope of each document. I also highlight some of the significant changes between these working drafts and the original release of the RDF specifications... Note: the RDF documents include [1] RDF Primer (W3C Working Draft 11 November 2002); [2] RDF Semantics (W3C Working Draft 12 November 2002); [3] RDF Vocabulary Description Language 1.0: RDF Schema (W3C Working Draft 12 November 2002); [4] RDF/XML Syntax Specification - Revised (W3C Working Draft 8 November 2002); [5] Resource Description Framework (RDF): Concepts and Abstract Syntax (W3C Working Draft 08 November 2002); [6] RDF Test Cases (W3C Working Draft 12 November 2002). See the W3C Resource Description Framework (RDF) website.

• [November 22, 2002] "RPV: Triples Made Plain." By Kendall Grant Clark. From XML.com November 20, 2002. ['In the XML community over the past week, the debate over RDF rumbles on. As just about the oldest application of XML and Namespaces, the fact that RDF is still a source of debate four years later is testament to both its significance and its troubles. Kendall Grant Clark, custodian of the XML-Deviant column's watchful eye over the XML community, brings us the latest developments in the debate. Tim Bray has responded to the RDF discussion with a suggestion for a new RDF/XML syntax that aims to answer some of the criticisms of the existing format.'] "... If you don't like or understand or prefer RDF's XML serialization, find a way to avoid dealing with it directly. Using an RDF triplestore from a high-level language is one such way, while retaining some, perhaps all of the benefits of RDF's data model. So, my argument is a more focused variant of the suggestion Shelley Powers has been making repeatedly on XML-DEV lately: if you don't like or understand or prefer RDF, just don't use it. This seems fair enough. Most recent discussion of RDF, which has bubbled over the bounds of XML-DEV and moved out into the broader confines of the Web development community, has been by turns absurd and sublime. From foundational debates about whether RDF is complex, or fights over how to characterize its complexity, to awfully redundant discussions about whether its XML serialization is all that user-unfriendly, to meta-debates in which various sides jockey for position to see which side can be described as unfair or 'politically correct' (whatever that could possibly mean in this context) or dismissive or narrow-minded or high-handed -- and on and on. Yet the debate has also been productive at times, including Tim Bray's RPV proposal ['The RPV (Resource/Property/Value) Syntax for RDF']. Bray says his RPV proposal 'is an XML-based language for expressing RDF assertions ... designed to be entirely unambiguous and highly human-readable.' That two-part design goal is worth spending some time with insofar as it's emblematic of a good deal of the underlying debate over RDF. To say that an XML language is or should be 'entirely unambiguous' and 'highly human-readable' is to say that it should be as easily digestible by machines as by humans. It's that tension which runs all the way from XML to RDF. Further, Bray suggests that RDF has failed to gain traction because of this tension: his RPV proposal 'is motivated by a belief that RDF's problems are rooted at least in part in its syntax.' He elaborates on this point by saying, first, that RDF's XML serialization is 'scrambled and arcane,' preventing people from easily reading or writing it; second, that the XML serialization uses qualified names in a way that's not user-friendly and is in some conflict with the TAG's idea that significant resources be identified by URI; third, that there doesn't seem to be a general problem for metadata folks to think of things in terms of RDF's 3-tuples; fourth, that some alternatives to RDF-XML, like n3, suffer because, as non-XML, they can't get the network effect of ubiquitous XML support; and, fifth, that the idea of embedding RDF in XML languages, which seemed in the summer of 2000, both to Leigh Dodds and much of the rest of the XML development community, like a viable approach, 'has failed resoundingly in the marketplace'..."

• [November 22, 2002] "The RPV (Resource/Property/Value) Syntax for RDF." By Tim Bray. November 2002. ['The RPV (Resource/Property/Value) syntax is an XML-based language for expressing RDF assertions. It is designed to be entirely unambiguous and highly human-readable.'] "The Resource Description Framework (RDF) is designed to facilitate the interchange and processing of metadata concerning Resources (where the word Resource is used in its Web sense). RDF models metadata as 3-tuples which assert that some resource has some property (identified by URI) which has a value identified either by URI or given literally. The centrality of metadata in many classes of application, and the simplicity and elegance of RDF's data model would seem to make it something that has many obvious applications on the Web. Despite this, RDF has been slow to catch hold. The RPV language proposal is motivated by a belief that RDF's problems are rooted at least in part in its syntax. Specifically: (1) The syntax of RDF/XML is sufficiently scrambled and arcane that it is neither human-writeable nor human-readable. (2) The RDF/XML syntax makes heavy use of qnames that is neither intuitive to humans nor conforms particularly well to Web Architecture, which requires that everything significant be identified by URI. (3) People who care about metadata have no trouble thinking in terms of resource/property/value triples. (4) Alternatives like N3 that make the RDF triples evident in syntax suffer in comparison to the XML/RDF syntax because they lack XML's widely-deployed base of software, i18n facilities, and APIs. (5) The notion that you RDF can be mixed into XML transparently enough to be unobtrusive has failed resoundingly in the marketplace..." See John Cowan's summary: "Mini-review of Tim Bray's RPV syntax for RDF. This is mostly a remapping of a small subset of standard RDF/XML. It has the following features that RDF/XML has not: (1) Expresses property names as URIs rather than QNames; (2) String-valued property can have the string stored remotely, reachable by URL; (3) Incorporates xml:base; (4) Provides separate base attributes for resources, properties, and values..."

• [November 15, 2002] "RDF, What's It Good For?" By Kendall Grant Clark. From XML.com. November 13, 2002. ['Kendall Clark's been keeping an eye on the XML-DEV debate and the subject of the spec everyone loves to hate, RDF. Bob DuCharme and John Cowan's recent XML.com article on RDF spawned discussion about what RDF was actually good for.'] "The Resource Description Framework is still among the most interesting of W3C technologies. But it's got persistent troubles, including having had its reputation beaten up unfairly as a result of the many and often nasty fights about RSS. But, just like my eccentric old uncle, RDF is not entirely blameless. In a previous XML-Deviant article ('Go Tell It On the Mountain') I argued that RDF's trouble might have something to do with it having been the victim of poor technical evangelism. In some sense that's still true. Recently I googled for a comprehensive, up-to-date RDF tutorial, which proved as elusive as finding Uncle's dentures the morning after nickel beer night at the bingo hall. In fact, I was hard pressed to find an RDF tutorial which looked like it had been updated this year. And one which I did find simply listed 13 different ways to express the same basic set of assertions, which not only makes a terrible tutorial, but also exemplifies another of RDF's persistent troubles: its XML serialization... During the time I've tracked RDF in the XML community, I can't recall running across even one enthusiastic defender of RDF's XML serialization. Apparently everyone, or so it seems, thinks it's a nasty kludge at best. Now, I've been using RDF in some of my recent Python programming, using Daniel Krech's excellent rdflib -- which, as Andrew Kuchling reminded me, thanks to its new ZODB/ZEO storage layer, now does fully-distributed storage. One virtue of rdflib is that it shields me, the carefree application hacker, from having to deal with RDF's XML serialization. I never think about it or about its warts. I rarely even see it. Which is perfect. As long as, when I send the XML-serialized dump of my RDF triple store to someone else, they end up with the same graph of assertions, I'm happy. But everyone's needs are not as easy to satisfy..."

• [November 08, 2002] "Make Your XML RDF-Friendly." By Bob DuCharme and John Cowan. From XML.com. October 30, 2002. ['The describe how to structure XML documents so that they can be used by RDF processors. The authors explain: "as RDF interest and application development grows, there's an increasing payoff in keeping RDF concerns in mind along with the other best practices as you design document types".'] "Suppose you're designing an XML application or maybe just writing a DTD or schema. You've followed various best practices about element and attribute names, when to use elements versus attributes, and other design issues, because you want your XML to be useful in the widest variety of situations. As RDF interest and application development grows, there's an increasing payoff in keeping RDF concerns in mind along with the other best practices as you design document types. Your documents store information, and small tweaks to their structure can allow an RDF processor to see that information as subject-predicate-object triples, which it can make good use of. Making your documents more 'RDF-friendly' -- that is, more easily digestible by RDF applications -- broadens the range of applications that can use your documents, thereby increasing their value. A lot of XML RDF documents look like they were designed purely for RDF applications, but that's not always the case. The frequent verbosity of RDF XML, which often intimidates RDF beginners, is a by-product of the flexibility that makes RDF easy to incorporate into your existing XML. By observing eight guidelines when designing a DTD or schema, you can use this flexibility to help your documents work with RDF applications as well as non-RDF applications. Some of the guidelines are easy, while some involve making choices based on trade-offs. But knowing what the issues are gives you a better perspective on the best ways to model your data... As RDF tools become more widely available and easy to use, you'll have more resources available to do improved metadata management for your own data. Even if you're not ready to build serious RDF applications just yet, making more of your own data RDF-friendly will do more than widen the number of applications that can use it. For many people, the kinds of things that RDF is good at become clearer to them when used with data that is important to their business or important to them personally, such as an address or appointment file. Using RDF tools to play with your own data will help you understand the strong points of RDF and, perhaps, even the strong points of your own data better..." See W3C Resource Description Framework (RDF) website and Semantic Web Activity Statement.

• [May 17, 2002] "Go Tell It On the Mountain. [RDF Primer]". By Kendall Grant Clark. From XML.com. May 15, 2002. ['As part of the re-framing of the W3C's Resource Description Framework a primer has been produced to accompany the new RDF specifications. Kendall Clark reviews the new document.'] On RDF Primer, W3C Working Draft 26 April 2002. "... After languishing for a relatively long time, the next 12 to 18 months is a make or break time for RDF, as well as for the Semantic Web Activity, of which it is a crucial element. Despite the technical problems with RDF, the biggest impediment to its widespread use to date has been the failure of evangelism, not so much because it was done poorly, though there have been missteps, but, rather, because it was mostly not done at all. And so the arrival of a Primer among the work product of the RDF Core WG is a happy occasion. It offers those of us not serving on an RDF working group, but inclined to do formal or informal evangelization of RDF among our peers, a non-normative but still blessed and trusted ground upon which to base our efforts. As well, it offers curious, potential users a more easily accessible introduction to RDF, and that can only be a good thing. There is some sense in which there being an RDF primer is far more strategically valuable than the sort of primer it is. However, as with other introductory texts, which are often the only texts about a technology users ever read, there are certain principles it is hard to quarrel with. Among these are simplicity and concision. In what ways and to what extent these principles are met, as always, at least partially a subjective question. I for one think that the RDF Primer gets more things right than it gets wrong, but I'm also hopeful that future drafts grow increasingly simplified and concise..."

• [April 2002] "Ontology Storage and Querying." By Aimilia Magkanaraki, Grigoris Karvounarakis, Ta Tuan Anh, Vassilis Christophides, and Dimitris Plexousakis. Foundation for Research and Technology Hellas, Institute of Computer Science Information Systems Laboratory. Technical Report No 308. April 2002. 21 pages. Review of RDF tools and APIs. [*NB: "One of the conclusions drawn from this survey is that the majority of the query languages do not yet support the complete set of modeling constructs offered by the above standards. Furthermore, the frontiers between querying and inferring capabilities offered by these languages are not clear. In most cases, inference is limited to a recursive traversal of ontology class/property hierarchies as well as of data paths involving transitive properties. We believe that the target functionality of the proposed query languages still has to be justified with respect to real large-scale Semantic Web applications."] "The necessity for ontology building, annotating, integrating and learning tools is uncontested. However, the sole representation of knowledge and information is not enough. Human information consumers and web agents have to use and query ontologies and the resources committed to them, thus the need for ontology storage and querying tools arises. However, the context of storing and querying knowledge has changed due to the wide acceptance and use of the Web as a platform for communicating knowledge. New languages for querying (meta)data based on web standards (e.g., XML, RDF, Topic Maps) have emerged to enable the acquisition of knowledge from dispersed information sources, while the traditional database storage techniques have been adapted to deal with the peculiarities of the (semi)structured data on the web. The purpose of this chapter is to briefly present and evaluate a set of query languages and associated tools for ontology/resource storage and querying aiming to support large-scale Semantic Web applications, the next evolution step of the Web. This list of languages and tools is by no means complete and the tools presented are indicative of the tendency to provide full storage and query support to web-based ontology/metadata standards, such as RDF, RDFS, Topic Maps, DAML+OIL or the forthcoming Web Ontology Language. Our work in this chapter focuses on the evaluation of querying languages designed for Semantic Web related knowledge representation formalisms rather than general-purpose querying languages (e.g., SQL, Datalog, F-logic). Although it has to be proven in practice, RDF-enabled search technologies have the potential to provide a significant improvement over the current keyword-based engines or theme navigation search, especially when it comes to conceptual browsing and querying. Furthermore, this orientation facilitates the comparison of querying languages and tools, since it provides a common reference base. It should be stressed that our comparison of ontology query languages and tools does not rely on performance figures, since these would require extensive comparative experiments, which go beyond the scope of this work. On the contrary, we present an overview of general system features and query language expressiveness, while providing the interested reader with useful references to additional informative material..." [cache]

• [April 06, 2002] "Managing structured Web service metadata. The realities of managing Web service metadata." By Uche Ogbuji (Principal Consultant, Fourthought, Inc.). From IBM developerWorks, Web services. April 2002. ['This article builds on an earlier developerWorks article on using the Resource Description Framework (RDF) to enhance WSDL, and related to a recent article on using SOAP with RDF. Uche Ogbuji looks at how updates in WSDL affect the techniques presented earlier, and draws on the significant discussion of RDF and Web services description to show how developers can use both to their advantage.'] "About a year and a half ago, I took a close look of how the then just announced Web Services Description Language (WSDL) could benefit from interacting with Web metadata format, RDF, either at the standards level, or at the level of individual developer effort. Since then, there has been a huge amount of activity in the Web services community and in the RDF (and Semantic web) community. Some of this has been very good, as dialog between these groups has taken root, and the technologies put forth by both groups have been improved. Some has also been bad, as the press has somehow conjured up a fantastical struggle between Web services camps and Semantic Web camps at the W3C, fighting for the resources of the consortium. All these developments are a great insight into the development and interaction of next-generation technologies, but in this article, I shall distill the most important developments of interest to developers... The recent RDF model theory and RDF/XML syntax specifications motivate some changes to the approach I have taken for mapping from WSDL to RDF. Other factors have also weighed in. In particular, Eric Prud'hommeaux has worked to improve on my approach by trying to make a mapping of the underlying intent behind the WSDL elements, rather than my own mechanical approach to the mapping. Certainly such a mapping would be more useful for general RDF integration, and one hopes that it is such a rich mapping that it will be accepted by the Web services description working group. I, however, also had a particular aim in my own approach: to provide a mapping straightforward enough to be palatable for non-RDF-types, and as close as possible to an identity transform from XML. With the increasing cooperation between the Web services and RDF camps, such a mechanical mapping is no longer a great necessity, so I shall look a bit more at the big picture for developers... developments in Web services and RDF provide not only richer tools for developer looking to take advantage of both, but a greater spirit of cooperation between the two efforts. The RDF query of WSDL metadata that I demonstrated can easily enough be duplicated using SQL queries, or API calls against some data binding of WSDL, but the benefit of using RDF is that one can then mix WSDL with other important RDF-based metadata, including content description and syndication formats (for example, Prism and RSS), privacy profiles (for example, P3P), and other emerging RDF applications. The more generic the management of Web services information, the more readily productivity output can be enhanced by improved integration..."

• [March 21, 2002]   W3C RDF Core Working Group Publishes RDF Primer Working Draft.    The W3C RDF Core Working Group has produced an initial public working draft RDF Primer. The Resource Description Framework (RDF) is a general-purpose language for representing information in the World Wide Web. It is particularly intended for representing metadata about Web resources, such as the title, author, and modification date of a Web page, the copyright and syndication information about a Web document, the availability schedule for some shared resource, or the description of a Web user's preferences for information delivery. RDF provides a common framework for expressing this information in such a way that it can be exchanged between applications without loss of meaning. Since it is a common framework, application designers can leverage the availability of common RDF parsers and processing tools. Exchanging information between different applications means that the information may be made available to applications other than those for which it was originally created. This Primer is designed to provide the reader the basic fundamentals required to effectively use RDF in their particular applications." [Full context]

• [March 11, 2002] "Using RDF with SOAP. Beyond Remote Procedure Calls." By Uche Ogbuji (Principal Consultant, Fourthought, Inc.). From IBM developerWorks, Web services. February 2002. ['This article examines ways that SOAP can be used to communicate information in RDF models. It discusses ways of translating the fundamental data in RDF models to the SOAP encoding for PC-like exchange, or for directly passing parts of the model in RDF/XML serialized form.'] "SOAP is a transport protocol for carrying XML payloads over lower level Internet protocols. Specifications of the transport prior to 1.2 built in a suggested encoding of XML that is geared towards the serialization of programming language constructs. Such encodings are the staple of what is known as remote procedure call (RPC) systems, which have the common aim of making requests to remote computers look just like local procedure invokations. Other examples of RPC encodings are External Data Representation (XDR), from 'classic' RPC (and defined in RFC 1014), and Common Data Representation (CDR) from CORBA. As a result of bundling an encoding with such relatives, SOAP took on a decidedly application-programming feel, and its usefulness for general data exchange seemed suspect. These early flavors of SOAP generated much controversy. Firstly, mixing transport and data encoding specifications seems to be a very messy approach to communications, and seems to fly in the face of layered protocols that have been the practice in networking for decades. After all, the specification for HTML mark-up is not embedded into the HTTP specification. Secondly, choosing an RPC-like encoding for pre-eminence puts SOAP in an odd spot; it has little more expressive power than pre-XML RPC mechanisms, yet it is practically guaranteed to be less efficient because of XML's verbosity and the more generic architectures of HTTP, SMTP, and the like. It would seem that the only advantage SOAP brought as a next-generation RPC was to unify the Microsoft and CORBA camps; this is important, but certainly not what SOAP appeared to be promising. One important down-side consequence of SOAP-as-RPC is that such a system is completely unsuitable for the next-generation-EDI ambitions of Web services in general. If Web services are to become the new way businesses communicate over networks, they would seem to need a transport mechanism that communicates at the level of business and legal requests, rather than at the level of programming language APIs. And surely enough, the ebXML initiative, whose ambition is to use XML to craft a system for international electronic business communication, originally balked at using SOAP, as did a few other influential organizations... There are other approaches and ideas when it comes to how SOAP and RDF can inter-operate, and indeed it is a topic of constant interest as RDF users discover Web services and vice versa... Certainly more generic systems for serializing XML-based data will only enrich the world Web services." Also in PDF format.

• [January 11, 2002] "RDF Declarative Description (RDD): A Language for Metadata." By Chutiporn Anutariya, Vilas Wuwongse, Kiyoshi Akama, and Ekawit Nantajeewarawat. In Journal of Digital Information [ISSN: 1368-7506](January 2002). Metadata: Papers from the Dublin Core 2001 Conference. "RDF Declarative Description (RDD) is a metadata modeling language which extends RDF(S) expressiveness by provision of generic means for succinct and uniform representation of metadata, their relationships, rules and axioms. Through its expressive mechanism, RDD can directly represent all RDF-based languages such as OIL and DAML-family markup languages (e.g., DAML+OIL and DAML-S), and hence allows their intended meanings to be determined directly without employment of other formalisms. Therefore, RDD readily enables interchangeability, interoperability as well as integrability of metadata applications, developed independently by different communities and exploiting different schemas and languages. Moreover, RDD is also equipped with computation and query-processing mechanisms." Full article available in PDF format. [cache]

• [January 04, 2002] "RQL: A Declarative Query Language for RDF." By Greg Karvounarakis, Vassilis Christophides, and Dimitris Plexousakis (Institute of Computer Science, FORTH; Heraklion, Greece). In D-Lib Magazine Volume 7 Number 12 (December 2001). ISSN: 1082-9873. "In the next evolution step of the Web, termed the Semantic Web, vast amounts of information resources (i.e., data, documents, programs) will be made available along with various kinds of descriptive information (i.e., metadata). This evolution opens new perspectives for Digital Libraries (DLs). Community Web Portals, E-Marketplaces, etc. can be viewed as the next generation of DLs in the Semantic Web era. Better knowledge about the meaning, usage, accessibility or quality of web resources will considerably facilitate automated processing of available Web content/services. The Resource Description Framework (RDF), enables the creation and exchange of resource metadata as any other Web data. To interpret metadata within or across user communities, RDF allows the definition of appropriate schema vocabularies (RDFS). The most distinctive feature of the RDF model is its ability to superimpose several descriptions for the same Web resources in a variety of application contexts (e.g., advertisements, recommendations, copyrights, content ratings, push channels, etc.), using different DL schemas (many of which are already expressed in RDF/RDFS. See examples. Yet, declarative languages for smoothly querying both RDF resource descriptions and related schemas, are still missing... This ability is particularly useful for next generation DLs that require the management of voluminous RDF description bases, and can provide the foundation for semantic interoperability between DLs. For instance, in knowledge-intensive Web Portals, various information resources such as sites, articles, etc. are aggregated and classified under large hierarchies of thematic categories or topics. These descriptions are exploited by push channels aiming at personalizing Portal access (e.g., on a specific theme), using standards like the RDF Site Summary... Motivated by the above issues, we have designed RQL, a declarative query language for RDF descriptions and schemas. RQL is a typed language, following a functional approach (as in ODMG OQL or W3C XQuery). RQL relies on a formal graph model (as opposed to other triple-based RDF query languages) that captures the RDF modeling primitives and permits the interpretation of superimposed resource descriptions by means of one or more schemas..."

• [January 04, 2002] "Doubt Cast Over Web Standard's Ownership." By Margaret Kane. In CNet News.com (January 3, 2002). "A Canadian company is claiming that a popular Web technology infringes on a patent it owns. The technology in question, Resource Description Framework, is based on Extensible Markup Language (XML) and allows programmers to write software to access Web resources, such as Web page content, music files and digital photos. The RDF standard has been endorsed by the World Wide Web Consortium, which evaluates and recommends standards for Web technologies. Vancouver-based UFIL Unified Data Technologies, a private company, claims that it owns U.S. patent 5,684,985, a "method and apparatus utilizing bond identifiers executed upon accessing of an endo-dynamic information node." The patent was awarded in November 1997. UFIL is working with Toronto-based Patent Enforcement and Royalties Ltd. (PEARL) to enforce the claims. According to press releases on PEARL's Web site, the companies believe as many as 45 companies may be infringing on the patents... The patent may also infringe on the RDF Site Summary standard, a way to describe Web content that's written in something other than HTML. RSS lets Web sites exchange information about Web site content and e-commerce data, for instance. RSS was originally developed by Netscape Communications, now owned by AOL Time Warner. Netscape's Mozilla browser uses the technology, as do other programs. Daniel Weitzner, technology and society domain leader at the W3C, said the consortium has not been approached directly regarding the patent issue..." See "Resource Description Framework (RDF)" and "RDF Site Summary (RSS)."

• [September 28, 2001] "RDF/Topic Maps: late/lazy reification vs. early/preemptive reification." By Steven R. Newcomb. Posting 2001-09-27. "For me, at least, the shortest, most compelling and cogent demonstration of a certain critical difference between Topic Maps and RDF was Michael Sperberg-McQueen's wrap-up keynote at the Extreme Markup Languages Conference (www.extrememarkup.com) last August. Michael brought colored ribbons and other paraphernalia to the podium, in order to illustrate his words... In the past, I myself have considered RDF as the competitor of Topic Maps. Happily, I was wrong -- at least in fundamental technical terms. Indeed, I now believe that if there were no RDF, the Topic Maps camp would have to invent something like it in order to make the Maps paradigm predictably comprehensible by the programmers who are pioneering the development of the Internet. There are other interesting comparisons to be made between RDF and Topic Maps, but ever since Michael's demonstration of the difference between early vs. late (preemptive vs. lazy) reification, I have been meaning to document both the difference and the demonstration..." See also "(XML) Topic Maps."

• [August 24, 2001] "On the Integration of Topic Maps and RDF Data." By Martin Lacher and Stefan Decker. 14 pages. Paper presented "on the integration of Topic Maps and RDF" at the August 2001 'Semantic Web Workshop' at Stanford. ['We provide a way to make Topic Map sources RDF-queriable by exchanging one layer in a layered data model stack. The exchanged layer is the layer on which both are represented as a graph; we use TMPM4 as a Topic Map graph representation. Our approach complies with what Graham Moore has termed in his XML Europe paper "modeling the model".'] "Topic Maps and RDF are two independently developed paradigms and standards for the representation, interchange, and exploitation of model-based data on the web. Each paradigm has established its own user communities. Each of the standards allows data to be represented as a graph with nodes and labeled arcs which can be serialized in one or more XML- or SGML-based syntaxes. However, the two data models have significant conceptual differences. A central goal of both paradigms is to define an interchangeable format for the exchange of knowledge on the Web. In order to prevent a partition of the Web into collections of incompatible resources, it is reasonable to seek ways for integration of Topic Maps with RDF. A first step is made by representing Topic Map information as RDF information and thus allowing Topic Map information to be queried by an RDF-aware infrastructure. To achieve this goal, we map a Topic Map graph model to the RDF graph model. All information from the Topic Map is preserved, such that the mapping is reversible. The mapping is performed by modeling the graph features of a Topic Map graph model with an RDF graph. The result of the mapping is an RDF-based internal representation of Topic Maps data that can be queried as an RDF source by an RDF-aware query processor... Interoperability is of greatest importance for the future Semantic Web. We suggested a way to achieve interoperability between Topic Maps and RDF, which enables the joint querying of RDF and Topic Maps information sources. Our work builds on existing work on general approaches for the integration of model based information resources. In contrast to those general approaches we showed a detailed mapping specifically from XTM Topic Maps to RDF. We achieved this by adopting an internal graph representation for Topic Maps, which has been published as part of one of the processing models for Topic Maps. We perform a graph transformation to generate an RDF graph from the Topic Map graph representation. The Topic Map source can now be queried with an RDF query language together with RDF information sources. We see this as a first step towards the integration of the many heterogeneous information sources available on the Web today and in the future." [cache]

• [July 17, 2001]   Proposal for Basic Semantic Web Language (BSWL).    Sean B. Palmer has announced a new proposal for a stripped down RDF-in-XML syntax called "BSWL" or the "Basic Semantic Web Language." The abstract syntax of this proposed language "is indeed very simple, consisting only of a set of three elements and a handful of attributes. The elements are: (1) <t> , denoting a triple; (2) <po>, denoting a predicate an object pair; (3) and <o>, denoting an object. Each of these elements has a range of attributes that associate a URI with a particular part of the content..." The proposed syntax features advantages over RDF M&S [Resource Description Framework (RDF) Model and Syntax Specification], including: "(1) Simpler syntax - no typed or anonymous nodes, allows one to form triples simply by nesting QNames; (2) Has a special syntax for referring to XML QNames; (3) Forces you to use xml:lang as part of the model, so it isn't lost; (4) Allows you to nest triples so that the subject of the former triple becomes the object of the latter triple; (5) Is possible to convert back into RDF M&S, and vice versa -- once RDF Core decide what to do about anonymous nodes; (6) Files using abbreviated BSWL tend to be shorter than RDF M&S." [Full context]

• [July 13, 2001] "Matching RDF Graphs." By Jeremy Carroll (HP Labs). July 13, 2001 (draft). "The Resource Description Framework (RDF) describes graphs of statements about resources. This paper explores the equality of two RDF graphs in light of graph isomorphism literature. We consider anonymous resources as unlabelled vertices in a graph, and show that the standard graph isomorphism algorithms, developed in the 1970s, can be used effectively for comparing RDF graphs..." [Post to 'www-rdf-interest@w3.org': "One of the improvements in Jena-1-1-0 [http://www-uk.hpl.hp.com/people/bwm/rdf/jena/] is a matching algorithm that can tell if two models are the same. The algorithm aligns the anonymous resources; so that two files, identical except for the order of statements will compare equal. I've written up the algorithm used... It's based on a standard algorithm from graph theory. It could also be useful for deeper notions of equivalence (e.g. after we have decided that certain pairs of URI's actually refer to the same resource). Any feedback, including stuff like typos and spelling errors, as well as more profound comments, would be welcome. I plan to take the doc to a second final version in three weeks time, when I will post a technical report number and a non-transitory URL..." [cache]

• [July 05, 2001] "Basic XML and RDF Techniques for Knowledge Management. Part 1: Generate RDF using XSLT. [Thinking XML #4.]" By Uche Ogbuji (CEO and principal consultant, Fourthought, Inc.). From IBM developerWorks. July 2001. ['I've started a series in my column about working with RDF in an XML system. I use an issue tracker as my example: hopefully one that will soon be the live tracker of RIL, 4Suite, etc... Columnist Uche Ogbuji begins his practical exploration of knowledge management with XML by illustrating techniques for populating Resource Description Framework (RDF) models with data from existing XML formats. As shown in the three code listings, RDF can be used as a companion to customized XML, not just as a canonical representation for certain types of data. This column, with code samples included, demonstrates how easy it can be to jump-start knowledge management with RDF even relatively late in the development game.'] "Although Resource Description Framework (RDF) was designed by the W3C as a general metadata modeling facility, it offers many features that make it an ideal companion to XML data. In many emerging XML applications, the knowledge encapsulated in the application throughout its lifetime is stored in XML documents in a database or repository. The basis of RDF's strength as a knowledge-management tool is that it allows you to organize, interrelate, classify, and annotate this knowledge, thereby increasing the aggregate value of the stored data. RDF has a reputation for complexity that is belied by the simplicity of adding RDF support to XML-based applications. This article begins an exploration of the symbiosis between RDF and XML. I'll demonstrate how to use XSLT to generate RDF from XML... In this column I have presented a simple example of the use of XSLT to extract RDF from XML instances. As more and more XML-based applications come into use, such techniques are useful in expanding applications with knowledge-management features. The next installment will continue with the issue tracker example, demonstrating batch processing of the issue documents and some open-source tools useful for such processing." Article also available in PDF format.

• [June 20, 2001] "Simplified XML Syntax for RDF." By Jonathan Borden (Tufts University School of Medicine, The Open Healthcare Group). June 17, 2001 or later. "A simplified XML syntax for RDF is proposed. Its major differences with RDF 1.0 are: (1) namespace = http://www.openhealth.org/RDF/RDFSurfaceSyntax; (2) defined as tree regular expression; (3) attribute aboutQ="ex:name" accepts QName as value indicating subject; (4) attribute resourceQ="ex:value" accepts QName as value indicating object; (5) rdf:parseType="Resource" is default; (6) The subject or object of a statement may be either a URI reference, a qualified name, a quantified variable, another statement or a collection of statements; (7) ?x defines a quantified variable. XML Syntax: The XML syntax for RDF 1.0 can be described in terms of a tree regular expression. This form can be thought of as expressing constraints on the XML Infoset which arises when parsing an RDF document. The advantage of expressing the syntax in this form over EBNF, is that a tree regular expression (e.g., RELAXNG/TREX schema http://relaxng.org) already takes into account the rules of XML syntax + XML namespaces, e.g., correctly handles namespace prefixes, empty elements, mixed content, whitespace, attribute ordering etc. Such schemata are also described as 'hedge regular expressions' or 'hedge automata' [http://www.oasis-open.org/cover/hedgeAutomata.html]. The tree regular expression schema for RDF 1.0 is available [online]. This schema handles several proposed updates such as the requirement that the "rdf:about" and "rdf:ID" attributes be prefixed/qualified. A tree regular expression for the proposed syntax is available [online]..." See: "RELAX NG."

• [June 20, 2001] "Making RDF Syntax Clear. Proposal of a DTD and minor syntax enhancement to RDF, to overcome many of the current practical difficulties." By Rick Jelliffe (Topologi Pty. Ltd.) 2001-06-20. "The current RDF Recommendation is almost impossible to implement because the discipline of a DTD was not used. Consequently, RDF implementations lack exchangability, and most people coming to the RDF Spec (from outside the 'RDF Community') expecting clear description of syntax must go away disappointed/ Furthermore, the advent of RDFS raises compatability issues, in that certain elements are used in RDFS, but are only general names in RDF. This proposal suggests the the situation could be improved by: [1] creating a normative DTD for RDF; [2] state clearly that this DTD (and DTDs that use it) embodies the RDF exchange current RDF exchange XML; [3] reconciles the use of namespaces in RDF with XML Schemas; [4] clarifies RDF's current syntax with standard concepts such as "architectures". I propose that this DTD should be included as a normative part of the RDF specification, and the BNF sections removed or reworded to fit in with it. From the 2001-06-20 posting to 'www-rdf-interest@w3.org': "I have posted to the RDF comments list a proposal for clarifying RDF syntax. This proposal features a new DTD, used to map between RDF documents and a notional XML Schemas schema using xsi:type. I have been working through RDF specifications and examples again recently, and I am even more convinced than ever that getting the basic discipline of the transfer syntax clear is a prerequisite for RDF becoming useful..."

• [May 24, 2001] "Using the Jena API to Process RDF. [Tutorial.] By Joe Verzulli. From XML.com. May 23, 2001. ['Jena is a freely-available Java API for processing RDF. This article provides an introduction to the API and its implementation.'] "There has been growing interest in the Resource Description Framework (RDF) and a number of tools and libraries have been developed for processing it. This article describes one such library, Jena, a Java API for processing RDF. It is also the name of an open source implementation of the API.'] XML is very flexible and allows information to be encoded in many different ways. If meaningful tag names are used it is relatively easy for a person to determine the intended interpretation of an XML string. However, it is difficult for programs to determine the intended interpretation since programs don't understand English tag names. DTDs and XML Schemas don't really help in this regard. They just allow a program to verify that XML strings conform to some set of rules. RDF is a model and XML syntax for representing information in a way that allows programs to understand the intended meaning. It's built on the concept of a statement, a triple of the form {predicate, subject, object}. The interpretation of a triple is that <subject> has a property <predicate> whose value is <object>... RDF requires that different kinds of semantic information (e.g., subjects, properties, and values) be placed in prescribed locations in XML. Programs that read an XML encoding of RDF can then tell whether a particular element or attribute refers to a subject, a property, or the value of a property. Jena was developed by Brian McBride of Hewlett-Packard and is derived from earlier work on the SiRPAC API. Jena allows one to parse, create, and search RDF models. Jena defines a number of interfaces for accessing and manipulating RDF statements..." [Website description: "Jena is an experimental java API for manipulating RDF models. Its features include: (1)statement centric methods for manipulating an RDF model as a set of RDF triples (2) resource centric methods for manipulating an RDF model as a set of resources with properties (3) cascading method calls for more convenient programming (4) built in support for RDF containers - bag, alt and seq (5) enhanced resources - the application can extend the behaviour of resources (6) mulptiple implementations (7) integrated parser (David Megginson's RDFFilter). An alpha quality implementation is available for download."]

• [May 23, 2001] "RDF and TopicMaps: An Exercise in Convergence." By Graham Moore (Vice President Research & Development, Empolis GmbH). Paper for XML Europe 2001 Berlin. 2001-05-24. ['This paper presents: (1) a way in which RDF can be used to model topicmaps and vice versa; (2) the issues that arise when performing a model to model mapping; (3) some proposals for changes to XTM to enable semantic interchange of the two standards. I am presenting this paper on Thursday at XML Europe if anyone is around and interested. I don't think this is the complete solution to the integration issue. However, I think that this paper could help focus some of the discussions.'] "There has long been a sense in the semantic web community that there is a synergy between the work of ISO and TopicMaps.org on TopicMaps and that of the W3C on RDF. This paper looks at why and how we can bring these models together to provide a harmonised platform on which to build the semantic web. The reasoning behind bringing together these two standards is in the fact that both models are intent on describing relationships between entities with identity. The question we look to answer in this paper is 'Is the nature of the relationships and the identified entities the same'. If we can show this to be true then we will be able to have a common model that can be accessed as a TopicMap or as a RDF Model. To make this clearer, if we have a knowledge tool X we would expect to be able to import some XTM syntax, some RDF syntax and then run either a RDF or TMQL query in the space of tool X and expect sensible results back across the harmonised model. In order to achieve this aim we need to show a model to model mapping between the two standards. We present the TopicMap model, the RDF model, a discussion on modelling versus mappings and then a proposed mapping between the two. As part of the mapping we make suggestions as to the changes that could be made to better support interoperation and finally we conclude and provide an insight into future work... we define a clear goal that we should be able to run a TMQL query against an RDF model and get 'expected results' i.e., those that would be gained from running a query against the equivalent TopicMap. To make this possible we need to make the models map rather than using the models to describe each other. The key difference in these approaches is that one provides a mapping that is semantic, the other uses each standard as a tool for describing other models. It is interesting that both models are flexible enough and general enough to allow each to be modelled using the other... While we found there was a useful mapping that could be performed it was felt that some additions to the TopicMap model -- Templates and Arcs would enable two way transition from RDF to TopicMaps and vice versa. We conclude that making some non-regressive enhancements to TopicMaps would enable a useful degree of convergence between TopicMaps and RDF, creating a single common semantic space in which to define the semantic web." [cache]

• [April 27, 2001] "An Introduction to Prolog and RDF." By Bijan Parsia. From XML.com. April 25, 2001. ['In the first of a series on creating Semantic Web applications with Prolog, Bijan Parsia introduces Prolog and its use in processing RDF.'] "Many Semantic Web advocates have gone out of their way to disassociate their visions and projects from the Artificial Intelligence moniker. No surprise, since the AI label has been the kiss of, if not death, at least scorn, since Lisp machines were frozen out of the marketplace during the great 'AI winter' of the mid-1980s. Lisp still suffers from its association with the AI label, though it does well by being connected with the actual technologies. However, it is a curious phenomenon that the AI label tends to get dropped once the problem AI researchers were studying becomes tractable to some degree and yields practical systems. Voice recognition and text-to-speech, expert systems, machine vision, text summarizers, and theorem provers are just a few examples of classic AI tech that has become part of the standard bag of tricks. The AI label tends to mark things which aren't yet implemented in a generally useful manner, often because hardware or general practices haven't yet caught up. That seems to describe the Semantic Web pretty well. I'm going to do a little down-to-earth exploration of RDF, a core Semantic Web technology, using a classic AI programming language, Prolog, plus some standard AI techniques and technologies... The root RDF data model is deliberately very minimal and, as with XML, that minimalism is intended to make things easier for programs. One consequence of that minimalism, when coupled with other machine-friendly design tropes, is that though 'human readable', RDF is not generally very human writable (although the Notation3 syntax tries to improve things.) Furthermore, while RDF's data model is specified, the processing model isn't (deliberately), so one should expect a wide variety of processors, each working in its own way, depending on a variety of constraints and desiderata. Standard Prolog provides a rich processing model which naturally subsumes RDF data. Deriving RDF triples from Prolog predicates, and then the reverse, can deepen our understanding of both. Furthermore, there is a lot of experience implementing a variety of alternative processing models (both forward and backward chaining systems, for example) in Prolog -- from the experimental toy, through the serious research project, to the industrially deployed, large-scale production system level. Furthermore, Prolog's roots in symbolic processing and language manipulation support a wide array of mechanisms for building expressive notations and languages for knowledge management, which serve well for hiding the less friendly aspects of RDF."

• [April 11, 2001] "The Semantic Web. A new form of Web content that is meaningful to computers will unleash a revolution of new possibilities." By Tim Berners-Lee, James Hendler and Ora Lassila. In Scientific American (May, 2001). "Most of the Web's content today is designed for humans to read, not for computer programs to manipulate meaningfully. Computers can adeptly parse Web pages for layout and routine processing -- here a header, there a link to another page -- but in general, computers have no reliable way to process the semantics: this is the home page of the Hartman and Strauss Physio Clinic, this link goes to Dr. Hartman's curriculum vitae. The Semantic Web will bring structure to the meaningful content of Web pages, creating an environment where software agents roaming from page to page can readily carry out sophisticated tasks for users. Such an agent coming to the clinic's Web page will know not just that the page has keywords such as "treatment, medicine, physical, therapy" (as might be encoded today) but also that Dr. Hartman works at this clinic on Mondays, Wednesdays and Fridays and that the script takes a date range in yyyy-mm-dd format and returns appointment times. And it will 'know' all this without needing artificial intelligence on the scale of 2001's Hal or Star Wars's C-3PO. Instead these semantics were encoded into the Web page when the clinic's office manager (who never took Comp Sci 101) massaged it into shape using off-the-shelf software for writing Semantic Web pages along with resources listed on the Physical Therapy Association's site. The Semantic Web is not a separate Web but an extension of the current one, in which information is given well-defined meaning, better enabling computers and people to work in cooperation. The first steps in weaving the Semantic Web into the structure of the existing Web are already under way. In the near future, these developments will usher in significant new functionality as machines become much better able to process and "understand" the data that they merely display at present... Two important technologies for developing the Semantic Web are already in place: eXtensible Markup Language (XML) and the Resource Description Framework (RDF). XML lets everyone create their own tags -- hidden labels such as or that annotate Web pages or sections of text on a page. Scripts, or programs, can make use of these tags in sophisticated ways, but the script writer has to know what the page writer uses each tag for. In short, XML allows users to add arbitrary structure to their documents but says nothing about what the structures mean . Meaning is expressed by RDF, which encodes it in sets of triples, each triple being rather like the subject, verb and object of an elementary sentence. These triples can be written using XML tags. In RDF, a document makes assertions that particular things (people, Web pages or whatever) have properties (such as 'is a sister of,' 'is the author of') with certain values (another person, another Web page). This structure turns out to be a natural way to describe the vast majority of the data processed by machines. Subject and object are each identified by a Universal Resource Identifier (URI), just as used in a link on a Web page. (URLs, Uniform Resource Locators, are the most common type of URI.) The verbs are also identified by URIs, which enables anyone to define a new concept, a new verb, just by defining a URI for it somewhere on the Web... this is not the end of the story, because two databases may use different identifiers for what is in fact the same concept, such as zip code. A program that wants to compare or combine information across the two databases has to know that these two terms are being used to mean the same thing. Ideally, the program must have a way to discover such common meanings for whatever databases it encounters. A solution to this problem is provided by the third basic component of the Semantic Web, collections of information called ontologies. In philosophy, an ontology is a theory about the nature of existence, of what types of things exist; ontology as a discipline studies such theories. Artificial-intelligence and Web researchers have co-opted the term for their own jargon, and for them an ontology is a document or file that formally defines the relations among terms. The most typical kind of ontology for the Web has a taxonomy and a set of inference rules... The real power of the Semantic Web will be realized when people create many programs that collect Web content from diverse sources, process the information and exchange the results with other programs; the Semantic Web promotes this synergy: even agents that were not expressly designed to work together can transfer data among themselves when the data come with semantics."

• [April 10, 2001] "Networked Knowledge Representation and Exchange using UML and RDF." By Stephen Cranefield (Department of Information Science, University of Otago PO Box 56, Dunedin, New Zealand). In Journal of Digital Information (JoDI) Volume 1, Issue 8 (February 15, 2001) [Themes: Information management, Information discovery.] "This paper proposes the use of the Unified Modeling Language (UML) as a language for modelling ontologies for Web resources and the knowledge contained within them. To provide a mechanism for serialising and processing object diagrams representing knowledge, a pair of XSLT stylesheets have been developed to map from XML Metadata Interchange (XMI) encodings of class diagrams to corresponding RDF schemas and to Java classes representing the concepts in the ontologies. The Java code includes methods for marshalling and unmarshalling object-oriented information between in-memory data structures and RDF serialisations of that information. This provides a convenient mechanism for Java applications to share knowledge on the Web... [Conclusions:] This paper has illustrated the use of UML for representing ontologies and knowledge about particular instances in the domains modelled by those ontologies. As a widely known and supported modelling language, UML has great potential for describing Web resources in a machine accessible way. Although the XMI specification defines a standard way of serialising UML models, this does not provide a convenient way of serialising knowledge in the form of object diagrams. As a solution to this problem, a pair of mappings from XMI encodings of UML class diagrams to Java classes and to RDF schemas have been defined and implemented using XSLT. The Java classes include code to marshal and unmarshal knowledge expressed as in-memory representations of object diagrams to and from RDF documents in the XML encoding. There is considerable interest in developing bridges between standards from the domains of object-oriented modelling, distributed object computing and Internet computing (Jagannathan and Fuchs 1999). It is hoped that the specification of mappings such as the ones described here will be addressed by a recognised industry standards body. To aid this process, the work described here will be made publicly available at http://nzdis.otago.ac.nz/projects."

• [March 24, 2001] "RDF Protocol." By Ken MacLeod. March 24, 2001. "RDF Protocol is simple structured text alternative to standard ASCII line-oriented protocol (as used in FTP, NNTP, SMTP, et al.). RDF Protocol also subsumes the features of RFC-822-style headers as used in MIME, SMTP, and HTTP." Includes Core RDF Protocol; IRC in RDF Protocol; Replication in RDF Protocol. [From the posting: 'Toying With an Idea: RDF Protocol': "RDF Protocol really isn't a protocol so much as setting down some conventions for passing bits of RDF around. Well, ok, some of the bits work a lot like a protocol, so it's gotta look like that, but here goes... I'm playing with a Python implementation of the basic message read/write and using IRC as the example protocol to emulate, using Dave Beckett's IRC in RDF schema. In case anyone was wondering, there are no APIs and no RPCs at this layer, it's all XML instance passing, with RDF triples as the content..."

• [March 16, 2001] "Querying and Transforming RDF." By Stefan Kokkelink. "QAT basic observation: The data model of XML is a tree, while the data model of RDF is a directed labelled graph. From a data model point of view we can think of XML as a subset of RDF. On the other hand XML has a strong influence on the further development of RDF (for example XML Schema <-> RDF Schema) because it is used as serialization syntax. Applications should take into account this connection. We should provide query and transformation languages for RDF that are as far as possible extensions of existing (and proven) XML technologies. This approach automatically implies to be in sync with further XML development." See the working papers: (1) "Quick introduction to RDFPath" and (2) "Transforming RDF with RDFPath" ['The Resource Description Framework (RDF) enables the representation (and storage) of distributed information in the World Wide Web. Especially the use of various RDF schema leads to a complex and heterogenous information space. In order to efficiently deploy RDF databases, we need simple tools to extract information from RDF and to perform transformations on RDF. This paper describes two approaches for transforming RDF using the RDF path language RDFPath. The first approach realizes transformations within an Application Programming Interface (API) and the second approach describes a declarative transformation language for RDF (analogously to XSLT for XML).'] From the 2001-03-16 posting: "After investigating the currently available techniques for querying and transforming RDF (for example see [1]) I would like to propose an alternative approach that is connected more closely to the XML development. Basically I would like to have the counterparts of XPath,XSLT and XQuery in the RDF world: RDFPath,RDFT and RQuery. This approach has (in my opinion) some advantages: (1) benefit from the lessons learned from XML; (2) don't reinvent the wheel: copy and paste as long as possible, extend if necessary; (3) be in sync with XML development. This approach is feasible because from a *data model* point of view XML (tree) is a subset of RDF (directed labelled graph)..."

• [March 08, 2001] "Jena: Implementing the RDF Model and Syntax Specification." By Brian McBride (Hewlett Packard Laboratories Bristol, UK). ['Some aspects of W3C's RDF Model and Syntax Specification require careful reading and interpretation to produce a conformant implementation. Issues have arisen around anonymous resources, reification and RDF Graphs. These and other issues are identified, discussed and an interpretation of each is proposed. Jena, an RDF API in Java based on this interpretation, is described.'] "Since the W3C's Resource Description Framework (RDF) Model and Syntax specification completed its path to W3C recommendation several implementations have been developed. These differ in some aspects of their interpretation of the specification. There has been much discussion of these issues on the RDF Interest Mailing List [refs], which so far, has not produced resolution. Inter-mixed with those discussions, have been others about changes and extensions to the specification. All this has caused confusion and uncertainty that is inhibiting the acceptance and deployment of RDF. Tool builders wish to build tools that are correct and conformant. This they cannot do, because it is not clear what it means to be correct and conformant. Similarly producers and consumers of RDF wish to produce RDF whose interpretation is well defined. Uncertainty of interpretation inhibits them from doing so. One reason for the lack of resolution is that issues are discussed individually. The issues themselves however, are interlinked. It is hard for a community discussing, say the subtleties of reification to agree when the have fundamentally different views on the nature of resources and their identification. An implementer setting out to develop an implementation of an RDF tool must have an interpretation of the specification. This paper describes the interpretation developed for Jena, an RDF API in Java. The guiding principle for this interpretation was to implement, as far as possible, the specification as it is, without embellishment. It is documented here in the hope it will prove helpful to other developers."

• [March 05, 2001] "Information Modelling using RDF. Constructs for Modular Description of Complex Systems." By Graham Klyne (Content Security Group, Baltimore Technologies). 24 pages, with 25 references. "This paper describes some experimental work for modelling complex systems with RDF. Basic RDF represents information at a very fine level of granularity. The thrust of this work is to build higher-level constructs in RDF that allow complex systems to be modelled incrementally, without necessarily having full knowledge of the detailed ontological structure of the complete system description. The constructs used draw on two central ideas: statement sets as contexts (based in part on ideas of McCarthy [Notes on Formalizing Context] and Guha [Contexts: A Formalization and Some Applications]) to stand for a composition of individual RDF statements that can be used in certain circumstances as a statement, and a system of 'proper naming' that allows entity prototypes to be described in a frame-like fashion, but over a wider scope than is afforded by class- and instance- based mechanisms... Articulated visions for the Semantic Web require that anyone must be able to say anything about anything. It is unreasonable to expect everyone to adopt exactly the same ontological structure for making statements about an entity; apart from political and perceptual differences, that approach cannot scale. This leads to my assertion that practical modelling of complex systems requires statements that can stand independently of finer ontological details. This is not a dismissal of ontological structures; work on onological frameworks such as OIL and DAML-O is needed to underpin verification of web-based information. In due course, I would expect a theory to emerge that relates descriptions based on incomplete ontologies to more rigorously complete frameworks. I view basic RDF as a kind of 'assembly language' for information modelling, and see this use of contexts and proper naming as a parallel to procedures and formal parameters in programming languages, used to aid the construction of complex object descriptions without adding new formal capabilities. The constructs presented here are being used in the following ongoing experimental developments: (1) A graphical tool for RDF modelling. (2) An experimental RDF-driven expert shell. We also aim to develop mechanisms for trust modelling and inference; modelling social trust structures and overcoming the brittleness of purely cryptographically based approaches to trust in e-commerce, etc. Another area for investigation is the design of mechanisms for managing non monoticic reasoning, and other logical extensions of contexts. In messages to the RDF interest group, Dan Brickley has proposed an alternative approach to labelling anonymous RDF resources; i.e. resources whose formal URI or URI reference is unknown. The outcome of these discussions may affect the exact form of naming preferred. Note: 'I've finally got around to putting on the web a note I drafted some time ago describing some thoughts about using RDF and contexts for modelling complex objects and concepts. It draws heavily on my earlier note about contexts and RDF, and adds some other thoughts about modularizing complex RDF graphs.' - Posted to the RDF interest group. [cache]

• [February 22, 2001] "[Draft/experimental] Formal Specification of the RDF Syntax." By Brian McBride (HPLabs). February 22, 2001. "[This is] an experiment in doing a formal specification of the RDF Syntax. The goal is to more formally define the triples that any given RDF XML represents. The idea is to annotate the grammar with attributes. Each production in the grammar takes attributes as arguments and can return attributes as a result. A production emitTriple, which always succeeds but has the side effect of emitting a triple is introduced. There is a trivial transformation from the annotated grammar to an equivalent XSLT transform, thus in effect enabling an executable specification." ["There was a suggestion on the list last summer that transformation grammars could be used to formally specify the translation of RDF XML to triples. A quick search around the web revealled that such grammars were proposed in natural language processing, but I didn't find anything immediately useful. I liked the idea of formal definition of the transformation. I also thought it would be good to have an 'executable' specification, i.e. one that we could execute against test cases and would spit out the triples. My first thought was to use XSLT to define the transform, but that turned out pretty unreadable. My second attempt has been to produce an attribute grammar for RDF. It turns out that an attribute grammar works reasonably well, and there is a simple, possibly automatable, way of turning the attribute grammar into an XSLT transform. The attribute grammar can be found in the header comment, and the XSLT is executable, though probably buggy."]

• [February 16, 2001] "The Design and Implementation of the Redland RDF Application Framework." By Dave Beckett (Institute for Learning and Research Technology University of Bristol). Accepted for presentation at the WWW10 Conference in Hong Kong in May, 2001. HTML, PostScript and PDF versions are available. Abstract: "Resource Description Framework (RDF) is a general description technology that can be applied to many application domains. Redland is a software library for RDF which implements a flexible framework that complements this power and provides a high-level interface allowing instances of the RDF model to be stored, queried and manipulated. Redland implements the model concepts using an object-based API and provides several of the classes as modules which can be added, removed or replaced to provide different functionality or application-specific optimisations. The framework also provides a core technology for developing new RDF applications that can experiment with implementation techniques, APIs and representation issues." The running code is on http://www.redland.opensource.ac.uk/; see also the Redland home page. [cache]

• [February 03, 2001] "RDF Representation of Wordnet Available for Download." By Sergey Melnik and Stefan Decker. Posting 2001-02-02. "An RDF-Representation of Wordnet 1.6 (a Lexical Database for English) is available for download. WordNet is an on-line lexical reference system whose design is inspired by current psycholinguistic theories of human lexical memory. English nouns, verbs, adjectives and adverbs are organized into synonym sets, each representing one underlying lexical concept. Different relations link the synonym sets. Please read the license before downloading the RDF representation of Wordnet. (1) Nouns (10MB), (2) Glossary (15MB), (3) SimilarTo-Definitions (2MB ), (4) Hyponym Definitions (8MB). A Schema (Ontology) [KB] defining the terms used to represent the RDF version of Wordnet is available at: http://www.semanticweb.org/library/wordnet/wordnet-20000620.rdfs."

• Metadata: eLib Use of RDF. "As of December 1998 all of the eLib Web Pages [The Electronic Libraries Programme] contain embedded Dublin Core metadata. The metadata is stored in a ROADS database and is dynamically converted to an XML representation of RDF (Resource Description Framework) as the pages are requested. It is expected that search engines will begin to support embedded XML/RDF as RDF emerges as a standard way of encoding metadata. Early adoption of RDF is a way of encouraging this process... Since the metadata is embedded in the eLib web pages it can be seem by viewing the HTML source for a page. The metadata is in XML/RDF format for machine readability. A human viewable rendering of the metadata on each page is available by clicking on the "DC Metadata" link in the page footer... The eLib metadata is encoded using an HTML-compliant XML representation of RDF as described in the W3C 'Resource Description Framework (RDF) Model and Syntax Specification'... The embedded RDF has been verified using the SiRPAC parser...Rather than inserting XML/RDF metadata into each eLib Web Page (which would be error prone and difficult to maintain) the metadata is embedded 'on the fly' using a server side include (SSI) directive. This SSI directive makes a call to a Perl script and inserts the output of that Perl script (the XML/RDF metadata) into the HEAD of the document. The Perl script retrieves the appropriate metadata record from the ROADS database and converts it to XML/RDF. This approach allows other representations of the metadata to be generated such as META TAGS or the viewable HTML that can be accessed from the footer of each page..."

• [January 30, 2001] "Understanding RDF: The Resource Description Framework in Context." By Dan Brickley. 1999/2001. "This presentation of RDF attempts to provide a high level overview of W3C's Resource Description Framework, while grounding the discussion in enough technical detail to highlight RDF's novel and interesting characteristics. For those who have not heard of RDF before, RDF is a relatively new framework for metadata interoperability devised by the World Wide Web Consortium, home of HTML and other Web standards. This overview does not assume any special knowledge of RDF, but does assume some basic familiarity with concepts such as 'metadata', 'URI', 'XML'." [Draft 'online notes from "Understanding RDF" overview' - "XHTMLisation based on notes from a (hastily assembled) talk I gave in Luxemburg a couple of years ago; not yet quite integrating the (GIF image; ugh) content from my original overhead slides. I've lofty ambitions to tidy this up further and extend to reflect recent apps and the 'semantic web' side of things. Time will tell if that happens, so here's the raw doc in its unpolished state. Feedback / suggestions welcomed..."]

• [January 25, 2001] "Tutorials: What is RDF?" By Tim Bray and Dan Brickley. From XML.com. January 24, 2001. ['An introduction to the W3C's Resource Description Format, a standard for exchanging metadata, and a key technology for the W3C's "Semantic Web".'] "This article was first published as "RDF and Metadata" on XML.com in June 1998. It has been updated by ILRT's Dan Brickley, chair of the W3C's RDF Interest Group, to reflect the growing use of RDF and updates to the specification since 1998. RDF stands for Resource Description Framework. RDF is built for the Web, but let's leave the Web behind for now and think about how we find things in the real world. Scenario 1: The Library. You're in a library to find books on raising donkeys as pets. In most libraries these days you'd use the computer lookup system, basically an electronic version of the old card file. This system allows you to list books by author, title, subject, and so on. The list includes the date, author, title, and lots of other useful information, including (most important of all) where each book is..."

• [January 12, 2001] "RDF Terminology and Concepts." Edited by Graham Klyne. "This is currently a live working document, being a collection of suggestions from participants in the W3C RDF Interest Group." [cache]

• [January 10, 2001] "The future of natural-language processing. Seeking a practical solution to the limitations of NLP methodologies and software." By Chimezie Thomas-Ogbuji. In (January 2001). ['What is natural-language processing (NLP) and how does it relate to XML and knowledge management? In this Unix Insider feature, guest writer Chimezie Thomas-Ogbuji discusses NLP in conjunction with the World Wide Web Consortium's Resource Description Framework (RDF) and introduces Thought Treasure, an open source natural-language processor that helps integrate NLP with RDF application logic.'] Natural-language processing (NLP) is an area of artificial intelligence research that attempts to reproduce the human interpretation of language. NLP methodologies and techniques assume that the patterns in grammar and the conceptual relationships between words in language can be articulated scientifically. The ultimate goal of NLP is to determine a system of symbols, relations, and conceptual information that can be used by computer logic to implement artificial language interpretation. Natural-language processing has its roots in semiotics, the study of signs. Semiotics was developed by Charles Sanders Peirce (a logician and philosopher) and Ferdinand de Saussure (a linguist). Semiotics is broken up into three branches: syntax, semantics, and pragmatics. A complete natural-language processor extracts meaning from language on at least seven levels. However, we'll focus on the four main levels. [...] The W3C's Resource Definition Framework (RDF) was developed to enable the automated processing of Web resources by providing a means of defining metadata about those resources. RDF addresses the physical limitation of memory space by allowing a natural-language processor to access resources in a distributed environment. A networked computer processor can access RDF models on various other processors in a standard way. RDF provides a unifying ontological syntax for defining knowledge bases. RDF is expressed in XML, a markup language designed to cleanly separate data formatting from data semantics. As a result of the extensible nature of XML (authors have only the restriction of being well-formed and valid), a number of categories of information can be expressed very clearly using XML and RDF. RDF is by no means the perfect ontological syntax. For instance, there are five semantic principles: existence, coreference, relation, conjunction, and negation. RDF doesn't inherently support conjunctions and negations. At its core, RDF allows users to define statements in a simple format about network resources... let's take a closer look at a practical example: Thought Treasure is a powerful, open source natural-language processor developed by Erik T. Mueller. It is capable of interpreting natural-language queries, responding to queries in natural language, extending its knowledge base, and identifying emotions in conversation. It provides developers with powerful ways to extend its knowledge base and invoke its various services. Thus, I could easily extend it to handle RDF using 4RDF. The example we covered only scratches the surface of possibilities. Thought Treasure allows remote access through its ThoughtTreasure Server Protocol (TTSP). So, Thought Treasure servers running dynamically on a 4RDF model can be queried with natural language remotely. You could also use Thought Treasure's learning agency to extract knowledge bases from text, converting the ontologies to an RDF model. I haven't explored the full extent of the Thought Treasure data format, but I'm sure many improvements could be made to the conversion process. At the very least, this article provides a starting point for developers seeking to integrate NLP to their RDF application logic."

• [November 06, 2000] "Querying Community Web Portals." By Greg Karvounarakis, Vassilis Christophides, Dimitris Plexousakis, and Sofia Alexaki. ICS-FORTH Institute of Computer Science. November, 2000. 28 pages. "Information systems such as organizational memories, vertical aggregators, infomediaries, etc. are expected to play a central role in the 21st-century economy by enabling the development and maintenance of specific communities of interest (e.g., enterprise, professional, trading) on corporate intranets or the Web. Such Community Web Portals essentially provide the means to select, classify and access, in a semantically meaningful and ubiquitous way various information resources (e.g., sites, documents, data) for diverse target audiences (corporate, inter-enterprise, e-marketplace, etc.). Yet, in commercial software for deploying Community Portals, querying is still limited to full-text (or attribute-value) retrieval and more advanced information-seeking needs require navigational access. Furthermore, recent Web standards for describing resources [W3C Metadata Activity: RDF/ RDF Schema] are completely ignored. Moreover, standard (relational or object) databases are too rigid for capturing the peculiarities of RDF descriptions and schemas. Motivated by the above issues, we propose a new data model and a query language for RDF descriptions and schemas. Our language, called $RQL$, relies on a formal graph model, that captures the RDF modeling primitives, also providing a richer type system, and permits the interpretation of RDF descriptions by means of one or more schemas. In this context, $RQL$ adapts the functionality of semistructured query languages to the peculiarities of RDF but also extends this functionality in order to query RDF schemas. The novelty of $RQL$ lies in its ability to smoothly switch between schema and data querying while exploiting - in a transparent way - the taxonomies of labels and multiple classification of resources." [cache]

• [October 20, 2000] "Contexts for RDF Information Modelling." By Graham Klyne (Content Technologies Ltd). Revised: 18 October 2000. "This memo describes some experimental work that is being undertaken with the goal of simplifying the application of RDF to a number of information modelling problems, particularly involving relationships between physical-world objects and trust modelling. It is our goal that, by using contexts, a degree of modularity can be introduced that will ease the construction of RDF information models. . . As a mechanism for representing information, RDF is very general, but very primitive. It might be viewed as a kind of 'assembly language' for knowledge and metadata representation. There are some metadata applications, such as adding properties to web pages, for which basic RDF is well suited. But there are others, particularly describing detailed relationships between physical-world objects, where one soon becomes lost in a tangle of graph nodes and edges, loosing sight of the overall structure of the information. The above conclusion was reached when trying to model configuration and interworking options between a number of computer system components. Despite repeated simplifications of the problem, we kept on running out of whiteboard space to contain the RDF graph of our chosen problem. Assembly language programmers soon adopted the notion of subroutine -- grouping instructions into separate, understandable, interacting pieces -- to construct programs consisting of very many primitive instructions. It is a thesis of this proposal that the idea of 'contexts' can perform a similar function for information modelling in RDF. What are the kinds of problem we hope to address using contexts? Some are: (1) Representing the relationship between statements and documents that contain them; e.g. what is the effect of signing a document on the statements that it may contain? (2) Trust modelling; again, modelling the effect of signature, originator, etc. Applying heuristics for establishing levels of trust based on the origin of and/or uses made of information. (3) Nested resources; e.g., web pages are resources that may be made up from other resources. (4) Modelling the full complexities of real-world relationships; e.g., selecting the right power supply for an electrical device will depend upon many inter-related factors: supply voltage, supply quality, device voltage required, device current required, supply quality required, type of connector, physical space available, noise suppression requirements, etc., etc. (5) Providing a framework for expressing statements about which one might reason non-monotonically; e.g., birds can fly, unless the bird in question is a penguin..."

• [October 13, 2000] The Semantic Web: The Roles of XML and RDF." By Stefan Decker, Sergey Melnik, Frank Van Harmelen, Dieter Fensel, Michel Klein, Jeen Broekstra, Michael Erdmann, and Ian Horrocks. In IEEE Internet Computing Volume 4, Number 5 (September/October 2000), pages 63-74. ['XML and RDF are the current standards for establishing semantic interoperability on the Web, but XML addresses only document structure. RDF better facilitates interoperation because it provides a data model that can be extended to address sophisticated ontology representation techniques.'] "The World Wide Web is possible because a set of widely established standards guarantees interoperability at various levels. Until now, the Web has been designed for direct human processing, but the next-generation Web, which Tim Berners-Lee and others call the 'Semantic Web,' aims at machine-processible information. The Semantic Web will enable intelligent services -- such as information brokers, search agents, and information filters -- which offer greater functionality and interoperability than current stand-alone services. The Semantic Web will only be possible once further levels of interoperability have been established. Standards must be defined not only for the syntactic form of documents, but also for their semantic content. Notable among recent W3C standardization efforts are XML/XML schema and RDF/RDF schema, which facilitate semantic interoperability. In this article, we explain the role of ontologies in the architecture of the Semantic Web. We then briefly summarize key elements of XML and RDF, showing why using XML as a tool for semantic interoperability will be ineffective in the long run. We argue that a further representation and inference layer is needed on top of the Web's current layers, and to establish such a layer, we propose a general method for encoding ontology representation languages into RDF/RDF schema. We illustrate the extension method by applying it to Ontology Interchange Language (OIL), an ontology representation and inference language. . .The Web community currently regards XML as the most important step toward semantic integration, but we argue that this is not true in the long run. Semantic interoperability will be a sine qua non for the Semantic Web, but it must be achieved by exploiting the current RDF proposals, rather than XML labeling. The RDF data model is sound, and approaches from artificial intelligence and knowledge engineering for establishing semantic interoperability are directly applicable to extending it. Our experience with OIL shows that this proposal is feasible, and a similar strategy should apply to any knowledge-modeling language. The challenge is now for the Web and AI communities to expand this generic method for creating Web-enabled, special-purpose knowledge representation languages." See also "XML and 'The Semantic Web'."

• [October 13, 2000] "4RDF: A Library for Web Metadata." By Uche Ogbuji. From XML.com (October 11, 2000). ['One of the jewels in the crown of Python's XML support is the 4Suite collection of libraries, the most recent addition to which is 4RDF, a library for the parsing, querying, and storage of RDF.'] 4Suite is a library and collection of tools for XML and object database development using Python, with support for most UNIX flavors and Win32. Fourthought, Inc. develops 4Suite as open source software, and the package (this article discusses the 0.9.1 release) includes a set of sub-components: (1) 4DOM: an XML/HTML library based on DOM Level 2; (2) 4XPath: a complete XPath 1.0 engine; (3) 4XSLT: a complete XSLT 1.0 processor; (4) 4XPointer: a (so far) partial implementation of XPointer; (5) 4ODS: an object persistence library based on ODMG 3.0, including a persistent DOM engine; (6) 4RDF: a library based on the W3C RDF specifications. There are other technologies supported in 4Suite, such as SAX and UUID generation, but the focus of this article is 4RDF. I shall assume familiarity with RDF. There are many resources providing introduction and discussion at the W3C's RDF page. 4RDF is a full-featured library based on the abstract models defined by W3C in their RDF Model and Syntax Recommendation 1.0 (RDF M&S) and RDF Schema Candidate Recommendation 1.0. (RDF Schemas). It provides several features beyond the RDF core, including multiple persistence mechanisms and an experimental inference layer for RDF data. Note that Fourthought is currently alpha-testing a 4Suite Server, a distribution of 4Suite with a built-in CORBA interface to allow use as a black box from other platforms and programming languages..." See also part 2, RIL: A Taste of Knowledge"; an innovative part of 4RDF is the RDF Inference Language (RIL), which provides a way of viewing an RDF model as an Expert System knowledge base.

• [October 06, 2000] PRISM Profile of the Resource Description Framework." Posting to 'www-rdf-interest@w3.org' by Ron Daniel. 2000-10-06. "The Resource Description Framework (RDF) has been standardized by the W3C to provide a general framework for metadata. As such, its capabilities exceed those required by PRISM. Therefore, this document specifies a 'profile' - a restricted subset - of RDF that all PRISM-compliant software must support. This profile excludes certain capabilities of RDF that are not needed in PRISM applications, thus simplifying the development of PRISM applications that cannot, for one reason or another, make use of an existing RDF parsing frontend. Applications conforming to the PRISM specification MUST produce correct RDF documents that can be read by any RDF-compliant software. PRISM-compliant software does not have to be capable of processing any arbitrary RDF documents. There are three general classes of simplification this document makes in its profile of RDF. First, there are certain capabilities of RDF that are excluded. Second, there are some syntactic abbreviations allowed in RDF that are excluded from PRISM documents. Third, there are conventions adopted for the syntax used to express information where RDF allows multiple ways of saying the same thing... [The post said: "In response to Gabe Beged-Dov's request, the PRISM Working Group has authorized me to send out our suggested profile of RDF for wider review. Please send any comments this list. I will take care of feeding the comments back to the PRISM working group, and notifying this list of the results of deliberations about the comments. Be aware that this profile may get more restrictive over time as we examine more and more sample data from our publishing members. PRISM's goal is to be implementable, so the less opportunity for ambiguity the better." See: "Publishing Requirements for Industry Standard Metadata (PRISM)."

• [October 02, 2000] "An Extensible Approach for Modeling Ontologies in RDF(S)." By Steffen Staab, Michael Erdmann, Alexander Mädche, and Stefan Decker. 10 pages, with 16 references. Presented at the First Workshop on the Semantic Web at the Fourth European Conference International Workshop on Research and Advanced Technology for Digital Libraries, Lisbon, Portugal 18-20 September 2000. "RDF(S) constitutes a newly emerging standard for metadata that is about to turn the World Wide Web into a machine-understandable knowledge base. It is an XML application that allows for the denotation of facts and schemata in a web-compatible format, building on an elaborate object-model for describing concepts and relations. Thus, it might turn up as a natural choice for a widely-useable ontology description language. However, its lack of capabilities for describing the semantics of concepts and relations beyond those provided by inheritance mechanisms makes it a rather weak language for even the most austere knowledge-based system. This paper presents an approach for modeling ontologies in RDF(S) that also considers axioms as objects that are describable in RDF(S). Thus, we provide flexible, extensible, and adequate means for accessing and exchanging axioms in RDF(S). Our approach follows the spirit of the World Wide Web, as we do not assume a global axiom specification language that is too intractable for one purpose and too weak for the next, but rather a methodology that allows (communities of) users to specify what axioms are interesting in their domain. . . The proposal described in this paper is based on several related approaches, viz., we have built on considerations made for the RDF inference service SiLRi, the ontology engineering environments ODE and Protégé, the ontology interchange language OIL, considerations made by Gruber, and our own earlier work on general ontology engineering. SiLRi was one of the first approaches to propose inferencing facilities for RDF. It provides most of the basic inferencing functions one wants to have in RDF and, hence, has provided a good start for many RDF applications. In fact, it even allows to use axioms, but these axioms may not be denoted in RDF, but only directly in F-Logic. It lacks capabilities for axiom representation in RDF(S) that our proposal provides. In our earlier proposals we have discussed how to push the engineering of ontological axioms from the symbol level onto the knowledge level -- following and extending the general arguments made for ODE and Ontolingua. This strategy has helped us here in providing an RDF(S) object representation for a number of different axiom types. Nearest to our actual RDF(S)-based ontology engineering tool is Protégé, which provides comprehensive support for editing RDFS and RDF. Nevertheless, Protégé currently lacks any support for axiom modeling and inferencing -- though our approach may be very easy to transfer to Protégé. A purpose similar to our general goal of representing ontologies in RDF(S) is pursued with OIL. Actually, OIL constitutes an instantiation of our methodological approach, as the definition of concepts and relations in description logics is equivalent to the instantiation of a small number of axiom schemata in a particular logical framework. The axiom categorisation we presented in this paper can be effortlessly combined with the ontological meta-layer proposed in OIL. Thus, applications can utilize two vocabularies that complement each other to model classes in a DL-style while at the same time defining axioms on the conceptual level. Finally, there are other approaches for ontology exchange and representation in XML formats that we do not want to elaborate here, as they fail our litmus test for supporting the RDF(S) metadata standard. We have presented a new approach towards engineering ontologies extending the general arguments made for ODE and Ontolingua in the web formats, RDF and RDFS. Our objectives aim at the usage of existing inferencing services such as provided by deductive database mechanisms or description logics systems. We reach these objectives through a methodology that classifies axioms into axiom types according to their semantic meaning. Each type receives an object representation that abstracts from scoping issues and is easily representable in RDF(S). Axiom descriptions only keep references to concepts and relations necessary to distinguish one particular axiom of one type from another one of the same type. When the limits of object representations in RDF(S) are reached, we fall back onto target system-specific representations. These may be formulated in RDF versions of languages like OIL or MetaLog -- but since they are commonly very specific for particular applications, they may also be expressed by strings (CDATA), the particular semantics of which is only defined in the corresponding application. Our proposed extension of RDF(S) has been made with a clear goal in mind -- the complete retention of the expressibility and semantics of RDF(S) for the representation of ontologies. This includes the relationship between ontologies and instances, both represented in RDF(S). Especially, the notion of consistency between an RDF model and a schema also holds for ontologies expressed in RDF(S). The integration of the newly defined resources has been carried out in a such a way that all RDF processors capable of processing RDF schemas can correctly interpret RDF models following the ontology schema, even if they do not understand the semantics of the resources in the o-namespace. Special applications like OntoEdit can interpret the o-namespace correctly and thus fully benefit from the richer modelling primitives, if the RDF model is valid according to the defined ontology schema. Our approach has been partially implemented in our ontology engineering environment, OntoEdit. The object-model engineering capabilities for RDF(S) are ready to use, while different views for axiom representations are currently under construction." Document also in PostScript format. See the research projects in the The Researchgroup Knowledge Management, Institute for Applied Computer Science and Formal Description Methods (AIFB), University of Karlsruhe, Karlsruhe, Germany. See especially the Publications of the Researchgroup Knowledge Management and the OntoBroker Project. [cache]

• [October 02, 2000] "RSLP Collection Description." By Andy Powell (UKOLN, University of Bath), Michael Heaney (University Library Services Directorate, University of Oxford), and Lorcan Dempsey (DNER Director, Joint Information Systems Committee, King's College London). In D-Lib Magazine Volume 6 Number 9 (September 2000). ISSN: 1082-9873. "This article describes work undertaken as part of the RSLP Collection Description Project, a project funded by the UK Research Support Libraries Programme (RSLP) with the aim of enabling all projects funded through the programme to describe collections in a consistent and machine readable way. With additional funding from OCLC, the project has developed a model of collections and their catalogues. We have used this work to form the basis of a collection description metadata schema, implemented using the Resource Description Framework (RDF). A Web-based tool has been developed that allows the construction of RDF descriptions by filling in a Web form. Associated with this tool there is a detailed set of data entry guidelines and an enumerated list of collection types. Future work will see the development of a Web robot that will harvest collection descriptions from project Web sites and make them available through a central search service. Although it has its origin in the Research Support Libraries Programme, many of whose results will be digital resources of one kind or another, our work is not restricted to the description of digital collections. It is intended that the results of the project should be applicable to physical and digital collections of all kinds, including library, art and museum materials. It is by no means applicable only to the resources of large research libraries. . . The Resource Description Framework (RDF) is the W3C recommended architecture for metadata on the Web. RDF provides a mechanism for making simple metadata statements about resources (including both digital and physical resources) of the form - resource X has property Y with value Z. By grouping sets of these simple statements together, and by using the same mechanism to make statements about the sets of statements, it is possible to build up complex RDF descriptions of multiple resources and the relationships between them. Currently, the exchange of RDF descriptions on the Web is achieved by encoding them using the Extensible Markup Language (XML). The RSLP Collection Description project chose to encode collection descriptions using the XML encoding of RDF, based on the attributes listed in the schema above. Full collection descriptions are partitioned into separate RDF descriptions of Collections, Locations, Collectors, Owners and Administrators. These separate descriptions are linked together to form a full description..."

• [September 15, 2000] "Going to Extremes." By Liora Alschuler. From XML.com (September 13, 2000). ['Geeks in tweed and metadata maniacs, shapers of the future of structured information representation. The recent Extreme Markup Languages conference had it all. Liora Alschuler was there and reports back on the Topic Maps and RDF head-to-head.]' "XML has to date achieved a degree of syntactic, but not semantic, interoperability. On the Web, you still can't find what you need easily, and when you do, you may not know what it means. Grammars, that is, DTDs and schemas, don't supply meaning any more than the Elements of Style can tell you the size, shape, and location of a certain white whale. (The draft W3C schemas do include a type system, a necessary but not sufficient component of 'meaning.' W3C schemas figured remarkably little in discussion, although a pre-conference tutorial was well attended.) As Jeff Heflin and James Hendler put it, 'To achieve semantic interoperability, systems must be able to exchange data in such a way that the precise meaning of the data is readily accessible and the data itself can be translated by any system into a form that it understands.' The problem is that XML itself has, by design, no semantics. Or, as John Heintz and W. Eliot Kimber said, 'DTDs constrain syntax, not data models. They don't capture abstraction across models, they are simply an implementation view of a higher abstraction.' The conference program was rich in reports of real-world, large-scale implementations actively engaged in the search for meaning, and they were not all focused on Topic Maps or RDF -- although these specs (ISO and W3C respectively) were the most prevalent form of semantic representation addressed. . . Facing the conflict between Topic Maps and RDF head-on, the conference staged a debate between Eric 'RDF' Miller of OCLC and Eric 'Topic Maps' Freese of ISOGEN. Freese and Miller provided this comparison between the two specs: Both (1) are hard to read, (2) share a goal: to tie semantics to document structures, (3) provide a systematic way to declare a vocabulary and basic integrity constraints, (4) provide a typing system, (5) provide entity relationships, (6) both work well with established ontologies. Differences between the two specifications (1) Topic Maps are not XML-specific and have so far been standardized for SGML only. The XML Topic Map activity under the GCA's IDEAlliance is drafting a proposal for such an implementation. (2) RDF is also not XML-specific, but to date has been implemented only in XML. (3) RDF now has which provides a standard way to express and link an ontology; such a schema is proposed for Topic Maps. (4) RDF uses XML linking, Topic Maps use HyTime linking. (5) Topic Maps have explicit scoping. (6) Topic Maps start with the abstract layer and (optionally) link to resources; RDF starts at the resource layer and (optionally) creates an abstract layer. [...] But as C. M. Sperberg-McQueen reminded us in his closing keynote, meaning is always in the instance. It would be reassuring to think that the Topic Map and RDF folks will hold this in mind as they convene their joint meetings and deliberate on the future of angle brackets with metadata. Reducing Tosca to a Topic Map, or a set of directed graphs, and calling the libretto 'mere information,' while calling the metadata schema 'knowledge,' misses a very large and important boat. Again, as Sperberg-McQueen put it, we should all 'resist the temptation to be more meta than thou,' and not lose sight of the importance of the instance itself."

• [September 22, 2000] W3C RDF and ISO/XML Topicmap discussion. Dan Connolly posted the announcement: "Following the energy and good will built up at the 'RDF vs. Topic Maps' session at Extreme Markup Languages in Montreal, a few of us got together by phone/IRC this morning (well... morning in my time zone). The notes we managed to take are available at http://www.w3.org/2000/09/tmr493/notes..." See RDF - ISO/XML Topicmap Agenda - 20000918: "A continuation of the conversations that started in Montreal at the Extreme Markup Languages Conference to increase knowledge and understanding about the relationships between the W3C RDF and ISO/XML Topicmap activities."

• [September 22, 2000] "XML-Deviant: Super Model." By Leigh Dodds. From XML.com (September 20, 2000). ['Growing interest in RDF is seeing renewed work to increase understanding of the specification, including a move to separate RDF's simple data model from its oft-maligned syntax.'] "The RDF Interest Group has recently been gathering momentum, and the XML-Deviant takes a look at the progress they're making towards improving understanding of RDF."

• [September 06, 2000] "Research notebook: On edge-labelled graphs in XML." By Dan Brickley. "There seems to be some consensus around the claim that RDF has a useful data model but a problematic XML syntax. This document is an attempt to gather together the various discussion documents and proposals that relate this topic to the broader context of XML-based graph serialization systems. . .This document serves as an informal survey of XML applications that adopt an edge-labelled graph data model similar to that used in W3C's Resource Description Framework (RDF). It also points to discussion and proposals regarding improvements to the RDF XML syntax. Hopefully these pointers will prove useful even while the document is incomplete..." [Forwarded from www-rdf-interest for hopefully obvious reasons. RDF syntax discussions have a lot in common with some more mainstream XML concerns; I'm hoping I might raid XML-DEV's bookmarks on this topic to build a useful overview for both communities. Basically I'm wondering whether the notion of a 'new, better' RDF syntax makes sense, or whether such a thing is likely to fall out of mainstream XML-for-data-graphs interchange conventions. Apologies for the sketchy state of the draft etc etc.]

• [September 06, 2000] "SOAP, RDF and the Semantic Web." By Henrik Frystyk Nielsen. Presented at WWW9, Semantic Web Track (May 2000) Developers Day Slides. (1) ZIP format, (2) HTML. See also the " Walkthrough of RDF Examples" [examples in the RDF spec and how they serialize in SOAP].

• [August 28, 2000] "A Logical Interpretation of RDF." By Wolfram Conen and Reinhold Klapsing. ['A document written to capture the precise meaning of RDF: we tried to express the concepts and constraints of the RDF model in first-order logic (FOL). The discussion paper contains the facts and rules we found. A SiLRI-conform datalog formulation of the rules and facts is also contained. Our approach tries to separate clearly between the level of representation (triples) and the level of knowledge (instanceOf, Resource, statements, predicates to express constraint violations etc.), avoids asserting negated facts, and discusses a way to utilize the rules in applications. A summary of motivation and key aspects is included on the title page of the paper. We really invite interested readers to have a look at it and to send us their comments.]' Abstract: "The Resource Description Framework (RDF) is intended to be used to capture and express the conceptual structure of information offered in the Web. Interoperability is considered to be an important enabler of future web applications. While XML supports syntactic interoperability, RDF is aimed at semantic interoperability. Interoperability is only given if different users/agents interpret an RDF data model in the same way. Important aspects of the RDF model are, however, expressed in prose which may lead to misunderstandings. To avoid this, capturing the intended semantics of RDF in first-order logic might be a valuable contribution and may provide RDF with a formalization allowing its full exploitation as a key ingredient of the evolving semantic Web. This paper tries to express the concepts and constraints of the RDF model in first-order logic." Also in Postscript and HTML-Format. [From 'www-rdf-interest@w3.org' list]

• [August 24, 2000] "An eXtensible Web Modeling Framework." By Reinhold Klapsing and Gustaf Neumann (Information Systems and Software Techniques, University of Essen, DE; {Reinhold.Klapsing, Gustaf.Neumann}@uni-essen.de). WWW8 (1999). "This paper presents the eXtensible Web Modeling Framework (XWM-F) which is based on the Resource Description Framework (RDF). Both frameworks use metadata to describe properties of web resources. As stated in the distinction between "data" and "metadata" is not an absolute one. Our proposed framework applies the same (meta-) data model to reason about data and metadata, and to specify the structure and content of a web site and making statements about the elements of a web site. The formal model of the XWM-F results in machine-understandable and interoperable content- and meta-data of a web site. The data model is capable to structure information from small units such as elements or single web pages to large structures such as web sites. An RDF schema can constrain the structure and content of a web page in a similar manner as a document type definition (DTD). An instance of such a schema is considered as content of a web page. XWM-F can be used to issue statements about elements of a web page by assigning instances of properties which are defined by an eXtensible set of RDF schemes. These statements can cover layout information, access rights, intellectual property rights for example. We developed a graphical editor to evaluate the approach."

• [August 22, 2000] "XML and the Resource Description Framework: The Great Web Hope." By Norm Medeiros (Technical Services Librarian, New York University School of Medicine). In ONLINE Magazine Volume 24, Number 5 (September 2000). "What incentive do search engine companies have for altering their indexing and rating algorithms? Moreover, what motivation do Web content providers have for implementing an intricate metadata standard if such efforts are futile at increasing retrieval or page ranking? The World Wide Web Consortium's (W3C) Resource Description Framework (RDF) and Extensible Markup Language (XML) offer a potential means to enhanced resource discovery on the Web. But will they work? [...] XML, Extensible Markup Language, is the syntax for RDF. Not surprisingly, XML was also developed by the World Wide Web Consortium and shares similarities with its metadata sibling. Both XML and RDF are concerned with information contexts. RDF focuses on this concern in regard to metadata, and uses the XML namespace facility to parse element sets. XML is poised to dethrone HTML as the language of the Web since it is extensible (not restricted to a limited number of elements), and supportive of automated data exchange (able to create contextual relationships that are machine-processable). In particular, XML's document type definition (DTD) and Extensible Stylesheet Language (XSL) separate the context from the display of information--a division HTML is incapable of achieving. . . Although RDF, XML, and a number of semantic standards avail themselves to the metadata community, the question remains: Will they work? Clearly, locally-defined metadata projects will benefit from the W3C's commitment to the Semantic Web. OCLC's Cooperative Online Resource Catalog (CORC) and UKOLN's DC-DOT Generator are just two examples of projects utilizing RDF in an attempt to populate the Internet with highly descriptive, machine-readable metadata. If digital signature technology can operate within the framework of RDF, perhaps commercial search engines will once again trust content providers to incorporate and associate appropriate metadata within their works. Will searching the Web one day be like searching an OPAC? Perhaps. It can't get any worse than it is...can it?"

• [August 04, 2000] "Topic Maps and RDF: A First Cut." By Steve Pepper. June 2000. "Ten theses on the relationship between topic maps and RDF. This is a first cut at understanding the similarities and differences between these two approaches to making information findable." On Topic Maps, see: "(XML) Topic Maps."

• [August 10, 2000] "Putting RDF to Work." By Edd Dumbill. From XML.com (August 09, 2000). ['Tool and API support for the Resource Description Framework is slowly coming of age. Edd Dumbill takes a look at RDFDB, one of the most exciting new RDF toolkits.'] "Over recent months, members of the www-rdf-interest mailing list have been working at creating practical applications of RDF technology. Notable among these efforts have been Dan Connolly's work with using XSLT to generate RDF from web pages, and R.V. Guha's lightweight RDF database project. RDF has always had the appeal of a Grand Unification Theory of the Internet, promising to create an information backbone into which many diverse information sources can be connected. With every source representing information in the same way, the prospect is that structured queries over the whole Web become possible. That's the promise, anyway. The reality has been somewhat more frustrating. RDF has been ostracized by many for a complex and confusing syntax, which more often than not obscures the real value of the platform. One also gets the feeling, RDF being the inaugural application of namespaces, that there's a certain contingent who will never forgive it for that! [...] RDFDB offers a great backbone -- storage and query facilities -- for integrating diverse information sources. In its early stages now, it's a project that deserves to get more mindshare. The SQL-like syntax brings a familiarity to querying that other, more Prolog-like, mechanisms don't. Architecturally, I find the implementation of RDFDB as a database server a great advantage. It immediately makes multiple data sources and clients a reality, and makes cross-platform implementation easy (writing a language client to RDFDB is pretty trivial, I managed a workable first cut in 10 lines of Perl)."

• [August 31, 2000] "XML-Deviant: Instant RDF?" By Leigh Dodds. From XML.com. August 30, 2000. RDF has some devoted followers, but is yet to hit the XML mainstream. Many believe this is because of its complicated syntax. XML-Deviant investigates the quest for 'instant RDF'.'] "Complexity has been one criticism which RDF has had difficulty in shaking off. Both the RDF model, and its serialization syntax, have fallen foul of this issue at various points in its development. Efforts to produce a simpler serialization syntax have lead to several alternate proposals, including one from Tim Berners-Lee ("The Strawman Proposal"), and one from Sergey Melnick ("Simplified Syntax for RDF"). For non-RDF-afficionados, the serialization syntax is the representation of the RDF data model as XML. (Although XML is only one possible means of representing this information). While technical concerns have been raised about specific details of the RDF syntax, the main aim of simplification is to make it easier to generate RDF from existing (and future) XML documents--documents which were not produced with RDF applications in mind. Given the slow adoption of RDF, this seems a useful approach. While discussion of the finer points of the RDF syntax are no doubt beneficial, for developers seeking to gain some benefit from using RDF this transitional step from XML to RDF is important. An increasingly large amount of XML data coupled with a vast amount of HTML (suitably tidied for well-formedness) provides a rich data source for bootstrapping RDF applications... While it's too early to say whether RSS will its proving ground, RDF's supporters are keen to see more adoption. Dan Brickley has suggested to developers that effort should be spent on producing interoperability tests for the increasing range of available RDF parsers..."

• [June 28, 2000] RDF Tutorial. By Pierre-Antoine Champin. This document is a presentation of the Resource Description Framework (RDF) recommended by the World Wide Web Consortium (W3C), to model meta-data about the resources of the web. It is described in both documents [syntax] and [schema]; the former focuses on syntactical aspects while the later addresses the definition of vocabularies (often named schemas). Though this is a pragmatic approach, I will use a slightly different plan, more suited to my own goals (using RDF in knowledge representation systems). The first section will describe the RDF model, which is its fundamental syntax. The second section will present the semantic aspects of RDF, the concepts and the corresponding vocabulary. The last section will describe the XML syntax proposed in [syntax]."

• [February 26, 2000] XML Schema for RDF. "For anyone interested, appended is a stab at an XML Schema for RDF. It shows how abstract elements and equivClass is useful for constructing frameworks..." From Rick Jelliffe.

• [August 04, 2000] XSD for RDF by Dan Connolly. Revision of an XSD sketched by Rick Jelliffe. v 1.17 2000/08/04. [cache]

• [January 2000] Summary of Recent Discussions about an Application Programming Interface for RDF By Peter Hannappel, University of Essen, Germany. "This paper introduces a proposal for an RDF API standard made by the RDF interest community which discussed the topic in a newsgroup hosted by the W3C. Chapter 2 is dedicated to previous approaches to an RDF API. Chapter 3 describes the development of the API standard and displays its current status. In Chapter 4 an example of implementing the standard is introduced. The last chapter is used for describe future work that may be done on the API."

• [July 01, 1999] "Expressing the Dublin Core in the Resource Description Framework: Suggestions based on an early examination of the problem." By Ron Daniel Jr, Renato Ianella, and Eric Miller. Abstract: "The Dublin Core (DC) community is very interested in the Resource Description Framework (RDF). This is due to RDF's promise of becoming a widely-used means for the exchange and processing of resource descriptions. Those descriptions would not only come from the Dublin Core, but might spur the combination of packages along the lines of the Warwick Framework. The RDF-WG has recently produced a document that describes their data model and how it could be mapped to XML syntax. This paper looks at how Dublin Core descriptions might be encoded according to that paper. Based on that examination, we suggest directions of work for the RDF working groups." See also the URL http://www.ukoln.ac.uk/metadata/resources/dc/datamodel/WD-dc-rdf/.

• [May 02, 1999] "Towards the Semantic Web: Metalog." By Massimo Marchiori and Janne Saarela (The World Wide Web Consortium (W3C), MIT, INRIA). "The new W3C standard RDF (Resource Description Framework) describes a metadata infrastructure which can accommodate classification elements from different vocabularies i.e. schemas. The underlying model consists of a labeled directed acyclic graph which can be linearized into eXtensible Markup Language (XML) transfer syntax for interchange between applications.This paper will demonstrate how a new system, Metalog, allows users to write metadata, inference rules and queries in English-like syntax. We will demonstrate how these reasoning rules have equivalent representation both as RDF descriptions and as logic formulae. We will also show how an automated compilation between these translations is possible, showing the effectiveness of the system, which aims to be a first step towards the ambitious project of Tim Berners-Lee's semantic web. RDF provides the basis for structuring the data present in the web in a consistent and accurate way. However, RDF is only the first step towards the construction of what Tim Berners-Lee calls the semantic web, a World Wide Web where data is structured, and users can fully benefit by this structure when accessing information on the web. RDF only provides the 'basic vocabulary' in which data can be expressed and structured. Then, the whole problem of accessing an managing these data structured arises. Metalog provides a 'logical' view of metadata present on the web. The Metalog approach is composed by two major layers. The first layer consists in an enrichment of the RDF model. Metalog provides way to express logical relationships like 'and', 'or' and so on, and to build up complex inference rules that encode logical reasoning. This 'semantic layer' builds on top of RDF using a so-called RDF schema. We call this level of Metalog the Metalog model level. The second layer consists of a 'logical interpretation' of RDF data (optionally enriched with the semantic schema) into logic. This way, the understood semantics of RDF is unwound into its logical components. This means that every reasonment on RDF data can be performed acting upon the corresponding logical view, providing a neat and powerful way to reason about data. We call this level of Metalog the Metalog logic level..."[cache]

• [August 19, 1998] "RDF Made (Fairly) Easy." By John Cowan. Posted 20-June-1998. Revised as: "RDF Made Easy" 1998-08-19. [local archive copy]

• [June 07, 1998] "An Introduction to the Resource Description Framework." By Eric Miller [Online Computer Library Center, Inc.] In D-Lib Magazine (May 1998). [ISSN 1082-9873] Abstract: "The Resource Description Framework (RDF) is an infrastructure that enables the encoding, exchange and reuse of structured metadata. RDF is an application of XML that imposes needed structural constraints to provide unambiguous methods of expressing semantics. RDF additionally provides a means for publishing both human-readable and machine-processable vocabularies designed to encourage the reuse and extension of metadata semantics among disparate information communities. The structural constraints RDF imposes to support the consistent encoding and exchange of standardized metadata provides for the interchangeability of separate packages of metadata defined by different resource description communities."

• [August 12, 1997] A response to the incipient Resource Description Framework (RDF) proposal, in terms of the AFDR architecture mechanism (HyTime Second Edition): "Using the RDF Data Model as an SGML Architecture," by W. Eliot Kimber. The document summary: "Describes the author's attempt to use the Resource Description Framework (RDF) data model as an SGML document architecture conforming to the Architectural Forms Declaration Requirments annex of ISO/IEC 10744:1997 (HyTime Second Edition). Includes an explanation of RDF base architecture as well as examples of using that architecture derived from the examples used in the RDF working draft."

• "Why RDF?" - By Tim Bray (Textuality). "RDF stands for Resource Description Framework. This note describes why it exists and why you might want to use it."

• Article previewing the Resource Description Framework specification, from Eamonn Sullivan: "Developing a Card Catalog for the Expansive Web." Published in PC Week 14/36 (August 25, 1997) 34. "The emergence of XML in a more or less solid form earlier this year has provided a more comprehensive framework for metadata, prompting several organizations to propose solutions based on XML. The main proposals have been XML-Data from Microsoft which is available at www.microsoft.com/standards/xml/xmldata.htm) and MCF (Meta Content Format) from Netscape (available at www.w3.org/TR/NOTE-MCF-XML/). Both proposals provide for a sophisticated method to describe the structure of information, such as properties about authorship and relationships between objects. This week [August 25, 1997], a working group under the auspices of the W3C organization will meet in Redmond, Wash., to begin hammering out a specification that will take the best parts of XML-Data, MCF and PICS. The resulting RDF [Resource Description Framework] specification, if used widely, will enable more efficient searches and exchanges of information between organizations. [Extract]" The article is available online: http://www.zdnet.com/pcweek/opinion/0825/25isigh.html; [archive copy]

• "Meta Content Framework Using XML." By R.V. Guha and Tim Bray. "This document provides the specification for a data model for describing information organization structures (metadata) for collections of networked information. It also provides a syntax for the representation of instances of this data model using XML, the Extensible Markup Language." [cache]

• Description of RDF in the W3C 'Data Formats' Architecture. October 29, 1997. Note that PICS is being re-written to use RDF/XML, in the context of the P3P (Platform for Privacy Preferences) project. [local archive copy]

• [October 21, 1997] Announcement for a formal "consolidation of the relationship between the W3C and the DC community" based upon the Fifth Dublin Core [Metadata] Workshop, which endorsed Resource Description Framework. Excerpts: "The fifth Dublin Core Metadata Workshop was held October 6 to 8 in Helsinki, Finland. Seventy-five experts from libraries, the networking and digital library research communities, and a variety of content specialties gathered to continue the international consensus-building around the Dublin Core Metadata Element Set. Representatives from the World Wide Web Consortium (W3C) Resource Description Framework (RDF) working group presented interim results of the RDF specification effort at this meeting. . .Eric Miller of OCLC, Renato Iannella of the Distributed Systems Technology Centre, and Ralph Swick of the W3C showed how RDF addresses the architectural requirements for resource description that were identified at the Fourth Dublin Core Workshop in March of this year... Participants in the 5th Dublin Core workshop were unanimous and enthusiastic in their endorsement of the RDF as a critical component of the evolution of a metadata architecture for the Web... The RDF effort promises to provide the technical base for interoperable distribution of Dubin Core metadata and a wide variety of other types of metadata on the Web."

Software Tools for RDF

• See the W3C listing "RDF Developer Resources"

• RDF APIs - A list provided by Jason Diamond.

• [August 31, 2001]   Baltimore Technologies Releases RDFExpert as a Web-Powered Expert System for Generic Inference Tasks.    A posting from Graham Klyne (Baltimore Technologies) announces the availability of a prototype work-in-progess RDF-driven expert system shell. The RDFExpert software uses Brian McBride's JENA API and parser. Distributed as a single ZIP archive containing a number of Java .jar files, the application provides "a simple expert system shell that uses RDF for all of its input: knowledge base, inference rules and elements of the resolution strategy employed. It supports forward and backward chaining. The tool uses a special vocabulary to build arbitrary n-place predicate facts and rules. Other RDF statements are interpreted as binary facts (i.e., predicates with constant arguments). There is also a representation for n-place predicates that generalizes the normal RDF representation of binary facts." The RDFExpert web site provides a manual, sample test cases, and an overview document which outlines the influences, capabilities and future directions of a research project entitled the RDFExpert' undertaken at the strategic research department of Baltimore Technologies. Graham writes: "Craig Pugsley has been working on an experimental expert system shell that uses RDF for all of its input data (knowledge base, rules and 'control'). We can now use it to read arbitrary RDF from the web and perform inferences on that data. We have been exercising this capability using RDFweb/webwho data. A simple example query we have run is to list RDFweb people with a common interest... It is very much an experimental/prototype piece of software, and all the usual caveats apply about being provided as-is, without warranty, etc. Further developments under consideration for the tool include support for an inference rule format compatible with RuleML work; forward chaining from a designated set of facts; rules containing variable predicate names; extension of resolution strategy component to provide greater control over fact resolution process." [Full context]

• [August 15, 2001]   New Online RDF Validation Service from W3C Supports Data Model Visualization.    W3C has announced the availability of an online validation service for RDF (Resource Description Framework) documents. The new RDF validation service "is based on version 1.0.3 of the Another RDF Parser (ARP). ARP was created and is maintained by Jeremy Carroll at Hewlett-Packard Labs in Bristol." The RDF validation service at W3C was created and is maintained by Art Barstow of HP, visiting W3C Fellow at MIT. One may use the online validation service by entering a URI or copying an RDF/XML document into the text field of the HTML forms interface; a 3-tuple (triple) representation of the corresponding data model as well as a graphical visualization of the data model will be displayed. The graph is generated using the GraphViz open source graph drawing software from AT&T Labs. The servlet uses ARP, and thus depends on Xerces and SAX2 as documented at the ARP home page. The servlet source code is available from the W3C website. [Full context]

• [August 15, 2001]   Redfoot Version 0.9.9 Supports Improved Modularization and 'RedCode' Language for Combining Python and XHTML.    A posting from James Tauber and Daniel Krech announces the release of Redfoot version 0.9.9, with improvements designed to make it easier to write applications on top of Redfoot. Redfoot is a "framework for distributed RDF-based applications, written in Python. It includes an RDF database, a query API for RDF with numerous higher-level query functions, an RDF parser and serializer, a simple HTTP server providing a Web interface for viewing and editing RDF, and the beginnings of a peer-to-peer architecture for communication between different RDF databases. The developers plan to enhance Redfoot to include a complete peer-to-peer architecture for discovery of RDF statements, an inference engine, and connectors for mapping non-RDF data into RDF triples. The current 0.9.9 version available from the Sourceforge CVS repository represents a complete rewrite from the ground up, and has a much cleaner architecture that will support the continuing development of Redfoot well into 1.x and beyond. Version 0.9.9 should be viewed as a beta for version 1.0, to be released in the first half of September 2001. This release supports a cleaner notion of modules, with the beginnings of modules like RSS and authentication; it offers improvements to the 'RedCode' language for combining Python and XHTML." [Full context]

• [March 16, 2001] Extended DumbDown for Dublin Core metadata. From Stefan Kokkelink. Experimental. "I have set up an online demonstration of a (extended) dumb-down algorithm for Dublin Core metadata. There are several examples available, try the E[1-6] buttons. RDF documents using DC properties should be responsible for seeing that for every DC property (or subProperty) a meaningfull literal value can be calculated by the algorithm described below. Documents respecting this algorithm can use any rdfs:subPropertyOf or any additional vocabularies (e.g. for structured values) they want: the algorithm ensures that these documents can be used for simple resource discovery however complex their internal structue may be. Extended DumbDown algorithm: This algorithm transforms an arbitrary RDF graph containing Dublin Core properties (or rdfs:subPropertyOf) in an RDF graph whose arcs are all given by the 15 Dublin Core elements pointing to an 'appropriate literal'..."

• [March 09, 2001] "Representing UML in RDF." By Sergey Melnik. "A testbed converter that supports automatic translation from UML/XMI to RDFS/RDF/XML is available. The UML community developed a set of useful models for representing static and dynamic components of software-intensive systems. UML is an industry standard and serves as a modeling basis for emerging standards in other areas like OIM, CWM etc. As of today there exist a variety of UML vocabularies for describing object models, datatypes, database schemas, transformations etc. The goal of this work is to make UML 'RDF-compatible'. This allows mixing and extending UML models and the language elements of UML itself on the Web in an open manner. XMI, the current standard for encoding UML in XML by OMG, does not offer this capability. It is based upon a hard-wired DTD. For example, if a third party were to refine the concept 'Event' defined in UML statecharts into say 'ExternalEvent' and 'InternalEvent', it would not be possible to serialize the corresponding event instances in XMI." [Referenced in the 'xmlschema-dev@w3.org' list: "I'd like to support your initiative. In addition to the applications you mentioned, I see UML as well-established schema language that can be used on the Semantic Web along with RDF Schema, XML Schema, DAML-O etc. Webizing UML allows leveraging a broad spectrum of tools and existing UML schemas. I while ago I took a crack at setting up UML on top of RDF and making it interoperate with other schema languages: http://www-db.stanford.edu/~melnik/rdf/uml/." This post from Sergey was in response to a message by David Ezell on a 'Proposed UML Interest Group.']

• [February 22, 2001] Intellidimension Announces RDF Gateway Technology Release. Geoff Chappell announced a technology release of 'RDF Gateway' Version 0.1 by Intellidimension, Inc.. RDF Gateway is "an RDF-based semantic query service for distributed data. The query service uses RDFQL, a simple SQL-style language with inference extensions to perform complex deductive queries. Queries can be executed over a wide range of dynamic data by connecting to one or more Data Services. Data Services expose structured data as a collection of RDF statements. The release contains Data Services for File Systems, RDF Memory Repositories, RDF Database Repositories, OLEDB Providers and RDF Files. The query service is exposed to applications via an ADO/OLEDB interface.

• [February 09, 2001] RDF-Crawler Knowledge Base Tool. Siegfried Handschuh (Institute AIFB, University of Karlsruhe, Germany) announced the availability of an RDF-Crawler. It is a java-based tool/API which downloads interconnected fragments of RDF from the Internet and builds a knowledge base from this data. The development team plans to make the crawler a windows application as well (using Java Swing). Implementation follows the design presened in the document "Specification of an RDF Crawler." In part: "Ontology servers and other tools dealing with meta information sometimes need to retrieve facts describing resources on the Web. he current standard of making statements about Web resources is RDF (Resource Description Framework), and there are a few more standards which build on top of the RDF, e.g. RDFS and OIL. Therefore we may need a utility to download RDF information from all over the Internet. This utility will be henceforth called RDF Crawler. It is a tool which downloads interconnected fragments of RDF from the Internet and builds a knowledge base from this data. At every phase of RDF crawling we maintain a list of URIs to be retrieved as well as URI filtering conditions (e.g. depth, URI syntax), which we observe as we iteratively download resources containing RDF. To enable embedding in other tools, RDF Crawler provides a high-level programmable interface (Java API). RDF Crawler utility is just a wrapper around this API - either a console application, or a windows application or a servlet. The tool is available for download, together with online API documentation. Note: "Currently the RDF Crawler is tested only on the Windows platform, using Java Version 1.3. You can get it from http://java.sun.com - either as JDK (Java Developer Kit) for development, or JRE (Java Runtime Environment) just for running this program. Linux/Unix platforms may cause problems in a few places where we use Windows-style filepaths, but they could be easy to correct."

• [January 31, 2001] Protégé-2000 Version 1.5 Supports RDF and RDF Schema Editing. Ray Fergerson and members of the Protégé Project at Stanford Medical Informatics (SMI) have announced the release of Protégé-2000 Version 1.5 which supports RDF and RDF Schema. "Protégé-2000 is open-source software and is written in Java. It provides an integrated knowledge-base editing environment and an extensible architecture for the creation of customized knowledge-based tools... The Protégé-2000 tool allows the user to construct a domain ontology, customize knowledge-acquisition forms, and enter domain knowledge; it provides a platform which can be extended with graphical widgets for tables, diagrams, animation components to access other knowledge-based systems embedded applications; it constitutes a library which other applications can use to access and display knowledge bases... Protégé-2000 is a knowledge-based systems development environment that can be used to edit RDF and RDF Schema (and other languages). We have enhanced our RDF support in this release in a number of ways. We have eliminated the need to use RDF specific metaclasses inside of Protégé and automatically convert Protégé concepts to the closest equivalent RDF concept. This gives a much more natural way of working with RDF in the Protégé environment. For those modeling elements in Protégé that do not have a corresponding RDF mapping (such as a restriction that a property be single-valued), we give users the option of either (1) discarding this information on save to produce very clean RDF, or (2) keeping the information as additional Protégé specific properties. We are also using Sergey's latest RDF API implementation which is quite a bit faster for large projects. A simple guide to how to work with RDF in Protégé-2000 is available from the 'RDF Support' link in our User's Guide, A more detailed look at RDF and Protégé-2000 is also available online. The new RDF backend has been designed specifically to be extensible for translation to other RDF based languages such as OIL and DAML. We are exploring the possibility of supporting these languages at a later date. If you would be particularly interested in such support, please send us a message to let us know."

• [December 13, 2000] "A Proposed Interpretation of RDF Containers." By Brian McBride (HP Labs) and Dave Beckett (ILRT, University of Bristol). Draft 1.0, 13th December 2000. "The RDF formal grammar defined in the Model and Syntax Specification [1] is ambiguous. Containers such as rdf:Bag, rdf:Seq and rdf:Alt match the container productions 6.25 through 6.31, but also match the typedNode production (6.13). The container productions attempt to restrict what the language can express about containers, but the ambiguity in the syntax effectively circumvents those restrictions. It is not clear what parsers should do if they encounter an rdf:li element when processing productions other than the container specific productions of the grammar. Sub-classes (described by rdfs:subClassOf) of the container classes do not match the container specific productions in the formal grammar. M&S states that these productions should be extended to included stuctures that are rdfs:subClassOf of rdfs:Container. Processing this requires parsers to process the class structure resources in a document, which some do not do. It also requires that the class structure must be included in any XML serialization. Some of these issues have been raised previously and are recorded in the RDF issues list. We recognise that other issues about containers have been raised whose resolution require changes to the specification. We consider changes to the specification to be beyond the remit of this document, and thus we do not address them here..."

• [January 08, 2001] "The RDFSuite: Managing Voluminous RDF Description Bases." By Sofia Alexaki, Vassilis Christophides, Greg Karvounarakis, and Dimitris Plexousakis. ['We would like to announce RDFSuite, a set of tools for parsing, storing and querying RDF metadata. We invite interested readers to send us their comments and/or suggestions.'] "Metadata are widely used in order to fully exploit information resources available on corporate intranets or the Internet. The Resource Description Framework (RDF) aims at facilitating the creation and exchange of metadata as any other Web data. The growing number of available information resources and the proliferation of description services in various user communities, lead nowadays to large volumes of RDF metadata. Managing such RDF resource descriptions and schemas with existing low-level APIs and file-based implementations does not ensure fast deployment and easy maintenance of real-scale RDF applications. In this paper, we advocate the use of database technology to support declarative access, as well as, logical and physical independence for voluminous RDF description bases. We present RDFSuite, a suite of tools for RDF validation, storage and querying. Specifically, we introduce a formal data model for RDF description bases created using multiple schemas. Compared to the current status of the W3C standard, our model relies on a complete set of validation constraints for the core RDF/S (without reification) and provides a richer type system including several basic types as well as union types. Next, we present the design of a persistent RDF Store (RSSDB) for loading resource descriptions in an object-relational DBMS by exploring the available RDF schema knowledge. Our approach preserves the flexibility of RDF in refining schemas and/or enriching descriptions at any time, whilst it ensures good performance for storing and querying voluminous RDF descriptions. Last, we briefly present RQL, a declarative language for querying both RDF descriptions and schemas, and sketch query evaluation on top of RSSDB." Also in HTML and Postscript formats. [cache]

• [December 07, 2000] Squish RDF Query Tool Released. Libby Miller has posted an announcement for an alpha release and demonstration of 'Squish' - a Java tool for processing complex RDF queries. "Squish is demonstration software written in Java for making complex queries of RDF on top of Java RDF APIs such as Jena and the Stanford RDF API. The SQL-like query language it uses is similar in some aspects to that used by R.V. Guha's rdfDB, and allows you to make complex queries of RDF models instead of navigating incrementally around them. Squish also uses the JDBC API to make RDF querying easier over RDF stored in SQL databases (Postgres) or in in-memory models. The distribution includes the Java servlet runner Tomcat, and sample JSPs for querying RDF databases using JDBC, including a JSP which allows you to generate and display RSS 1.0 channels. This implementation is intended to demonstrate the possibilities of this approach, and is only appropriate for extremely small scale use. Comments are very welcome."

• [November 02, 2000] RDFStore. Alberto Reggiori has announced the availability of RDFStore. RDFStore is a set of Perl modules to manage Resource Description Framework (RDF) model databases in a easy and straightforward way. It is a pure Perl implementation of the Draft Java API from the Stanford University DataBase Group by Sergey Melnik with some additional cool modules to read/write RDF triples directly from the Perl langauge environment. By using the Perl TIE interface, a generic application script can access RDF triplets using normal key/value hashes; the storage can happen either in-memory data structures or on the local filesystem by using the DB_File.pm or BerkeleyDB.pm modules. An experimental remote storage service is also provided using a custom DBMS.pm module coupled with a fast and performant TCP/IP deamon. The deamon has been written entirely in the C language and is actually storing the data in Berkeley DB v1.x files; such a software is similar to the rdfbd approach from Guha. The input RDF files are being parsed and processed by using a streaming SiRPAC like parser completely written in Perl. Such an implementation includes most of the proposed bug fixes and updates as suggested on the W3C RDF-interest-Group mailing list [and SiRPAC discussion]. A strawman parser for a simplified syntax proposed by Jonathan Borden, Jason Diamond and Dan Connolly is also included. By using the Sablotron XSLT engine is then possible to easily tranform XML documents to RDF and query them from the Perl language. Initial RDFStore features include: (1) Modular interface using packages; (2) Perl-way API to fetch, parse, process, store and query RDF models; (3) W3C RDF and strawman syntax parsing; (4) Perl TIE seamless access to RDF triplet databases; (5) Either DB_File and BerkeleyDB support; (6) Automatic Vocabulary generation; (7) Basic RDF Schema support; (8) Initial TCP/IP remote storage service support." [cache] See also the announcement for the release of RDFStore version 0.31.

• [October 30, 2000] Wolfram Conen recently announced RDF Schema Explorer -- a service based on Jan Wielemaker's SWI-Prolog (3.4.0), his SGML/RDF parser and an adaptation of his CGIServ code. RDF Schema Explorer can be used as follows: "(1) You can feed some RDF into the Explorer, either by keying it directly into the text field below or by uploading a file. This will be parsed with Jan Wielemaker's SWI-Prolog parser and the resulting triples will be asserted to the fact base. (2) You can check/validate your model against the rule set provided in version 1.2 of the paper 'A logical interpretation of RDF.' (3) You can query the model repeatedly by using the provided rule/fact set and by providing your own additional rules/queries. (4) You can define/extend the semantics for your own predicates directly from within your RDF document, along the guidelines presented in RDF Semantic Extensions. Version 1.2 of the paper 'A logical interpretation of RDF' is currently under public review in the Semantic Web (SEWEB) area of the web site Electronic Transactions on Artificial Intelligence (ETAI), where it is possible to comment/discuss the paper."

• [October 27, 2000] Redland Web Demo. Dave Beckett wrote on 27-Oct-2000: "I've just created a relatively stable web interface to Redland so you can try out the parsing (3 parsers), querying and storage of RDF. Note that the error/warning reporting from the parsers is pretty non-existant at the moment, so if you get 0 statements returned from a parse, something probably went wrong(!). The command line tools can be used to see it. Redland home page."

• [October 13, 2000] James Tauber (Director XML Technology, Bowstreet) has posted an announcement to the W3C 'www-rdf-interest@w3.org' mailing list for the release of Redfoot Version 0.9.0. "Redfoot is a store/viewer/editor framework for RDF that includes peer-to-peer communication between stores. It is written in Python by James Tauber and Daniel Krech, with open source development hosted on SourgeForge. "At present, Redfoot includes: (1) an RDF database; (2) a query API for RDF with numerous higher-level query functions; (3) an RDF parser and serializer; (4) a simple HTTP server providing a web interface for viewing and editing RDF; (5) the beginnings of a peer-to-peer architecture for communication between different RDF databases. Although the peer-to-peer functionality is embryonic, the RDF viewing/editing capabilities are of beta quality... In the future, Redfoot will hopefully include: (1) a full peer-to-peer architecture for discovery of RDF statements; (2) an inference engine; (3) a fully customizable UI; (4) connectors for mapping non-RDF data into RDF triples; (5) sample applications built on top of Redfoot. Redfoot is written in pure Python and is being tested on Python 1.6 and 2.0b1 (soon 2.0b2). Redfoot makes extensive use of callbacks as a means of processing RDF structures rather than building large temporary data structures in memory. For other details, see the development documentation.

• [October 10, 2000] Jason Diamond (injektilo.org) announced the the preview release of an open source RDF Parser written in ANSI C. "The parser is dubbed repat since both its interface and implementation is a callback-based RDF parser based on James Clark's expat; it is available for download from http://injektilo.org/rdf/repat.html. While the parser is not quite ready for prime time, it does -- to the best of my knowledge -- correctly parse all of the examples in the W3C " RDF Model & Syntax Specification. I'm looking for feedback on its usability and also on its stability. I'm hoping that it will compile on platforms other than my own (Windows) without any changes. In order to correctly handle all of the examples from the M&S, I took the liberty of 'enhancing' the syntax described therein but not strictly prescribed to by its authors. The syntax is much more flexible and -- in my opinion -- more internally consistent. For example, I've removed the somewhat arbitrary restrictions placed on container descriptions and rdf:li elements which can now contain embedded resources as objects. The web site documentation for 'repat' provides a brief overview of how the parser works and also details my list of issues with the syntax and how I resolved them; these are mostly rehashes of several of my messages to the list. I'm looking forward to your comments, criticisms, and patches. repat will be released under an open source license... 'repat' was originally based on David Megginson's RDFFilter but has changed signifigantly since its inception; any bugs or deficiencies were undoubtedly introduced by myself." Note also the XSLT RDF Parser on the injektilo.org web site. On RDF, see also RDF developer tools listed on the W3C web site.

• [October 02, 2000] RDFMaker. RDFMaker produces a set of RDF statements that represent the semantic information that has been annotated on HTML pages according to the annotation language HTML-A of Ontobroker. A second version of it can materialize a whole knowledge base into RDF facts that is valid concerning the translated version of an F-Logic ontology into RDF-Schema. Sample: RDFMaker translated the KA2-knoweledge base into a large RDF-fact-file. Compare also the RDF-Schema for the KA2 ontology." From Michael Erdmann, Research Group for Knowledge Management.

• [September 28, 2000] Jonas Liljegren recently announced the first alpha release of (Perl) RDF::Service from the Wraf (SourceForge) project. Wraf (Web Resource Application Framework) implements a RDF API. The purpose is to enable the construction of applications that fully uses the RDF data model in order to realize the Semantic Web. (1) All data is described in RDF (2) The User Interface is defined in RDF. Data presentation will be dependent on the user profile, situation context, and just what information can be found from trusted sources. (3) All functions and program code are named, described and handled as RDF Literals. Running an application can result in method calls to services on other internet servers. New functions could by reference transparently be downladed and executed from trusted sources. The actual code is Perl but the system could be extended to recognize other languages. (4) The development of applications is done in the same system used to run the application. Wraf will be extended and developed from within iteself. Wraf uses interfaces to other sources in order to integrate all data in one enviroment, regardless of storage format. You can read and update information from configuration files, databases, XML files, LDAP, etc. The system will use intelligent caching and optimizations in order to gain in speed without sacrifice any flexibility. A persistant backend service deamon will take requests from clients in mod_perl. Other non-browser interfaces could also use the service. Wraf will be idealy suited for complex, interconnected systems there the addition of new data often breakes the previous format and the exceptions is the rule. It can be used for personalized content generation, topic communities, intranets and more."

• [September 29, 2000] Dave Beckett (Institute for Learning and Research Technology, University of Bristol) announced the release of Redland version 0.9.4 with a new Perl interface and added support for Linux RPM binaries. Redland (An RDF Application Framework) "is a library that provides a high-level interface for RDF allowing the model to be stored, queried and manipulated. Redland implements each of the RDF model concepts in its own class so provides an object based API for them. Some of the classes providing the parsers, storage mechanisms and other elements are built as modules that can be added or removed as required. Redland provides: (1) A modular, object based library written in C; (2) C and Perl APIs for manipulating the RDF Model and parts -- Statements, Resources and Literals; (3) Parsers for importing the model from RDF/XML syntax [both parsers external at present]; (4) Storage for models in memory and on disk via Berkeley DB [SleepyCat]; (5) Query APIs for the model by Statement (triples) or by Nodes and Arcs; (6) Statement Streams for construction, parsing, de/serialisation of models." Beckett has created an eGroups list for the software at http://www.egroups.com/group/redland/ and invites interested parties to join the mailing list and development effort. At present Redland has no built in RDF/XML parser, so if you want to parse RDF/XML, you will have to download an external parser, either the W3C libwww C or the Java API RDF Parser (based on SiRPAC), as described in the installation document. A Python interface for Redland is now being designed, and work has begun on an internal RDF parser. The sources are available for download from main web site or from SourceForge. The code library is free software / open source software released under the LGPL or MPL licenses.

• [September 22, 2000] Michael Sintek announced the release of an RDF Schema visualization tool named 'FRODO RDFSViz'. The FRODO RDFSViz tool "provides a visualization service for ontologies represented in RDF Schema. It uses the Java RDF API implementation (from Sergey Melnik) and the Graphviz graph drawing program (from AT&T and Lucent Bell Labs). The tool creates simple class diagrams where classes become vertices and rdfs:subClassOf relations become edges. Optionally, properties with rdfs:Class-valued domains and ranges are also visualized as (labeled) edges. Future extensions are planned, e.g., to show properties with range rdfs:Literal or to support the strawman syntax. If you want to visualize general RDF models, you may use the RDF graph visualization tool Rudolf RDFViz (from Dan Brickley). The FRODO RDFSViz tool was implemented in the FRODO project (A Framework for Distributed Organizational Memories) at DFKI Kaiserslautern (German Research Center for Artificial Intelligence)." An online demo (which uses a Java servlet) and the download distribution (binary and source, command line and servlet versions) are available via the project web site. Online examples of tool output include: (1) The newspaper ontology from the Protégé-2000 tool which has experimental support for editing RDF schemas and instance data; (2) Searchable Internet services example from the RDF Schema specification. The developers (Michael Sintek and Andreas Lauer) welcome user comments, bug reports, and ideas for improvements.

• [September 21, 2000] Jonathan Borden (of The Open Healthcare Group) posted an announcement for an XSLT-based RDF extractor for XML. "In my investigations of simplfied XML syntax for RDF, and extracting RDF from arbitrary or colloqial XML, I have now come to the conclusion that the essence of TimBL's strawman, in which rdf:parseTyle='Resource' is the default, provides the best option for extracting RDF statements from XML. I have incorporated Jason Diamond's rdf.xsl into a new implementation of an XSLT based RDF extractor for XML. This extractor outputs rdf:Statements. Interestingly, when the result of a transform is itself transformed, the statements are reified, hence I call this rdfExtractify.xsl. A brief list of its features: (1) It implements XLink2RDF, now for extended XLinks as well; (2) It extracts RDF statements from plain 'ole XML; (3) It extracts RDF statements from RDF with defaultParseType='Resource' -- this is a param; (4) It handles collections, aboutEach and bagID; the syntax for collections is loosened so that any child element can be a member (need not only be <rdf:li>) (5) It implements QNameToURI -- see http://www.openhealth.org/RDF/QNameToURI.htm -- which converts namespace qualified names to URIs; (6) It implements nodeIdentifier which produces an XPointer fragment identifier e.g., #xpointer(/foo[1]) or ChildSeq identifier e.g., #/1/2 (see the XPointer spec), the type of XPointer produced is set in the explicitPathIndices = 'ChildSeq' (default) param. See now the updated: Extracting and reifying RDF from XML with the sources and online forms-based 'extractifier'.

• [September 20, 2000] Eric van der Vlist (Dyomedea) recently announced the availability of a Java interface for rdfDB (a RDF open source database) which can be used within an XT/XSLT transformation. The Java interface, as described on the 4xt.org web site, allows one to "get the results back in plain Java and/or from a a XT/XSLT transformation. RdfDB is a simple, scalable, open-source database for RDF developed by R.V. Guha. rdfDB uses a high level SQLish query language. The data is modelled as a directed labelled graph (RDF), where nodes in graph can be resources, integers, or strings. The new Java interface allows querying the database using its query language and to get the results back row by row and column by column in plain Java and/or as a result tree fragment in a XT/XSLT transformation. It is currently used on the web site XMLfr, where a full site summary has been loaded into rdfDB as three RSS 1.0 channels using the DC and taxonomy modules. . . One of the examples provided in the download section (2rss) shows how specific RSS channels for a topic can easily be generated using the interface, allowing to close the loop: the rdfDB fed by RSS channels can generate RSS channels."

• [September 20, 2000] 4RDF. 4Suite from Fourthought.com provides Open-Source Tools for standards-based XML, DOM, XPath, XSLT, RDF and object-database development in Python. "4Suite is a collection of Python tools for XML processing and object database management. An integrated packaging of several formerly separately-distributed components: 4DOM, 4XPath and 4XSLT, and featuring the new 4RDF and 4ODS. 4RDF is a Python library and toolkit for processing Resource Description Framework (RDF), a standard mechanism for maintaining meta-data in distributed application, particularly the Web. 4RDF provides a serialization and deserialization of RDF, tools to manipulate RDF statements in the resulting model, and for managing persistence of the RDF model. . . The 4RDF API: There is no standard API for RDF processors. We put together a simple, clean API that suits our uses of RDF very well. Other APIs are SIRPaC, RAX and..., none of which are supportd by 4RDF now." See the article of 2000-10-11.

• [September 07, 2000] Daniel Dardailler announced the availability of an 'SVG RDF tool': "With the summer over, I'm happy to release the work of a student we had here in Sophia, working on an SVG-to-text converter, using RDF statements to help with the inherent graphical semantics. The report, the tools and the schema are all at http://www.w3.org/WAI/ER/ASVG/. The 'SVG Linearizer Tools' project of Guillaume Lovet involved writing an SVG-to-text converter in three different steps: (1) The development of an RDF vocabulary, allowing the description of an SVG document (pictures, schemas, graphics), in order to make the information carried by such a document accessible, regardless of the support at one disposal to exploit it (computer screen, speaker, tactil screen). (2) The development of a tool (written in Java) able to exploit such an RDF description, thus using the elements of the previous vocabulary. The results of the proceeding will have to be presented in a textual form, ready then to be exploited by various accessibility tools (for example, a vocal module or a 'Braille' screen for people with visual impairment). (3) Eventually, the development of another tool (in Java again) implementing the edition process of an SVG document, in order to attach a description oriented to its accessibility. The user of such a tool will have few or no RDF notions, therefore the edition process will have to be as tranparent, simple and graphic as possible." The RDF vocabulary "is made of 29 properties (or words); this vocabulary forms the namespace axsvg (for Accessibity SVG), and has an associated RDF Schema. Most of these properties are 'by reference', i.e., in the RDF statement for which they are the predicate, the subject and the object are some 'entities' of the SVG document, identified by their 'id' attribute. [E.g., Structural: "Regroups, IsConvergencePoint, IsConnected, IsPartOf, PointsTo, Links, Contents, IsFatherOf, Has, SitsOnTop, HasOnTop, IsGoingThrough, IsLayeredOn, HasForValue, Associated"; Geographic: "AtRight, AtLeft, IsBehind, IsOver, InFrontOf, MaskedBy, On, Under"; Graphic properties, Special Properties, etc. The report also describes a Java translator and Java Editor.

• [August 2000] W3C Site Summary Dan Connolly (W3C): "Following the recent (Aug 2000) announcement of RSS-ala-RDF, and my notes on Semantic Web screen scraping (e.g. HyperRDF), I developed this little transformation that turns the W3C home page into RSS.

• [July 25, 2000] rdfDB : An RDF Database. "RDFdb is an open source (under the MPL) scalable triple database server with a SQL-like front end. Its written in C with a perl client." From R.V.Guha. The goals of this project are to build a database that is capable of (1) Supporting a graph oriented API via a textual query language ala SQL; (2) Load/Reload an RDF file from a url into the database; (3) Scalable to millions of nodes and triples; (4) Provide support for RDF Schemas; (5) Provide support for some basic forms of inferencing; (6) Provide both C and Perl access to the database; (7) The Perl philosophy applies: 'Simple things should be simple and complex things should be possible.'

• [July 20, 2000] "HyperRDF: Using XHTML Authoring Tools with XSLT to produce RDF Schemas." From Dan Connolly (W3C).

• [March 16, 2000] RDF Filter From David Megginson. RDF Filter (1.0alpha) is "a streaming, Java- and SAX2-based filter and handler interface for RDF processing. Unlike DATAX, this interface does not build an in-memory tree, and should be suitable for very large RDF documents. The beginnings of a general-purpose RDF test suite are included with the distribution."< Announced: David Megginson has announced the availability of an alpha version of 'RDFFilter'. "I'm happy to announce the first release of RDFFilter 1.0alpha, a Java- and SAX2(beta)-based package for processing RDF documents, together with a small bundled RDF test suite. Download information is available at http://www.megginson.com/Software/. RDFFilter uses a relatively simple callback-based interface, and unlike DATAX, it doesn't build any in-memory trees, so it's suitable for use with very large documents." ['The Java-based DATAX library greatly simplifies reading and writing XML documents for data exchange in any RDF-compliant XML document type. DATAX is currently in beta, and its creation was funded by Muze, Inc., the leading provider of databases for music, books, and video.']"

• [January 05, 2000] A communiqué from Greg Karvounarakis reports on the release of VRP, an ICS-FORTH Validating RDF Parser. "I am glad to announce the public distribution of the ICS-FORTH Validating RDF Parser (VRP). VRP is the first RDF parser offering full-fledged validation of RDF statements against an RDF Schema. Furthemore, it supports validation of RDF Schemata themselves which can defined in several namespaces. Principal features include: (1) 100% Java 1.2 development; (2) Understands embedded RDF in HTML or XML; (3) Full Unicode support; (4) Semantic and syntax checking of both RDF Schemata and Metadata instances; (5) Statement validation across several RDF/XML namespaces; (6) Based on standard compiler generator tools for Java (CUP/JFlex); (7) Easy to use and integrate with other software."

• [December 16, 1999] "Simplified Syntax for RDF." By Sergey Melnik. "This is a complementary proposal for a simplified RDF syntax inspired by Tim's strawman draft. A reference implementation is available [RDF API Draft]. Requirements for the syntax: (1) simplicity: self-explanatory; (2) as context-free as possible; (3) allow mixing XML with RDF. XML attributes controlling the behavior of the RDF processor that are used in this document are: rdf:instance (says that the containing tag is a class name) rdf:for (the containing tag is a property name, the value of the attribute is the subject URI) rdf:resource (the containing tag is a property name, the value of the attribute is the object URI)..."

• [August 27, 1999] S-Link-S MetaData Editor for RDF (Alpha). Eric Hellman posted an announcement for an alpha version of an 'S-Link-S MetaData Editor', from Openly Informatics. This is a tool "for creating and publishing RDF metadata using our S-Link-S RDF vocabulary for Journal Hyperlinking. We'd very much like to get feedback from the RDF community. The application is available for free download. Some features that may be of interest: We read comments, labels, and choices in directly from the RDF Schema file, and from a RDF configuation file. This is done with a SAX parser on XML4J. RDF is used as the output format. We built the application to shield our users from RDF as much as possible. A typical [desired] comment from potential users: 'We're wondering if we should use RDF for other applications; what is it really?'"

• [August 20, 1999] Release of DATAX: Data Exchange in XML. A communiqué from David Megginson (Megginson Technologies Ltd.) reports on the availability of a new library, DATAX. DATAX: Data Exchange in XML is "a new Java 1.2 based library which greatly simplifies exchanging structured data records using XML written in any RDF-compliant format. It requires no built-in knowledge of specific document types. The current version of DATAX is 1.0beta, and a stable 1.0 version is expected in Fall 1999. DATAX is based on the Java2 Collections package, so it will integrate easily with other Java components. The DATAX 1.0beta Java release is intended for evalution and testing purposes only. DATAX requires Java 1.2 or higher, the SAX 1.0 interface library (included in the distribution as sax.jar), and an XML parser with a SAX driver (Microsoft's aelfred.jar is included in the DATAX distribution)." DAXAT provides support for much (but not all) of the W3C RDF-Syntax Recommendation, available from the World Wide Web Consortium Web site. "RDF (the Resource Description Framework) is a set of conventions for encoding information about entities and their attributes and relationships. RDF was originally designed to provide metadata for Web pages, but it is useful for serializing and exchanging information about objects of any type. The DATAX library is not designed as a general purpose RDF implementation: it is possible to export a DATAX entity set to RDF and then import it again without loss, but if you are planning to import RDF files from other sources, it is important to note that some of the more obscure RDF features are not currently supported by the com.muze.datax.rdf.RDFReader class. The development of DATAX has been funded by Muze, Inc., a "leading provider of database information for music, books, and video. It is Muze's intention to release DATAX as free, open-source software once the beta period is ended." For further description, see the DATAX Roadmap of Java classes, with links to JavaDoc documentation. See also David Megginson's presentation abstract from the Montréal XML Developers' Conference, "Struggling with RDF" and in the [subsequent] announcement. Comments and questions may be directed to datax@megginson.com.

• [February 16, 1999] Validation: "As far as validating RDF, you might be interested in a little note I wrote "Using XSL to Validate Structured Documents". You can use XSL to write a very simple validation program that gives nice error messages and works with wrappers or islands." - Rick Jelliffe.

• [August 05, 1998] Janne Saarela (W3C) posted a notice for the availability of SiRPAC - a Simple RDF Parser & Compiler. Summary: "The program compiles RDF/XML documents into the triples of the corresponding RDF data model; it is suitable for embedded use as well as command line use. It is designed as a reference implementation of an RDF parser which does a compilation process from XML encoding syntax to the triples of the underlying data model. SiRPAC builds on top of the Simple API to XML documents (SAX). There is also an online compilation and visualization service using SiRPAC: 'enter/paste here a new RDF entry and send it to the server; the server will produce you the triples of the corresponding data model and provide a visual browsing tool within the data model'. SiRPAC has been implemented at the World Wide Web Consortium within the W3C-LA project." The author says: "I've been working on a program which compiles RDF/XML source files to triple representation of the corresponding RDF data model. I believe the software is now stable enough for the public to try it out. You can find the documentation with links to an interactive compilation and visualization service at http://www.w3.org/RDF/Implementations/SiRPAC/."

• [April 19, 1998] RDF for XML. An IBM Alphaworks project [coordinated by] Neel Sundaresan, IBM Almaden Research Center. RDF for XML is "a Java implementation of the RDF specification for creating technologies that search for data and describe, categorize, rate, and otherwise manipulate the data. This RDF processor builds, queries, and manipulates RDF structures, and it serializes and de-serializes them to and from XML forms. As a foundation for processing metadata, RDF for XML provides inter-operability between applications that exchange machine-understandable information on the Web. RDF for XML describes resources and their properties in a domain-independent way. It can be used in a variety of areas, including resource discovery for search engines, cataloging for describing contents, content rating, and so on. This implementation of RDF uses XML as its encoding syntax and conforms to the working draft dated 02/16/98 of the RDF Syntax and Model working group of the W3C." See the Web site for the FAQ document and download information. Also: Developer Tools: RDF for XML. [alt URL]

• I have an RdfParser that runs on top of Expat (or my own cheesy perl XML parser). See: http://www.w3.org/People/Eric/RdfDB.alpha4.tar.gz - Eric Prud'hommeaux, eric@w3.org

• [April 19, 1998] RDF in Mozilla.

Other RDF Resources

• "Dave Beckett's Resource Description Framework (RDF) Resource Guide." A large resource collection on RDF, maintained by Dave Beckett (ILRT, University of Bristol, UK.)

• RDF-DEV Resource Directory. "This is the RDF-DEV directory of metadata, RDF and XML resources. You can either browse the directory or search for keywords using the [online] form."

• "RDF Site Summary (RSS)." "RSS ('RDF Site Summary') is a lightweight multipurpose extensible metadata description and syndication format. RSS is an XML application, conforms to the W3C's RDF Specification and is extensible via XML-namespace and/or RDF based modularization."

• DMOZ 'ODP' RDF Resources

• [June 21, 1998] An annnouncement was posted by Dan Brickley (Research and Development Unit, Institute for Learning and Research Technology, University of Bristol) for a new discussion list, RDF-DEV. RDF-DEV hosted by UK's Mailbase service.