Brendan recently told me about a new blog post by Joel Spolsky about Javascript/AJAX and the future of web development. In the article, Joel claims that the history of development on the desktop is now mirroring itself on the web. He draws many excellent parallels between the past and present. In terms of optimization, portability, and UI consistency/interoperability, the current history of web applications does indeed look like the early history of mainframe/PC development.

However, Brendan then proceeded to read me this excerpt from the post:

Imagine, for example, that you’re Google with GMail, and you’re feeling rather smug. But then somebody you’ve never heard of, some bratty Y Combinator startup, maybe, is gaining ridiculous traction selling NewSDK, which combines a great portable programming language that compiles to JavaScript, and even better, a huge Ajaxy library that includes all kinds of clever interop features. Not just cut ‘n’ paste: cool mashup features like synchronization and single-point identity management (so you don’t have to tell Facebook and Twitter what you’re doing, you can just enter it in one place). And you laugh at them, for their NewSDK is a honking 232 megabytes … 232 megabytes! … of JavaScript, and it takes 76 seconds to load a page. And your app, GMail, doesn’t lose any customers.

But then, while you’re sitting on your googlechair in the googleplex sipping googleccinos and feeling smuggy smug smug smug, new versions of the browsers come out that support cached, compiled JavaScript. And suddenly NewSDK is really fast. And Paul Graham gives them another 6000 boxes of instant noodles to eat, so they stay in business another three years perfecting things.

And your programmers are like, jeez louise, GMail is huge, we can’t port GMail to this stupid NewSDK. We’d have to change every line of code. Heck it’d be a complete rewrite; the whole programming model is upside down and recursive and the portable programming language has more parentheses than even Google can buy. The last line of almost every function consists of a string of 3,296 right parentheses. You have to buy a special editor to count them.

And the NewSDK people ship a pretty decent word processor and a pretty decent email app and a killer Facebook/Twitter event publisher that synchronizes with everything, so people start using it.

And while you’re not paying attention, everybody starts writing NewSDK apps, and they’re really good, and suddenly businesses ONLY want NewSDK apps, and all those old-school Plain Ajax apps look pathetic and won’t cut and paste and mash and sync and play drums nicely with one another. And Gmail becomes a legacy. The WordPerfect of Email. And you’ll tell your children how excited you were to get 2GB to store email, and they’ll laugh at you. Their nail polish has more than 2GB.

Brendan and I then proceeded to get into an argument about whether this was a fair example to use or not. Joel has a lot of points buried in his post, but with this example, he seems to be implying that small startups will be the innovators and big companies will be caught sitting on their hands, obsolete before they even realize it because they spent too much time optimizing their applications for current technology.

Of course, when Joel looks for an example of a “big web company” to use in his large optimizer vs. small innovator example, he naturally picks Google. And, of course, I kinda resent the picture that he paints. After all, when I go to work every day, I don’t sit in my (very comfortable) googlechair in the googleplex sipping (really tasty) googleccinos and feeling smuggy smug smug smug. I go in to work and try to innovate the crap out of the stuff I’m working on. I’m not spending 8 hours a day in a massage chair reading Techcrunch and Hacker News and chortling quietly to myself.

Ok, so I don’t like Joel’s choice of examples. Big surprise. Ok, so he was just trying to be humorous. Whatever. If there’s some truth in every stereotype, there’s probably also some honesty in every joke.

I know it’s not the main point of the post, but I feel like it’s silly to suggest that a company loses its ability to innovate just because it’s big. Sure, some large companies of the past became too complacent in their top-of-the-market position and lost it all. Joel offers the example of Lotus, who originally had a stranglehold on the market with Lotus 1-2-3 and then lost it to new companies. However, that doesn’t mean that it’s an inevitability for all companies of a sufficient size.

Another way to look at it is that being large gives big companies the resources to BOTH optimize for current technologies AND innovate on the next big thing. Of course, this is really hard to do, but it’s possible.

Most new disruptive technologies are at least somewhat evolutionary instead of completely revolutionary. On the web, this usually boils down to “it works on top of HTML”. Joel’s example of the innovative SDK that provides amazing interaction with incredible speed may look like a revolutionary new technology to some, but to me it just looks like a case of creative optimization on top of current technology. After all, it’s still running in the browser, isn’t it? In this respect, having lots of experience with building things on current technology can help you to see the low hanging fruit that might turn out to be the next big thing.

Because there are so many browsers, so many web companies, three operating systems, and loads of developers, I find it very hard to believe that an entirely revolutionary technology will replace the web as we know it in the near future. Any drastic improvements that do occur will succeed because they are built on the backs of the technologies that came before and improve the experience that little extra bit, enticing everyone to switch over. If a truly revolutionary technology does emerge, it had better be able to raise the dead if it wants to attract users. “I can’t switch over because none of my friends are using it yet.” Critical mass is pretty hard to achieve when you’re incompatible with your predecessors. This is part of why the best technology doesn’t always win; a fact that seems to drive engineers crazy.

This might be a corollary to something that I’ve suspected for some time: we’ve got plenty of technology. What we need is a decent interface for interacting with the technology we’ve got.

Besides, as Robert Hoekman, Jr. says again and again in his book Designing the Obvious, it’s easier, faster, and equally effective to elevate through a series of constant small improvements instead of world-changing innovations.

We don’t need to innovate to make things better. Most often, we can elevate the standards and achieve very effective results that incrementally push the envelope.

I think the main problem here is actually with vocabulary. One man’s innovation or paradigm shift is another’s incremental improvement. A precompiled Javascript/AJAX SDK might look like an innovation to Joel, but to me it’s just the next logical step from our current ecosystem of Javascript libraries, which essentially seek to accomplish many of the same things (UI consistency and interoperability, cross-browser portability, and tweaked performance).

Every once in a while the stars align and a startup that nobody has ever heard of builds the next big revolutionary technology with just enough mojo to succeed. But every other day of the decade, the rest of us get to improve the current state-of-the-art as best we can through incremental changes on top of existing technology. Startups may have the small size, flexibility, and consuming hunger that it requires to pursue that next big revolution/evolution/whatever, but big companies who do things right should be able to optimize for now AND innovate for later.