This is the eleventh edition of Code Reads, a series of discussions of some of the central essays, documents and texts in the history of software. You can go straight to the comments and post something if you like. Here’s the full Code Reads archive.

Playfulness in writing about programming isn’t always so easy to find. But here it is again. In our last Code Reads we got to enjoy Guy Steele’s words-of-one-syllable language game; this time around, we’re in the hands of two writers who are playing games with the entire corpus of software history.

James Noble and Robert Biddle are colleagues at Victoria University in Wellington, New Zealand (Biddle is now at Carleton University in Ottawa). In Dreaming in Code I summarized a bit of their work (along with a group of colleagues) on “Scale-free geometry in OO programs” — a study which found that software objects are “scale-free, like fractals, and unlike Lego bricks.”

Earlier this decade Noble and Biddle presented a series of papers at the OOPSLA conference on the theme of “Postmodern Programming.” The first, “Notes on Postmodern Programming” (2002), opens with a tongue-in-cheek transposition of the Bauhaus manifesto into the computing realm. From there, it jumps into a sometimes line-by-line rewrite of Edsger Dijkstra’s “Notes on Structured Programming” (which we looked at back in Code Reads #4). So we’re on notice that this paper will draw heavily on the postmodern aesthetic of cobbling together scraps, references, tributes and parodies.

But those bits and pieces form a serious argument, too.



One reason I’m interested in this work — beyond its lovingly unconventional form — is that it represents what seems to me to be a rare minority-report view of software history. In the Noble/Biddle version, our sense of a “software crisis” is a delusion:

Our basic problem is simply the success of modern computer science…This corrosive scepticism about the achievements of programming is unfounded. Few doom-laden prophesies have come to pass: the world did not end with fireworks over the Sydney harbour bridge, and few modern disasters are due to software….The measure of software is our irritation at its failures, not our surprise that it works at all.

They go on to describe a diverse computing world of heterogeneous systems, a world organized according to “many little narratives” instead of one master plan. Rather than view this state as an anarchy in need of taming, they see it as a diverse, flourishing environment in which the biggest problem lies in our own determination to be dissatisfied with what we have. Their mantra is, “It’s all good” (or, as they sometimes have it, “‘Tsall good”).

The argument in “Notes on Postmodern Programming” is rooted in the vocabulary and theories of the arts, particularly architecture. There’s a certain coyness about the term “postmodernism” itself, but the authors largely use it straightforwardly to mean the condition of living after “great works” have already been written, in a world where you’re free to pick from a grabbag of styles and philosophies to suit the challenge at hand. The vocabulary is drawn specifically from the history of programming, but the attitude is a permissive, let-a-hundred-flowers-bloom stance that’s relatively uncommon in the field.

Noble and Biddle tell us via whiteboard scrawl (or is it back-of-napkin scribble?) that “messy is good” and “worse is better,” and ask, “Can we win small?” As they write in “No Name: Just Notes on Software Reuse,” “There is no silver bullet — but there are no werewolves.”

The form of this writing duly reflects its content. “Notes on Postmodern Programming” is confoundingly fragmentary, its followups even more so. By the end of it you may still be scratching your head trying to figure out if it’s serious or a joke. The authors ask that very question for you in a dialogue with “M-X doctor” — an Eliza-like chatbot built into emacs. (The chatbot, of course, turns the question back on them.)

For me, as a writer addressing the difficulties of programming and software development, the perspective in the “Postmodern” papers is arresting: They’re rejecting the entire “software is hard” premise of Dreaming in Code (and most of the rest of the field’s literature). But is this all just a literary game of no value to the working programmer? I’ll wait to hear from you working programmers on that.

Noble and Biddle aren’t entirely off in the ether: they identify Perl as “the first postmodern programming language” — a label embraced by Perl creator Larry Wall. And while they push pragmatism to the edge of the absurd — as, for instance, in their “First Example of Scrap-Heap System Construction,” which largely consists of looking up the code for a routine via Google — there’s an element of truth in their joke. In practice, this is exactly how we approach a great number of software-related problems today: we search through libraries and open source codebases and off-the-shelf products and see what’s already out there before we think about diving in to write something from scratch.

But surely that’s not enough. Is the “It’s all good” position a healthy corrective to software fatalism? Or is it just an invitation to complacency?

[tags]postmodern programming, code reads, software development, programming, James Noble, Robert Biddle[/tags]