You are right about the ‘one
generation got old, one generation got sold’ idea. Reinvention
is what got us XML. We just slap new names on it, give the neo-pioneers
credit for the slave labor of others and rebrand for the sake of resale.
And so it goes.
On the other hand, I wonder about
everything becoming declarative. It seems reasonable to those of us who
are old enough to remember using exclusions and inclusions in DTDs and trusting
our luck on the wire. On the other hand, on the X3D development
list where there are actually very few fuddies, some luddies, but not nearly
the depth of XML immersion, there is a debate going on about where to put
simplified network support in the language. Because this affects projects
such as X3D Earth, liaisons with the OGC for their web services and so on, it
isn’t an insignificant debate for that community even if the results won’t
be tangible for a bit. One camp wants simplified declarative nodes;
the other wants it in the scripting language based on ECMAScript
standards. One wants it to be easy for authors; the others want it
to be fast, efficient and likely experimental for some time into the future.
The first group tends to be the older guys and the second (the script fans)
tend to be the younger guys who are dismissive if someone’s programming chops
aren’t up theirs.
So I don’t think the XML view of
this is precisely or as widely accepted as we may think. In fact,
it may be exactly the opposite and for the same reasons you cite.
One tends to be jealous of and desire that which is in the other person’s
backyard. So the script kiddies will want more complexity, not
less. Many who endured everything from bytes to byte codes to curlies to pointies
want it all to be simpler and less typing intensive.
What I think is safe to predict is that we
aren’t in for a year of simplifying assumptions. Complexity is
being embraced. Why? For one, it is the only thing that gets a
venture capitalist’s attention except for a defensible
patent. Regardless of where you are, which side of the various debates
of the day you come down, or who your professor’s were, you have to make
a living and choose to be a boss or be bossed. So everyone is
either looking for funding, funding or getting out of the game. That
shared mode of transaction drives much that would otherwise be determined by our
local ethics.
People will do this stuff for free.
They just can’t keep it up.
len
From: Kurt Cagle
[mailto:kurt.cagle@gmail.com]
I think Howard Rheingold is right. Web
designers have no memory.
Of course not - but how is that different from any other generation's approach
to computing? XML was largely created by people who had forgotten many of the
lessons of the old fuddy-duddies in the SGML generation. Java was built to be a
better cooler C++, and in the end it has ended up becoming just as hide-bound
and crusty. Name me a hot technology today and I can likely point to a
hot technology from yesterday that solved nearly the same problems in nearly
the same way.
The truth here is that for many developers, their PRIMARY programming language
is JavaScript, they have at best only a marginal understanding of OOP
principles, design patterns or algorithms, and their primary experience with
programming environments is the browser. They want to use the paradigm they
grew up with, and are far more concerned about flash and magic than substance
and design, so they rely upon "frameworks" that get them 95% of the
way there and hope that they can jump the remaining 5%.
You could argue that this means that these programmers are of poorer quality
than the ones that came of age in our generation, and to a certain extent I'd
agree with you ... but only up to a point. The bad ones end up getting promoted
up to management, the good ones continue to strengthen their understanding, and
bring a fresh perspective to such applications. Certainly I'd argue that this
generation of programmers understands distributed, asynchronous programming far
better, because latency, which is a fairly minor issue within desktop
applications, looms huge in web apps. We are reaching a stage now where new
programmers in the field come in with a basic understanding of XML, HTTP
programming, and the like - something that we had to learn by creating - and so
they start from a base that is in many ways considerably more sophisticated
than the ones we had.
Ten years from now, the bulk of all programming will be declarative (and
fungible), with a layer of imperative bindings to provide integration.
Whether it will be XML or not is debatable, but the long term trends currently
would seem to say yes. Many of the programming methodologies that we take for
granted today will be obsolete and perhaps even considered eminently bad
practice. And ten years from now, the hotshot AJAX programmers of today will be
bemoaning the sorry state of programmers, because they can barely write a
decent Javascript file - but man, the things they can do with XML!
Kurt Cagle
http://www.forms.org
