[Zope-Moz] Re: [Zope] RDF Use cases

[Martijn Pieters]

Hello Shalabh,

Monday, December 20, 1999, 6:08:41 AM, you wrote:
SC> If I understand correctly this means we put the attributes of all the
SC> objects as RDF 'properties'. For eg: the object-type('DTMLDoc',
SC> 'DTMLMethod', 'Folder' etc) becomes a property, and also everything in
SC> in Properties tab becomes an RDF property. If you meant something else
SC> then here's another Use Case ;-)
SC> So, we have a bunch of XML (RDF) documents for all the Zope objects.
SC> These don't live as documents but probably get created on  the fly from
SC> the info in the ZODB. Does the RDF spec also define a way to
SC> _manipulate_ the RDF statements, like you suggest?

Let me try and give you a short explanation of what RDF is and what it
can do.

RDF is indeed a standard for describing metadata. So you can say that
you have a resource, an object (the "subject", in RDF jargon), and
this object has a property (the "predicate"), and this property has a
value (the "object"). The value can be either another resource, or a
literal value. In RDF this is depicted either by a triple ({pred,
subj, obj}), or by a directed graph (watch it, ASCII art):


   .-~~~~~-.  predicate   +--------+
  | subject |------------>| object |
   ~._____.~              +--------+

With this datamodel, you can describe very complex structures,
including an OODB. The subject can be anything that has a URI (URLs
are a type of URI), so a Zope object will do fine. The subject could
be http://www.zope.org/, the predicate RDF:type, and the object
http://www.zope.org/Resources/ZopeRDFSchema#Application. With
additional graphs, we can then also say what Zope properties are
defined on the object, what security settings it has, and what
subobjects it contains. And with a properly thought out Schema, we can
also declare what classes Application inherits from.

This RDF datamodel can then be serialized in XML. XML is the default
serialization syntax, but not the only one. The RDF Recommendation
only describes the datamodel, not how to manipulate it, or how to
propagate changes in the RDF model back to Zope.

But we can pull the RDF into Mozilla, and Mozilla allows you to query
the RDF datamodel, and manipulate it. With XUL, the cross-platform
user interface modeling language implemented in Mozilla, we can then
display the data in the RDF, and allow a user to interact with it.
Changes to the RDF datamodel can be detected, and then we can act upon
those changes, by for example sending an XML-RPC call to the Zope
server. This could be a way of implementing Visual Zope. We will
however, think about how we would propagate changes in Zope (by other
users or processes), into the datamodel in the browser.

The above description of the use of RDF in Zope is but one example,
albeit an extensive and far reaching one. Zope would not actually be
"doing" any RDF, it would only generate XML to represent a RDF
datamodel.

But maybe you can think of a scenario where it would be beneficial for
Zope to actually be able to directly manipulate a RDF datasource, to
aggregate different sources into one model, and then query this model
for internal purposes.

SC> Also, why not have the Zope Studio also query and manipulate the Zope
SC> objects through RDF only (vs having some other interface).

Because we want to keep Zope as open as possible. RDF would be one way
of representing Zope data. WebDAV another. XML-RPC is one way of
manipulating Zope, SOAP another.

-- 
Best regards,
 Martijn Pieters                  mailto:mj@digicool.com