Doctorow v. Johnson: iWhatevers versus Open Platforms and the Future of Computing

This last weekend the first iPads shipped to early adopters in the general public, including me. Like many of us in the technology business, I’ve kept a weather eye on the first impressions of many folks on the web, and friends in the industry. Most of these reactions are the stuff of geek discussion, and not terribly enlightening either about the device and its potential future uses, or the direction in which our industry is moving.

But one exchange is worth analysis and our attention, whatever the details of the device and our first impressions. Cory Doctorow, open-source freedom fighter extraordinaire and speculative fiction author, published a widely discussed, negative essay concerning the very idea of the iPad. By now, you’ve probably read it, or seen the link. If you haven’t, you should.

Cory’s essential points are two (with apologies if I’m missing something serious). First, that open platforms (think Linux, Android, FreeBSD, etc) are structurally designed to foster innovation at minimal entry cost, and with minimum friction to the innovator, and minimal interference between the innovator and the eventual consumer of those innovations. Second, Doctorow argues that the justification everyone is citing for the closed system — “making computers easy for mainstream users” — is insulting to mainstream users.

Joel Johnson responds that Doctorow’s principal arguments miss the point. In particular, that openness and innovation are not causally linked to the extent that open-source and Linux advocates claim. That innovation will thrive on the “nearly closed” platforms like the iPad and iPhone.

The argument is one that technologists and designers ought to think about pretty deeply. In fact, whichever side of the debate you tend to come down on, I believe you ought to sit and think hard about reasons why the other side might be right. Because I believe something like the sum of Doctorow and Johnson’s arguments represent the future of computing.

It’s undeniable that truly open systems (as opposed to the controlled openness of late 1980’s “open systems”) like Linux have fostered a Cambrian explosion of innovation and tinkering. Many of us, including myself, got their start in the computing world just as the Internet took off as a public phenomenon, with Linux, Apache, and Netscape as the principal “rocket boosters” for its success. But there are signs that the Cambrian explosion has begun to slow from a proliferative to a winnowing phase, at least in some areas.

There is still huge innovation on the server side, with new server-side frameworks and web toolkits, even new languages (i.e., the close coupling between the origins of Lift and Scala) and computing paradigms (clouds, Hadoop distributed computation) appearing monthly. When one examines the server and deep application side, it’s hard to imagine that Doctorow isn’t exactly right. Preservation of the openness of systems, the malleability of interfaces and even programming paradigms, is crucial to keeping the recombination going in this server-side cauldron of computing DNA.

Winnowing is occurring on the user experience front, however. The winnowing-out process really began when we all decided that the web browser was the main arbiter of client-side experience. In fact, that seems so obvious today that we forget that the browser used to simply be an HTML display engine, not a general-purpose UI framework for multi-language code execution. We forget things like Pointcast, and other “rich internet client” examples, since for years they largely went away in favor of browser-based apps. Even in “thick” applications like Microsoft Office, when internet interaction was required — say, for Help or looking up a template, the thick app would spawn a little unmarked IE window to do the “internet stuff.”

Johnson’s point, as I take it, is that this winnowing process on the user experience front has been a good thing, and should continue. And I agree. And Doctorow is wrong to focus on the “making a computer my mother can use” trope. The intuition behind the trope is fine, as far as it goes, but the metaphor fails to dig down to the core of the issue. Certainly, we nerds have done an insufficient job of hiding the underlying execution model of our software, and a poor job of interface and experience design, by and large. Despite the efforts of Don Norman, Alan Cooper, and others, we in the open systems community continue to focus on the computational underbelly and not enough on the user’s experience.

Which is where Apple comes in. We all know that the reason their devices continue to delight and appeal is that they are designed in every detail, by teams of design fanatics, led by our industry’s chief design obsessive. And we all tell ourselves that the degree of design fanaticism that continues to suck us in is only possible with closed or semi-closed systems.

And this is where we find ourselves today. Those, like Doctorow, who value open systems for their innovation- and freedom-enhancing qualities, steer clear of Apple devices. Those, like Johnson, who value the progress we’ve made toward highly usable, well-designed systems, eagerly await new Apple designs.

I’d like to suggest that the distinction isn’t as sharp as we think, however. The design fanaticism displayed by Apple is not inherently a feature of their approach to closed systems; closed systems simply make it easier. The closed system is really just a choice, not a necessity, if one wants design excellence. Similarly, the lack of design excellence displayed in most open-source software (I’m thinking about Linux desktop apps in particular here), is not inherently a feature of an open-source community. Open-source projects simply make it harder to create and enforce design excellence.

One of Johnson’s points, as I read him, is that if we want innovation in applications, coupled with performance and design excellence, we need to stop reinventing the wheel on everything else constantly, and innovate at higher levels. And that’s easiest when all you have to worry about is the application you’re designing, not the platform as well.

Personally, I would love to see a world where we continue to see huge innovation on computing models in general, and free access to the fundamental tools for development, and options for retaining control over security and privacy. But in that world I’d also love reliable, gorgeous, high performance platforms like the iPad, as the mechanism by which the innovation that openness engenders is available to everyone. That’s likely possible, in practical terms, only with a mixture of openness and closed systems.