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

[Shalabh Chaturvedi]

----- Original Message -----
From: Paul Everitt <paul@digicool.com>
> Imagine if...there was a facility to get an RDF representation of a
SQL
> Method, both its definition and what happened when you __call_'d it.
> You'd have access to the object metadata, like what arguments it
> expected.  You'd have access to the database connection it used, so
you
> could perhaps browse the tables looking for column metadata.  And you
> could do the "Test" tab and get data back that you formatted into a
much
> smarter widget in Zope _and_ in Mozilla.

Sounds nice though I wonder if we're using RDF outside its intended
domain here. Is RDF really meant to be used for this? Why not just XML?
To state w3c: RDF is
"a foundation for processing metadata"
"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"

If we view the SQL Method as a web resource and the arguments etc as
properties then I suppose it would be right to use RDF.

The visible usefulness of RDF here is really the usefulness of XML (or
any object model as such). It would be just as good if we had an XML
schema to represent the SQL Method or objects and then operated on that
model.
The only place where RDF may score over another XML is that mozilla has
support to manipulate it (but [1] how much would be usable for this
application. [2] does mozilla has support for XML too?)
Are we mixing up 'metadata' and 'data' here?

One question: Will a 'Zope Studio mozilla' be distributed with Zope or
will users have to get mozilla an use it to manage their Zope install?
I'd favour the former and assume it for the following:-

I present an architecture idea for the Zope Studio that is a bit
different from that of Martijn's:-
This is a bit vague yet but here goes...
-There exist XML Schemas for each of the Zope object-types.
-There exits XML-RPC calls for all posible operations on objects.
-The XML Schemas contain info about:-
  -All the attributes of the objects.
  -Info about the posible RPC modification calls that modify the
properties/do other stuff.
-Some XSLTs to go with each of the Objects.
Mozilla gets the XML doc for the object and renders it with the help of
the XSLT into XUL etc. There will be user-interaction widgets here too.
When the user performs an action on a widget, it gets translated to an
XML-RPC call and gets sent to the server. The server sends back a new
XML doc for each of the affected objects which are then rendered again
by mozilla. If its really smart it can send back only the changed info
for the objects and mozilla merges them in the objects on its side.
If the Zope data has changed through other logins/apps those changes can
also be sent to mozilla with any response. Optionally, after some
interval mozilla polls the zope server(auto -refresh) to get the changes
made by others.
There's no RDF here. We can put it in if we want to however - some of
the info about objects is stored as RDF and other is stored in other XML
docs.
Also, this architecture would need some specialized JS as XSLT would not
provide everything that may be desirable.
With this architecture too, a nicer SQL Method would be possible.


The first thing to decide is how much of the model (vs view) is to be
sent to the client side. For example: Zope, as it is now, can just send
back XUL instead of HTML and have a great interface in mozilla without
_any_ other change. That would be splitting the model-view right in the
middle, with only the view going to the client side.