February 17, 2006

On Procedural vs. Declarative Gardening

Over the last few days a wonderful event has been taking place in the EXSLT camp. To summarize:

* An initial EXSLT 1.0 proposal has been brought forward
* This proposal contains quite a bit of the great and wonderful things that have been developed as part of the XSLT 2.0 spec.
* A general "hand shake" agreement has taken place to move forward with extensions to the XSLT 2.0 spec, creating both an EXSLT 1.0 for XSLT 1.0 and an EXSLT 1.0 for XSLT 2.0 recommendation from the EXSLT group.
* Several major obstacles have been overcome resulting in all of the above being made possible.

However, not everyone is really all that satisfied with the current state of affairs, concerned that this effort takes away from XSLT 2.0 and the hard work put forth by the W3C:XSLT-WG.

I disagree. Here's why:

One who comes from an "XSLT 2.0 ROCKS!!!!" standpoint, I must admit that I initially set out about 8 months ago to convince Uche and others in the Python/4Suite world to build an XSLT 2.0 processor.

In that time, here's what I have discovered:

They don't want one.

Why? I don't think it really matters why, but I think a snippet from some comments made yesterday by Sylvain to the EXSLT list should help shed some light on the matter:

It was the time I was working with C# and .NET for my job and Python + Amara for my personal projects. Well, I would welcome more XSLT 2 in an environment such as J2EE or .NET because programming languages such as Java or C# do not have the same flexibility as Python, Perl or Ruby. To me it looks like XSLT 2 is more an attempt at fixing the lack of flexibility of the former. (Note that I do not mean to say C# or Java are weak or bad languages but I suspect their static nature is the root of their lack of flexibility in our context).

Like the W3C:XSLT-WG folks (most particularly Dr. Kay), I have a *TON* of respect for the Python/4Suite folks. When I set forth on the above mentioned quest, little did I know what the actual result of this 6+ month quest would be:

I've fallen for Python.

Don't get me wrong... I plan to use every bit and piece of XSLT 2.0 coupled with IronPython and C# via Saxon.NET, a project I have become pretty attached to as well ;)

I must admit, however, that I find it interesting that what was originally a push to convert the Python/4Suite community to XSLT 2.0 has instead resulted in my own conversion to the Python language.

Over the last 72 hours those of us subscribed to the EXSLT mailing list have witnessed what I believe to be a *FANTASTIC* compromise by several die hard folks from both camps. The fact that the EXSLT folks are open to the development of an EXSLT for XSLT 2.0 spec, and that several heavy hitters in the XSLT 2.0 camp are now standing behind both this effort *AND* the recent proposal put forth by John L. Clark and Uche Ogbuji means only one thing:

*THIS IS GOING TO HAPPEN*

Several folks have stressed concerned that this shows disrespect to the W3C-XSLT-WG.

But in reality it has nothing to do with disrespect for the W3C-WG and all the work they have done, and everything to do with providing extended value to the existing XPath 1.0-based XSLT language. In fact, a lot of the work the W3C-XSLT-WG has done has directly influenced the contents of the aforementioned spec. The fact that much of XSLT 2.0 has found it way into this initial proposal for EXSLT 1.0 suggests that these folks respect the work the W3C-WG has done, not the reverse.

It seems to me that all of this boils down to two action items:

* Continuing efforts to extend XSLT as a Domain Specific Language.
* Ensuring that the XSLT communities (1.0, 2.0, EXSLT 1.0) stick together, appreciating XSLT for what it is, no matter the version or extension family.

Few would ever suggest that Lisp is anything less than a *SPECTACULAR* language. XSLT is derived from DSSSL and DSSSL has its roots in Lisp.

How many variations of Lisp are there?

Not sure. I know there's a lot! Given the fact that Lisp is such a wonderful language, the fact that XSLT seems to be following in the footsteps of its forefathers to me suggests good things, not bad.

However, while Lisp is making a comeback in a *BIG* way, the biggest obstacle these communities are facing at the moment stems from the fact they let the family run wild for a bit too long without as much as a Family Reunion every couple of years to at very least catch-up on old times. As such these camps are finding the need to either start the family tree over from scratch (Arc) or attempt to find the best branch (Scheme) and graft themselves back into the main root 'system' (sorry... It was there. ;).

Of course there is a core group of folks who are standing firm on the notion that the core Common Lisp family roots is where the clean-up effort should be focused, headed by none other than Peter Seibel who has likened this effort to gardening -- see: http://lispniks.com/cl-gardeners/

I like Common Lisp. I like Peter Seibel. No disrespect is meant when I state what they are attempting to accomplish isn't about gardening... What they're attempting to do is plough an old farmers field that has long since been paved over and a mall built on top...

And they're attempting this with a horse plough!

While I commend these folks for their efforts, and really hope they gain some much needed traction, I don't envy them. It seems to me that we (speaking in terms of the collective XSLT communities) can either follow directly in the steps of our ancestors and as such find ourselves scrambling to re-band 10 years from now with our horse ploughs, scratching our heads as to why the soil is "SO DAMN HARD!", or we can learn from their mistakes, roll up our sleeves, pick the weeds, and work at keeping the "family" together the best we can. Our family may be showing signs of growing pains, but at least we're still happy and the growth taking place in fairly healthy soil.

If we do a good job now, there may be hope for our little Domain Specific Garden yet... But I don't think its time for the lime bags just yet and instead gardening gloves, pruning shears, rake's, shovels, fertilizer, and a bit of old fashioned nurturing.

I don't think its any accident that Lisp took on the 80's hyped roll as the de facto language for Artificial Intelligence. Intelligence suggests the ability to differentiate. To think through a list of choices, and choose one option over the others, and to do so both logically and, for the most part, accurately.

Intelligence is a human characteristic (at least its supposed to be anyway ;) With its roots in choice, coupled with the nature of being human, intelligence also promotes free will. Humans, by nature, have a tendency to rebel against the norm... especially when they are told they *MUST* do something a particular way. These characteristics --

* intelligence showcased through free will
* our tendency to tell people "you must do it this way, or you are wrong"

can be related to two styles of programming:

* Declarative, in this case, "Provide me with enough information, then let me choose my own path"
* Procedural, in this case, "It's my way or the highway!"

Tying this back into the notion of gardening:

* Declarative Gardening - "I would like a garden. Here are some elements. I can't wait to see the results!"
* Procedural Gardening - "You'll grow how I tell you to grow, and you'll like it!"

Telling our XSLT garden how to grow isn't going to work the way we think it will, if in fact we believe that fighting against the 'system' (what can I say, everything *IS* a system :) is going to end in the result that we expect that it will.

It won't.

Intelligence will choose its own path (XPath? :D).

Just like it *wasn't* designed to.

I leave you in peace:)