Due to certain interviews and wanting to bid on some contracts
I have looking at 'web services' such as Django and Zope, lately.
hence:

<rant>
A long long time ago in a galaxy....  there was something
called IBM 370 CICS.  Beyond tty, it allowed user 
interactivity.  All the mainframers had something similar.
You 'marked up' the output which the server sent to the
  terminal in a hard to read and write little language
  which had no power except to display content
  and define fields.
The user/client then filled in a bunch of fields and
  submitted the input to the server.
The server validated the input then either sent back 
  an error screen or the next step.
This process was stateless, that is the server was driven
  by what input it got in whatever order.
The users response time was determined by the bandwidth, traffic,
  and power of the server and responses might fall in a hole,
  sometimes quite slow.
A user could complete a LOT of input lose it all.
All users (terminals) were not the same and did not render
  equally.
An upgrade on either the server or client could easily break
  the applications.

Sound familiar?

Then came the mini-computer revolution, followed by the personal
computer revolution.
Software development became local.  Software tools became
powerful but fundamental.  Software began to be developed in
bedrooms and garages and exploded.
Hardware became local with apps running inches away on a computer
THE USER owned.
The user could fiddle with the software, extend and add to it.
The data belonged to the user.  He could write his own apps
and enhance his data.
God looked down and said 'this is good' and man flourished.

But there was one class of angels, called the IT, who did not
think this was good.  It looked like chaos and there was no
more value to there Co-Ball.  They worshiped a serpent they
call the ASP (In those days it meant application service
provider).  This serpent did not fly.  Then they discovered
there was in place a vast spider WEB which gave them the
ability to deliver applications remotely once again.

The problem was the only generally accepted transport was
something called http would could only deliver content.
And the primary language, HTML only displayed content.
But that was okay, there was a transport so all they needed
to do was glue on some patches. And more patches and more
patches....  And the versions of the patches proliferated.

But that was okay, the users could be sent messages like
"To properly view... you need to upgrade...."

So in the end the applications required many dissimilar 
technologies with many acronyms like XHTML, CSS, JS,
AJAX, PHP, ASP, .NET, APPLET, XML-RPC, etc.  And none of these
had syntaxes like the others.  It was a steep learning
curve to be a developer.  It was requiring professionals
with long weird resumes.  It was getting expensive and
applications needed to be served again by large companies.
This made the IT happy.

For a while.  But the developers knowledge was so broad
and deep, they were beginning to be as valuable as real
engineers and as hard to find.  There were still some cheap 
ones but they were 12 timezones away and talked funny.
So 'wrappers' began to emerge.  All of these weird technologies
could be wrapped into a single package and some real standards
could be enforced.  Now the IT were getting closer to control.
This process is evolving at this time.

It should be mentioned that there are really big gorillas
in this picture.  Some with names that rhyme with gorilla.
They are critical to the transport stack.  They have been
approached many times about actually transporting the
application and running it locally, by allowing the
user to download the source or the executable and capture
some or all of the data locally.  They were even approached
about this recently at a gathering of worshippers of another
large snake. (large snakes, large gorillas and Jessica Lange.
   this has potential)
This would obviate ALL of the above patchy confusing technologies.
Application programming would once again require modest
   learning curves.
Users could be provided 'hooks' to extend their applications.
Their databases could be local, shared, and perhaps synced with
   other databases.
Response time would instant.
Programming logic would be stateful and once again immediately
   responsive down to the keystroke level.

But alas, the big gorillas, think that would be insecure.
The application providers might be irresponsible and the
the users might be unwise.  Users might think they were adults.
The outcome of this discussion
may not be decided for a while.  It may require a smaller
gorilla entering the scene, with a different philosophy.

In the meantime, we've come full circle, but we can download movies.

</rant>
_______________________________________________
Linux@ctlug.org
http://www.ctlug.org/mailman/listinfo/linux