Stepping back, part two...

   Here's some further ramblings.  This was originally a private
message exchanged with Scott Lawton, but I realized there was some
material here I thought would be a useful follow up to my previous
message on the list.  So, after a little editing, here 'tis...
   [Note: the context here was some technical ideas that Scott had
regarding an overall approach to a transformation language, and
whether a declarative approach can really work, or if it just
complicates things more than anything else.  His conclusion was that
a declarative XML syntax could be "mapped" to a more powerful,
procedural language.]

   Actually, I'd say you're running down a good track here.  In
actuality, I tend to look at it from the other side, to a point.  I,
for one, happen to think that the DSSSL model is fantastic.  I had a
bit of learning to do to understand Scheme well enough to do anything
particularly useful (and I still haven't done much, as my "day job"
doesn't involve this stuff... yet).  However, from a purist computer
science kind of standpoint, I think it's great.  The casual user, on
the other hand, would freak.
   This gets down to a fairly fundamental philosophy, and touches on
the first major diatribe in my message to the list.  There are users,
there are programmers, and there are "gods" of programming (and a
variety of shades in between).  The gods are the ones who can pull of
those neat tricks with assembler.  The ones in the middle can assemble
a decent application in C.  And the users just want it to look nice in
the end.  Same thing here.  By "layering" the technologies, you allow
the gods to build the tools that allow the guys in the middle to
assemble easy to use facilities for the users.
   [Ed. note: Perhaps "gods" is not the most appropriate term.  If my
use of it here offends anyone, please don't take it too hard. :) ]
   This is also what I was getting at with the formatting objects
thing.  Someone like David can put together some beautiful TeX code
which can encapsulate the concept of a footnote which will end up
inlined or at the foot of the page depending on certain layout
criteria.  He develops it, wraps it up in a formatting object "shell",
and gives the user some documentation on what properties of the object
they can set to control the circumstances under which the footnote
gets inlined.  Some middle guy can write some well designed style
sheets (or even style sheet libraries, with functions that can be
used at a higher level) that can be utilized (possibly with some
customization) by an end user.
   Really, in a declarative style sheet, those declarations/tags are
macros, of sorts, written in a real programming language.  I asserted,
some time ago, that XSL may end up to be nothing more than a pretty
face for DSSSL engines, and indeed, xslj does just that.  However,
there may even be some gods who don't want to deal with Scheme, so
what if we could slice up the layers a bit more, and provide
interfaces to the core functionality of a DSSSL engine, onto which we
could graft any language we want (I have dreams of CORBA here)?
   I haven't had a chance to look at the DOM standard much, so I can't
speak on this too authoritatively, but my thought is to take that
basic approach, mix in the important aspects of groves (which is a
*great* model, IMHO), and establish a standard interface to
implementations of this.  Then, anyone could implement the DOM/grove
interface on top of a variety of data representations, including
in-memory, on-disk, and even databases of various types (RDBMS,
ORDBMS, OODBMS, etc).  Layer a couple of different transformation
implementations (among other tools... transformation isn't the only
thing you might want to do on top of this layer) on top, get yourself
a whole plethora of formatting options tailored to different needs,
and mix in a standardized architecture for pluggable formatting
objects, and you've got information management nirvana.
   If the standards folks start with the DOM/grove level, maybe do the
formatting object architecture next, and then work their way through
the levels, taking the best of the best as they go, we could just have
something that everyone can work with in the end (as if there would
ever be an end, eh?).
   One last point is that I think there is a fundamental problem with
the way the W3C is approaching the standards process.  The Object
Management Group (OMG), who is responsible for CORBA, et al, has an
excellent approach to standardization.  They identify a need for a
technology standard, then they request proposals, generally from their
members because almost every major technology company is a member.
One of the most important criteria for any proposal is that it has to
be based on proven concepts or technologies.  No theoretical mumbo
jumbo allowed.  They have to see that it works first.  It slows things
down a bit, granted, but I think it avoids discussions like what we're
going through now.

-Brandon :)


 XSL-List info and archive:  http://www.mulberrytech.com/xsl/xsl-list