My life regarding software goes thru phases. A phase transition is when
you strongly believe in something, then you strongly change your mind.
Others call it a 'revelation', others think you lost your mind.
I wrote Cocoon as a way to help achieving a more coherent look and feel
for the apache web sites. It was way overdesigned for that, so much that
we created another project for that (Forrest) which is still
overdesigned (even if it got a lot done).
Having one coherent look and feel was more of a social issue than a
technological one, here I was right and the way to design for SoC was
something that didn't have much to do with XML, yet SoC turned out to be
a key in a lot of aspects (and here I was right too, even if I don't
believe my mathematical simulation of degradation of SoC, done in my
master thesis, makes working group productivity saturate have any
scientific meaning whatsoever, in fact, I truly believe it to be correct
but I would need a lot more resources to prove it scientifically and I
don't have the time/will at this point)
Another thing that I got right was the assumption that in order to
create glue between systems, you can't transform everything into
everything else: a common ground, a low level "lingua franca", helps
establish a foundation for SoC work to take place for real.
The use of XML as such a lingua franca was a ridiculous bet in 1998, now
it's pretty much a given. People thought that forcing everything into a
SAX pipe would have been too limiting for those binary formats... but
the 80/20 rule worked very well, for those 20% cases where you need, for
example, to transform, say, AVI into MPEG4, well, use something else :-)
Cocoon is a lot different than it wanted to be when I started.
In fact, I didn't even release it when I wrote it, I thought nobody
would have been interested in it, but then I mentioned it once and
people wanted to take a look at it. And the rest is a lot of incremental
(and not so incremental) evolution.
- o -
Over the last 6 months, I worked pretty heavily on Mozilla as a platform.
Read more here if you are not up-to-date with it:
http://www-128.ibm.com/developerworks/xml/library/x-ffox15.html
Weird as it might seem, Mozilla and Cocoon have a lot in common:
1) a polymorphic component model (xpcom for mozilla, avalon for cocoon)
2) are not afraid of using the right language for the right thing,
even if this means an explosion of different things that you have to learn
3) the understanding that "in media stat virtus" (virtue is in the
middle) in regarding to compilation vs. interpretation, static vs.
dynamic and strongly typed vs. weakly typed languages (javascript + C++
for moz, javascript + java for cocoon) and other scripting languages
might follow
4) a vibrant, loyal and open development community
5) due to #1 + #4, a very strong and diverse collection of components
6) due to #6, a need for a simple to use extension deployment
mechanism (and metadata description to automate it)
but most important, is that pretty much everything that cocoon was born
to do, you can now do it in firefox directly.
Things like cinclude can be done with ajax-driven client side include,
even if this requires XSLT transformations (even multiple ones!)
The fact that it runs on a client, avoids the problem of having to use
SAX events instead of using DOM, which is much simpler to work with.
SVG is supported natively and SVG, XHTML and <canvas> can belong in the
same DOM and react to the same scripting environment, mix ajax and you
drastically reduce the need to go back to the server, even for the most
complex UI scenarios.
Because of that, you don't need continuations anyway: a wizard-type page
will have a continuation that is simply a state stored in your client...
and you go back to the server only to save state.. just use data-driven
web services a few, highly dynamic, XHTML templates.
I do that for my latest web sites and the more I learn how to driven the
client, the less I feel the need for advanced server frameworks. Is it
just me?
Is client side advancement making cocoon and all its machinery to
compensate for advanced web client obsolete and archaic?
Don't get me wrong, firefox's market share is minimal and firefox 1.5 is
not even out there, but the direction is set and things like Google
Maps, Flickr, Google Mail, the new Yahoo Mail and JotSpot show very well
where we are heading: richer and richer web UIs, requiring more web
services and less publishing engines.
Cocoon already moves in this direction, I'm fully aware of it and before
xforms make it into the browser, CForms are already out there and
working pretty damn well.
Cocoon was and still is instrumental as a bridge between old and new,
but in a new world, would one need to learn all this stuff? or, on the
other hand, once somebody knows how to work and build rich web UIs would
it find it easier to work on something like cocoon than, for example,
more traditional web frameworks?
If you ask me, the current infatuation with Ruby on Rails and friends,
while understanding and to the point (the need to avoid XML pushups, so
true), will fail dramatically short in scale to complex systems. Just
like M$ Word is great to write one/two pages and it fails miserably to
help you with your thesis, something like rails is awesome for your blog
or single-handed ecommerce web site, it would kill you no less than PHP
with a massively complex web site.
The strong architectural parallel between mozilla and cocoon, makes me
very hopeful in the future of mozilla as a platform, even if there are
years ahead of polishing to do.
But as a researcher, a scientist and one that likes to push the edge, I
sense that cocoon is kinda 'done', not as in "finished, passe'", but
more as in "been there, done that".
Sure, lots of things to polish and little things to continue to improve,
but I wonder if the action is somewhere else.
How do you feel about this?
--
Stefano.
