Knowing .NET

Richard Gabriel’s famous essay “The Rise of Worse is Better” (which, incidentally, I still think was originally published by me when I was editing AI Expert) details the “survival characteristics” of two approaches to software design: the “MIT approach” and the “New Jersey approach” (Bell Labs). He proposes these characteristics and values:

Gabriel’s greatest leap was to put aside his emotional attachment to the MIT approach and observe that even in the intentionally bad picture presented here, the New Jersey approach (labeled “worse-is-better”) has “better survival characteristics” than the MIT approach.

When considering my previous post on whether XML is the assembly language or UNIX pipe of Web 2.0, I realized that this was yet another battleground for these two philosophies, but ironically, the “usual suspects” seem to have reversed positions: it’s primarily the large vendors who are promoting the MIT-like WS-* stack and the academics / free-thinkers / entrepreneurs who are promoting the simplicity of REST/POX.

Since, as I made it clear in the previous post, I’m a REST/POX proponent, this is somewhat dismaying. Particularly worth deep consideration is the final part of Gabriel’s article, where he discusses how the approaches, once popular, evolve towards reuse and flexibility.

The sharp and capable Clemens Vaster says that “XML is the assembly language of Web 2.0,” drawing a complexity/productivity analogy to higher-level programming languages, which everyone but Steve Gibson thinks are worthwhile tools. The upshot: “[we] have arrived at the point where matters have gotten so complicated that a layer of abstraction over pretty much all things XML has become a necessity for everyone who makes their money building customer solutions.”

Not everyone agrees: James Speer balks andTomas Restrepo says that that Clemens is conflating XML and WS-*.

I disagree even more vehemently. One of my favorite recent quotes was Ray Ozzie’s quip that “RSS is the UNIX pipe of the Web.” In addition to being encouragingly the sort of quote (technical, insightful, engaged with current trends) to encourage Microsoft watchers, I heartily agree with the implicit emphasis on flexibility.

One of the defining characteristics of assembly language is that it is inflexible: it’s hard to write high-abstraction-level code in ASM (possible, but it’s not facilitated by the language). Another characteristic is that it is dominated by implementation idioms. What springs to mind is is XOR AX,AX which a generation of x86 programmers used to set a register to 0 because it was mildly faster than MOV. Because all abstractions leak, all “blackbox” systems are fuzzy and imperfect. No matter how worthwhile the aspirations of the WS-* stack, in practice systems using the stack will gather implementation-specific peculiarities. Perhaps no more than any other framework, but when tools are used to generate significant amounts of code, they inevitably produce low-abstraction code. Look at interface designers and the naive way they align controls: not by using a variable or directly referencing a dominant control, but by generating the same code over and over.

Similarly, if the XML moving between our Web 2.0 services is primarily tool-generated and difficult to comprehend, that will stand in the way of intermediaries adding value, which are an essential part of Web architectures. RSS is successful, not in spite of being “really simple,” but in large part due to being so. The same is true of HTML. The same will be true of the next major innovation in Web 2.0.

ActiveSync is the worst piece of software I use on a regular basis. I hate it: the way it irregularly wakes up the device, the way it loses profiles, the way it deals with resolving conflicts, its bugs… Vista apparently has device synchronization built in to it, hopefully rewritten from the ground up. Of course, it’s more likely just the buggy ActiveSync codebase now cooked in to the OS. Wait a second, maybe it’s reason enough not to move to Vista…