Code Reads #11: “Notes on Postmodern Programming”

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]

Post Revisions:

There are no revisions for this post.

Get Scott’s weekly Wordyard email


  1. As the authors point out there is no great crisis of software – we have not collapsed under the weighty complexity of our collective IT creations. But that still does not mean all is roses. The power of the internet is not only that it is a diverse collection of heterogeneous systems, but that each “little narrative” happens in the context of the grand narratives of TCP/IP, HTML, and MP3.

    Certainly we’re past the glory days of computing, when it seemed like everyone working in their garage was a Hercules destined for greatness. (And I by no means mean to belittle their profound achievements and vision.) But there are still grand narratives waiting to be told, and unifying themes waiting to emerge – just try to install new software on a Linux desktop, and you’ll long for a grand narrative.

    And I believe these narrative will emerge, or perhaps evolve, for our postmodern bed of a hundred flowers. Some will be the work of single heroes slaying great dragons, and others will simply arise as whole villages look around and realize that their premier, best-in-breed dragon slaying machine is expensive and a lot of work to maintain, while the guys in the next village down the road have a dragon killer that is free, easy to use, and good enough.

  2. Hello,
    I personally read NPMP a few months ago and had the same feeling reading Noble and Biddle’s article than reading any post-modern philosopher’s work: You never know if this is pure crap, plain tautology or extremely profound thinking. This may be due to the particular shape most PM writers give to their writings (tried to read Derrida, and gave up :-)).

    But the overall idea developed in the article is enthusiasming and perfectly fits my perception of our trade as software programmer. Software programming is dealing with language. This is obvious but the consequences you can draw from that point of view, once you accept the fact that a computer langaguage, and moreover a computer program (or source code fragment) is but a piece of written narration that talks about/acts upon the world have been addressed by critics theory, litterature, philosophy and most social sciences, but not by computer science: The Subject is everywhere and this has nothing to do with Engineering.


  3. Sam Penrose

    I disliked this piece fairly intensely; it took me back to the Foucault/Derrida/etc. I read in college and see no reason ever to read again. Responding to it point by point would take a longer article than the piece itself. I’m commenting mainly to recommend “Big Ball of Mud”, which it references, for a future Code Read.