xml-dev - RE: Groves, the next big thing (Re: ANN: XML and Databases article)

["Didier PH Martin" <martind@netfolder.com>]

Hi Michael

Micheal said:
------------------------------------------------
There are three basic reasons why the DOM is not more groves-like. First, as
someone pointed on earlier in the "XML and Databases" thread, not enough
people outside the hard-core SGML/XML community understand the groves
paradigm, so there was no general familiarity that we felt we should
leverage.  Second,  the available documentation for groves (at least a
couple of years ago) was mainly the DSSSL spec, which is very difficult for
non-specialists to make sense out of.  Third, there was a widespread
perception that the groves model implies, in DOM terms, that "every
character is a node",  and people concerned about implementing the DOM API
felt strongly that this would lead to unacceptable footprint and run-time
overhead.

Didier says:
------------------------------------------------
I agree the specs are usually not enough to sell something. If XSL or CSS is
popular its mainly because library shelves are becoming full of books about
it. Actually there is very little work done about DSSSL except to say it is
difficult. I personally think that it has been very badly explained and
sold. Sorry about the XML technical marketers you encountered, they probably
lacked a good tech/marketer in their team to do the bridge. They could have
simply introduced (as Paul Prescod did ) DSSSL at the same level as CSS.
Just look at the example below and notice the similarities. Just, sit and
relax and observe the two expressions, let go any preconceived idea and just
trust your perception system.

CSS

par {
    display: block
    font-size: 1.3em
    }

DSSSL
( element par
	(make paragraph
		font-size: 10 pt
	)
)

At the minimum DSSSL could be used simply like CSS - without the expression
language. It is only the expression language (quite powerful) that adds
difficulties (mainly because people are not used to its lispish syntax).
However, DSSSL could be used as CSS - simply as a basic style language
without any expression language. Thus to have a beginner level (only style)
and an advanced level (with expression language).

 So the next time the XML technical marketing people you spoke about are
having difficulties sorting a technology into beginners and advanced level
please give them my email, I'll be glad to help them make complex things
simple (Didier PH Martin martind@netfolder.com).

Michael said:
---------------------------------------
Groves may or may not become the next Linux; if this is going to happen, two
obstacles must be overcome.

Most importantly, someone is going to have to write a *clear* statement of
the paradigm, its power, why it's "the next big thing, etc.  Sortof  "Groves
for Dummies", or the "Grove Manifesto".  I can't stress enough the
importance of writing this for a fairly general audience. I recall
conversations a couple of years ago with very smart technical marketing
people at large companies who are now big players in the XML world; the
level of fustration they expressed at trying to make sense out of things
like the DSSSL spec was quite memorable!  I have not read the recent
attempts by groves adovocates to offer tutorials, etc., so forgive me if
this has already been done. I frankly doubt it, because if a clear and
compelling case for the groves paradigm has been made, it hasn't come to the
world's attention.

Also, even if the "grove paradigm" is a fundamentally more powerful way of
looking at XML and other types of data than what is in wide use today, it's
unlikely to be adopted unless there is a clean migration path from familiar
APIs like ODBC/SQL, the W3C DOM, the (forthcoming?)  JCP XML data binding
spec, etc.  One of the most eye-opening aspects of my experience on the DOM
WG has been to understand that most users of Web scripting languages, Visual
Basic, etc. know very little about computer science.  I began my DOM
"career" assuming that everyone who would be using such APIs understood tree
and graph data structures and would understand how nicely they represented
the types of things we were talking about.  I was quickly set straight by my
colleagues from companies with larger customer bases:  ARRAYS are about as
sophisticated a data structure as the typical Web scripter or VB programmer
can handle.  [I *know* that someone reading this wants flame me, but rest
assured that I don't like this notion any more than you do, and just about
every conceivable counter-argument has been raised, and very reluctantly
dismissed, by the DOM WG already.] So, I would *love* to see someone define
a grove API that extends the DOM, and/or to see the grove paradigm cleanly
incorporated into the Java Community Process XML data binding, and/or to see
a repository-friendly API that builds from ADO or JDO and incorporates
groves concepts.  But don't expect the typical consumer of XML APIs to be
impressed by a groves API that offers a "new paradigm" that assumes that the
reader understands graph theory and data structures and builds up from there
with little reference to existing efforts.

Didier says:
----------------------------------------------
I agree with you on that point Michael, a lot of people do not have enough
knowledge nor time to learn that groves are abstract data models. They need
API to implement things.

 Now speaking of APIs, it would have been possible to create an API inspired
from groves and following the composite pattern. This would have lead to an
more extensible API. The basic idea behind groves is that they are
hierarchical structures and as such, the perfect match for navigating in a
hierarchical structure is an API based on the composite pattern (gamma &
al.). Also, groves are not condemme to a single model. Grove could be based
on different models (i.e. the document model, the hyperlink model, etc..)

For example ADSI is based on the composite pattern and can support several
hierarchical directories are near directories. It support different model
and schemas. So, as already shown by ADSI and people just knowing VB,
javaScript and basic scripting language, this API is useful to these people
and understood. Thus, it is possible to create a simple, extensible API
based on grove concept.

regards
Didier PH Martin
mailto:martind@netfolder.com
http://www.netfolder.com


xml-dev: A list for W3C XML Developers. To post, mailto:xml-dev@ic.ac.uk
Archived as: http://www.lists.ic.ac.uk/hypermail/xml-dev/ and on CD-ROM/ISBN 981-02-3594-1
To (un)subscribe, mailto:majordomo@ic.ac.uk the following message;
(un)subscribe xml-dev
To subscribe to the digests, mailto:majordomo@ic.ac.uk the following message;
subscribe xml-dev-digest
List coordinator, Henry Rzepa (mailto:rzepa@ic.ac.uk)