More pushback on last week's column, this time from from Stefano Mazzocchi:
I've been one or the first to see the value of pipelines for XML processing and wrote Cocoon to make it happen, so I think I know a little about XML processing pipelines, but there is something that the people advocating web services miss entirely:
- protocol interoperability is hard but can be achieved
- data interoperability is harder but some standardization (real or de-facto) creates power-law clusters where things can work because some information can be taken for granted because implicit in that communication context
but there is a third piece of the puzzle that almost everybody forgets:
I think that point-2-point web services will work, as they do today and have been doing for a long while. Which communication protocol and programming language they use to make it work doesn't matter at all, it's all just marketing. The rest will have a complexity similar to that of the RDF/RDFSchema/OWL stack (and if you look at BPEL4WS you start to understand what I'm talking about). [Stefano's Linotype]
- metadata interoperability
The crux of Stefano's objection, I think, is here:
Marketing, protocol and syntax sugar aside, web services are RPC.I disagree. It's true that Web services got off to a shaky start. At a conference a couple of years ago, a panel of experts solemnly declared that the "Web" in "Web services" was really a misnomer, and that Web services really had nothing to do with the Web. But since then the pendulum has been swinging back, and for good reason. Much to everyone's surprise, including mine, the linked-web-of-documents approach works rather well. Not just one-to-one and one-to-many, but also many-to-many. Adam Bosworth's XML 2003 keynote was, for me, the most powerful affirmation yet that Web services can and should leverage the Web's scalable spontaneity. That's the vision firmly planted in my mind when I talk about Web services.
Meanwhile, this just in from Christian Morgensen:
Thanks Christian! I had seen that writeup in November, but lost track of it. This is just the sort of approach to harmonizing graphical and command-line interfaces that I've long envisioned.
You should check out Microsoft's new command line - after twenty years they're finally upgrading command.com in Longhorn. The Longhorn shell will do command pipelining using XML streams. They're calling it MSH - codenamed "Monad".
It should give developers the power and flexibility of a Unix command line, with less of the awk/sed rewriting glue needed, because the data isn't just text in columns, but is structured and meaningful. The writeups focus on the fact that it hooks into the dotNet runtime, but the clever thing is really the communication mechanism between the objects, which is structured text. The Indigo runtime will short-circuit the serialization/deserialization to actual text, but the basic concept looks sound. It will make things quite interesting when it hits -- there will probably be some culture clash as windows developers learn to work without a GUI.
Check out the writeup on the new shell here, and the PDC slides are here.
Former URL: http://weblog.infoworld.com/udell/2004/01/05.html#a879