Judging by the semantic blogs and lists, OWL-S, a vocabulary for describing web services in RDF, seems to be the hot schema of the moment. So, with a view to producing some OWL-S documents for the SchemaWeb web services, I have downloaded the example files and have started reading up the specs starting with Semantic Markup for Web Services.

Firstly congrats to the team for producing high quality documentation. These specs are concise and very readable.

The story I've gleaned so far is that in OWL-S a 'service' consists of three things.
1. A profile that describes what the service does. A high level description that provides a publication and discovery framework for clients and service providers. This is the UDDI bit.
2. A process model that describes how the service works in terms of IOPEs (input, output, preconditions and effects). This is an abstract description of a service.
3. A grounding which describes how to use and physically interact with a service. This covers protocols, message formats, URLs and ports etc. Similar to the 'concrete' bits of WSDL (<binding/> and <service/> elements). In fact WSDL and OWL-S are complementary and are used together to define SOAP web services in OWL-S. So don't throw away your wisdels yet!

Some first impressions and comments.
OWL-S combines the functionality of UDDI and WSDL in one model. +1.
OWL-S allows for reverse directories where clients do the advertising and service providers do the discovering; this is not possible with UDDI.
OWL-S allows 'complex' long running processes 'composed' of many web service calls to be described. This is an obvious advantage over WSDL which has a more highly grained focus and describes only individual web methods. This ability to create and advertise high level services will be good for clients and discovery and also allow third parties to aggregate diverse services and add value.
This is a complex specification. If you have slagged off WSDL in the past as too hard then you might change your mind after looking at OWL-S. And roll on tool support because I don't think there's going to be much hand coding of this baby!

Want to play at Semantic Web?

The .Net RDF parser that drives SchemaWeb is now available under a Creative Commons Attribution-ShareAlike license.

VicSoft.Rdf Parser binaries, source and documentation are at:
http://www.schemaweb.info/parser/Parser.aspx

This lightweight smush and query software component was developed on Windows. However it should run with Mono for those who work on the sunny side although this is un-tested.

VicSoft (makers of Buddy Browser FOAFware) announce the launch of SchemaWeb, an on-line directory of RDF schemas expressed using the RDFS, OWL and DAML+OIL schema vocabularies.

SchemaWeb provides (hopefully) a one stop shop for developers and designers working with RDF. It gathers schema data and meta-data in a single portal and offers both on-line forms and web services for access to RDF schema information by both human users and RDF software agents.

SchemaWeb is at:
http://www.schemaweb.info/

Your feedback is welcome.

For the first time since 1997 and the first Microsoft XML toolkit / parser, I have had to hack into XML files using regular expressions (arrrrrg!) in order to get a valid XML document to load into Microsoft XML tools.

An example of this type of XML is:

<?xml version="1.0"?>
<!DOCTYPE root [
<!ENTITY ns "http://www.some.com/schema">
]>
<root xmlns="&ns;">
<foo>Some foo</foo>
<bar>Some bar</bar>
</root>

The author of this type of XML is using a general entity to represent the default namespace uri. Both XmlDocument and XmlValidatingReader barf on this file with an error of:

System.ArgumentException: Prefixes beginning with "xml" (regardless of whether the characters are uppercase, lowercase, or some combination thereof) are reserved for use by XML.

So is this a valid XML document? Although using general entities in this way seems to be pushing the envelope a bit (Are namespaces part of the XML data or do they sit in a layer above the data?), I have seen quite a few examples in this style on the W3C site so I assume it is valid. So in order to deal with this type of XML, I have had to write code using tedious regular expressions to manually find and replace the offending entities prior to loading into .Net XML classes.

Which brings me to my point and request. How do I report this bug to the MS XML team? I have looked on Technet and MSDN but cannot find a way to do this.

Wow, two very hot articles on XML.com.

Mark's piece on Atom and RDF (sorry - we failed the audition) and Kendall's on OWL.

http://www.xml.com/pub/a/2003/08/20/dive.html
http://www.xml.com/pub/a/2003/08/20/deviant.html

So Atom is XML with a maintained, normative XSLT port to RDF. Better than nothing I suppose and most Atom providers will transform on the server and provide both XML and RDF feeds.

Mark, perceptive chap that he is, drills down to the two reasons why RDF won't be on Fame Academy next week. Tool support and RDF / XML syntax.

Mark is down on the Semantic Web. Well I never thought of the Semantic Web as some ethereal, elusive concept dreamt up by some PR brain farter. To me it is just code; a way to code a bit of 'intelligence' into our software applications. And OWL, as Kendall reports, is a step towards this.

Sam Ruby has a moan about RDF / XML. Some people just don't understand.

Also Edd Dumbill has a little gripe with RDFDrive, the only compliant RDF parser available for the .Net platform so I suppose beggars can't be choosers.

'Why all the interfaces', says Edd? Well, interfaces are cool. It means I can develop a parser that will query an in memory RDF graph and a parser that will query a database triples store against the same IRdfParser interface. I can then pass either parser to a application specific component, say a FOAF processor regardless of the internal implementations.

His other gripe is with the node based query model which I agree is clunky. Mine main gripe with RDFDrive is the fact that it uses a DOM instead of an .Net XmlReader to deserialise the XML into triples. This is a real performance killer and resource eater when working with RDF files over the internet. That's why I'm presently extending and upgrading Jason Diamond's excellent RdfReader to the latest Working Draft spec and then going to use it as the basis for a proper parser. You know, the one with that nice graph.GetStatements(subject, predicate, object) interface like RAP. Is there a better query interface? Please please let me know before I start!

One new feature of the Working Draft that I won't be tackling in a hurry is rdf:parseType = "Collection". Have you seen the triples that this is supposed to produce? And while we are talking syntax, why oh why is RDF / XML syntax so complicated? Any reasons or excuses for this would be appreciated because quite frankly, I just don't understand.

So hang on there all .Net RDF heads (all 2 of you), I will be releasing VicSoft.Rdf.RdfParser + source code in September.