So the web community is finally waking up to this?
Why is it so revolutionary to have “remote and local data” presented in an “OS agnostic” manner?
This has all been done before. And I should know. I have been working as a developer in this space for a while now.
I work as a J2EE Java developer.
Now Java, as many people know, is platform independant.
“Compile once, run anywhere” is a tradmark of Sun, the company that develops the language.
You compile a program into something called “bytecode” which can then run on an application called a “Java Virtual Machine” that interprets this into “machine dependant code” for that particular machine OS.
The JVM must be built to a common standard. Opening up identical API’s to the developer so that the bytecode does run on any JVM.
This is a bit of a gross simplification, but the JVM acts as an “intermediary layer” between the Java application and the OS.
Also, we have had Object Frameworks, or Middleware, such as CORBA, for over a decade as well.
These allow data, or objects, to be passed between applications, or processes, in a network achitecture agnostic manner.
This allows an application to use objects that are remote as if they are local.
This is the basis of the power of J2EE.
The difference between these technologies and the ones mentioned by Kottke, and yes it is a major one, is that WebOS, or whatever you want to call it, is visible to the end user.
The previous technologies, bytecode interpreted languages and middleware, were only really implemented at a server or network level.
[Although you could argue that Microsofts DCOM, the competitor for CORBA, made it to the desktop. However it was not widely used by end users!]
Merging and manipulating data on the web application server from various sources and then presenting in a OS agnostic manner to a thin client, i.e. web browser, is old-hat.
Now the move is to merge and manipulate the data in the thin client itself in a “thin application” based on ECMAscript.
As ECMAscript is, relatively, OS/Browser agnostic, this means that in the same way as the PC moved processing away from mainframes, these new “thin applications” are moving web based application functionality from remote servers to the desktop.
And it is not something that is a near future. It is here and now!
Something Kottke seems to have overlooked is greasemonkey, an add on from the Firefox browser.
It allows for the local manipulation of remote web pages using ECMAScript
For instance, I have a script installed that adds cache links to slashdot articles. These links are locally generated, by the script running in greasemonkey, and link to another site that caches the slashdot stories.
[A neat script would be an “as you type” spellchecker for text fields.
I think this could be done. It just needs someone to prvide the XML RPC service for dictionary lookups.]
And, as Kottke has identified, there were security issues with the present stable version so severe that they cripled it. [Although the dev build fixes that security problem.]
Let me state this definitevly.
None of this is an OS in the traditional sense of the word.
A WebOS, in my opinion, is an OS that maintains most of its libraries in a distributed manner.
i.e. The core, kernal, and TCP/IP protocol stack is maintained on the local machine, but graphics libraries, window managers etc, are located at a remote site [msn.com?] and loaded when required.
This has the benefit of allowing the OS vendor complete control over the version of library being used by the OS consumer.
A patch in a library is immediately available to all users.
Of course the problem with this model is bandwidth and security.
What if the servers at the OS vendor went offline?
What if a mailicious person could masqurade as the OS vendor and insert damaging code?
Back to Kottkes WebOS.
The Java application, even the distributed one, is still just an application.
The thin application, although browser based, is still a thin application.
But what it does is commoditize Operating Systems.
Now the OS is unimportant in the application decision.
It runs equally well on any OS.
[This of course means that virii will now run on any OS! MacOS people brace yourselfs]
What annoys me is all the new words that are comming out of this, so called, new technology. AJAX, Web3.0, WebOS, GoogleOS etc.
Why not just use the term “thin application”.
It follows the existing paradigm nomenclature of a “thin client” and takes it further.
And it is a nice catch-all for all the technologies that are moving to web based applications that are run locally, usually using scripting.
I will use this term from now on. I like it.