Re: [topicmaps-comment] RE: OASIS vs W3C

[Lars Marius Garshol <larsga@garshol.priv.no>]

* Tony Coates
| 
| One interesting thing about RDF is that any XML document is also an
| RDF document.  For example, even without any RDF annotations, an RDF
| parser will report an element with child elements as being an RDF
| container.  So they have some worthwhile default relationships.
| Now, the default information alone is actually not so useful by
| itself, but you can then use as many RDF annotations as you need to
| make the RDF information for the document sufficiently useful.

I am not sure this really is very interesting. This is a syntactical
convenience feature that reminds me very much of the equivalent
features of SGML. It has made the RDF syntax very much more complex
than it needs to be. The only gain is that RDF documents are easier to
author without supporting tools (which nobody should have to do
anyway) and that RDF becomes easier to generate (but only marginally[1]).

In short, I think this is a disadvantage, and that it is likely to
have cost the RDF community dearly, by making RDF much harder to
understand and implement, and also by making it difficult to
understand the true focus of RDF.

I may be wrong about this, of course, since I don't know much about
RDF, but this is how I understand this issue.
 
| This is the side of RDF that competes with SOAP, not topic maps.
| This is to do with parcels of information encoded as XML, parcels
| that are more-or-less equivalent to serialised objects.  I expect
| SOAP to win in that arena, but that is another discussion.

Agreed. 

| Once you have these bundles of information, the next question is how
| you create useful links between them.  This is the area where I see
| topic maps, RDF, and XLink playing.

I think XLink is going to be very hard to apply in this area. It is
too general, and so far hardly anyone seems to have done anything with
it.  

| What kinds of business questions will arise here?  Well, how easy is
| it with one of these solutions to express a particular kind of
| relationship between two things?  How easy is it to
| store/retrieve/process/query/maintain that information? 

I guess it is slightly easier with RDF for simple relationships, and
significantly harder for more complex relationships. Whether this is
an important point or not I am not sure.

| Are some solutions so low level that it is too easy to invalidly
| encode the relationships?  

A schema should solve that problem, I think.

| In general, how do you validate your encoding of the relationships?

With a schema.

| How much ambiguity is there is the expression of the relationships?

I assume none, so I'm not sure I understand what you mean.

| How easy is it to compare and/or merge relationship information from
| different sources?  

I don't think anyone has enough experience with this yet for it to be
possible to judge.

| How complex can the relationships be?  

Well, today I just discovered that one of our customers has an
association type with 13 association roles in it. So I guess the
answer is very complex.

| Are simple relationships simple to set up, or is there a high
| barrier to entry?  

My experience has been that once you 'get it', it is easy to create
simple relationships with topic maps.

| How much do the available tools reduce (or increase) the complexity
| of the task? 

I don't know the RDF tools, so I can't really compare. At the moment
they seem more low-level than the comparable topic map tools, though.

| How well do the available tools integrate with legacy data sources?

Not all that well at the moment, although I expect that to change.

| Which paradigms are simplest for non-technical staff to grasp?

Topic maps, I would guess. I've explained them dozens of times, and
everyone I've spoken to has understood it pretty quickly. RDF seems
harder to explain, because it is so low-level. 

| Anyway, back to RDF, I can see someone who is interested in object
| serialisation plus a bit of linking being attracted to RDF
| initially.

This is how I see it as well, at the moment, but it's too vague (in my
mind, at least) for me to really draw any conclusions from that, or
even to say that I understand what RDF can be used for.

--Lars M.

[1] Generating

  <foo:bar rdf:about="baz">
   quux
  </foo:bar>

  is not really easier than generating the (baz, foo:bar, quux) triple
  directly once you have a convenience method. In fact, once you
  consider that you have to combine all the triples applying to baz
  somehow going via the triples is likely to be significantly simpler.