[Zope-dev] Re: RDF Musings and TinyTables

[Shane Hathaway]

Paul Everitt wrote:
> 
> Shane Hathaway wrote:
>> I've understood the mechanics of RDF for a while, but never understood 
>> what makes it better than what we already have.  Now I think I get it: 
>> RDF theory is a new kind of database abstraction.  It's similar to a 
>> relational database in that you put pieces of data into the database 
>> and later search for data.  But it's much more ad-hoc than a 
>> relational database.
> 
> 
> I think you are 100% correct, maybe 110%. :^)

Whew, that's good to know.

> In the last two years I made several attempts at grokking Mozilla and 
> RDF was always the wall I ran into that prevented further progress.  In 
> the last three months I slowly, surely, forced myself to study it. Write 
> things down, take notes, rewrite them down, etc.
> 
> The light bulb has definitely gone off for me now, and I see things 
> exactly the way you describe it:
> 
> 1) It's an abstraction.  Once you start working with it, you realize 
> what this means.  You take a bunch of information and throw it into a 
> bucket.  You also throw in how the information relates to each other.
> 
> 2) It's a database.  You have a pretty formal way of asking questions 
> and making sense of the stuff in the bucket.  You also have a way to put 
> things in the bucket, and also to rearrange the stuff in the bucket.
> 
> 3) It's ad-hoc.  You don't have to know everything beforehand like SQL. 
>  You also don't have to control the containment hierarchy like you do 
> with XML.  (Took me a LONG time to realize the significance of the 
> latter point.)

With all this in mind, I just studied my Mozilla mimeTypes.rdf file 
again.  At first, this file looks nasty.  I've only defined handlers for 
two mime types, application/pdf and application/x-zope-edit, yet the 
string "application/pdf" shows up 8 times in the file!  I only typed it 
once. ;-)

But if I think of RDF files as database export files (or maybe the 
results of a database query), it all makes sense.

- The order in which the RDF elements appear in the file doesn't matter, 
just like the physical order of inodes on a hard disk doesn't matter.

- The obvious way to read this file is to search for XML elements that 
look like '<RDF:Description about="urn:mimetype:*">'.  But that's not 
the right way: that's like scanning filesystem inodes sequentially. 
Instead, there is a root URI, "urn:mimetypes", and the RDF elements make 
connections to other elements from there.

- RDF is hard to read, but legibility by humans isn't its primary focus. 
  It's more concerned with providing a way to declare any relationship 
about anything.

> The ad-hoc part is, for me, the key.  Relational theory provided the 
> theoretical foundation for modern online transaction processing.  But 
> things like content management are a much different problem.  (One 
> analyst states that unstructured content is 80% of the information in a 
> business.)
> 
> RDF, in my view, is the equivalent of a "set theory", a formal 
> foundation, for content management.  Without it, everyone has to build 
> their own "framework" for stitching things together, for connecting the 
> dots.

So RDF seems like a replacement for, or maybe enhancement of, relational 
theory.  But I wonder how object-oriented databases fit in the mix?

> 
>> Serialization of RDF into XML and the relationship between RDF and the 
>> Semantic Web are distinct concepts from RDF theory.
> 
> 
> That's right.  I've always been surprised when I threw some RDF/XML into 
> Mozilla, then got a dump of the serialized results.  What I put in 
> doesn't look like what I get out.  That's because there is an abstract 
> model.  The XML can look a couple of different ways, and you still have 
> the same abstract model.

How do you (1) throw RDF into Mozilla and (2) get a dump of the results? 
  Is there a utility for doing this?  Are the results in RDF, and are 
they pretty much equivalent to "cat file1 file2"? :-)

> 
> It took me a while, but I learned how to take advantage of this.  With 
> Moztop, I'm taking a pretty loose, distributed approach to content 
> managment.  I collect RDF from a bunch of different servers, throw it 
> all into one big graph, and use this to draw widgets on the screen.
> 
> The ability to make an assertion into a completely different part of the 
> tree is something you can't do in XML.
> 
>> This ad-hoc data storage made me think of TinyTables.  TinyTables is a 
>> good Zope product that fills the need for simple tables of data, but 
>> it needs attention.  What if it got replaced by some Zope product called 
> 
> 
> I will do everything in the universe to help such a project.  How is 
> that? :^)
> 
> I know what the practical benefits that RDF can mean for content 
> management.  And it isn't esoteric Semantic Gibberish.  I'm unable, 
> though, to map it on the server side.  However, I'm having luck on the 
> client side:
> 
>   http://www.zope-europe.org/Members/paul/tmp/moztop-pinstripe.png

I can see that the benefits on the client side would be enormous.  For 
interfacing clients to Zope, we've always thought in two directions: 
either connect the client via ZEO, or have the client call remote 
procedures that return lists and strings.  The ZEO client idea would be 
fast and easy, but the client would get unrestricted access to the whole 
database.  The remote procedures would be secure but potentially slow, 
since the client usually needs more than one list or string.

But if the client requests RDF using a remote procedure call, the server 
can send back everything at once that it considers relevant.  Hmmm... 
but I bet there's more to it.

Here's a fantasy... the ability to write a template that can be 
processed either by Zope or by the client.  When the client is able to 
do the work, send the template and bunch of RDF.  When the client can't 
do it, preprocess it.  This is what XSLT always wanted to be able to do, 
but I couldn't see it getting there.  Maybe RDF can make this a reality? :-)

This email is getting big, so I'll cut it off here for now.  I'll study 
the XUL templates.

Shane