Write One to Throw Away

A technique sometimes employed in developing computer software that occurred to me might equally have an application in philosophy is that of rapid prototyping. This typically involves constructing a ‘quick-and-dirty’ version of the system you’re trying to develop that mimics how many of its main features will work, but without all the effort that goes into constructing the fully working version. Consequently, many details of the prototype will be missing or inaccurate, and its implementation is likely to be of sub-standard quality. Nevertheless, the process of building such a prototype has several benefits. Firstly, you get to see roughly what the finished product will look like well before it’s actually complete, thus giving you the opportunity to gather feedback, refine the design, and so on early on in the development cycle—i.e. before various key decisions become too entrenched to change easily. Secondly, the experience that you gain from constructing the prototype will itself help to inform decisions about the construction of the final system, even if it’s a matter of how not to do things rather than providing a positive role model.

Perhaps the most important feature of such a prototype, however, is that it is built to be thrown away. This enables one to take all kinds of shortcuts that wouldn’t normally be acceptable but without this negatively affecting the quality of the final product. Indeed, it’s generally considered to be a Bad Idea to use a prototype as a basis for the final system. This is partly because it’s likely to constitute a rather shaky foundation given that it was created rapidly with relatively little concern for its internal structure, but also because after creating the prototype you are in a much better position to see how the same task could be achieved a whole lot better the second time around. In other words, when it comes to prototypes, what matters isn’t so much the end product as the experience that you gain through creating it.

This process of ‘writing one to throw away’ has obvious application to the production of philosophy papers and other academic work. Unless one is an absolute genius (and there are few of those around), the first draft of one’s initial ideas are likely to be pretty sketchy. We therefore try to refine and develop these over time into something that is (hopefully) more worthwhile. However, given that writing philosophical prose is generally quite difficult, it’s very easy to fall into the trap of letting one’s prototype evolve into the final product, rather than simply throwing it away and starting again, as the above approach might suggest. The danger is that, by building one’s thoughts upon the (almost inevitably) shaky foundations of a first draft—i.e. the initial prototype—the structural and argumentative inadequacies of the original continue to affect the shape of the more fully developed paper, with potentially disastrous results.

I often find in my own writing, for example, that as I work on a piece I become more and more attached to certain sections or forms of words, making me very reluctant to remove or rework them should they prove less than central to my argument. Moreover, it is often only after I finish a paper (typically an assessed or tutorial essay) that I have a clear and precise idea of the crucial issues are and what it is that I want to say about them. This is, of course, precisely the point at which one should start writing a paper, rather than finishing it, and so it would be wise to take this into account by writing an exploratory ‘prototype’ before getting stuck into the real thing so that the main issues may be more easily and quickly identified.

Of course, simply throwing away one’s first draft and starting again is no guarantee that the second draft will turn out to be any better. It may be that the flaws inherent in the former will find their way into the latter precisely because they reflects flaws in one’s way of thinking or approach to the issue in question. It is, therefore, essential both to test the prototype by reading, discussing and reflecting upon it, and then to apply the results of this process to the creation of the finished paper. There is also a danger of going too far the other way and, in trying to rectify all of the defects in the first attempt, creating a monster that spirals out of control—a pitfall that is known in software engineering circles as the ‘second system effect’ (Brooks 1975). However, provided that some basic ground-rules are observed, one’s second attempt is generally a substantial enough improvement upon the first that it can form the basis for subsequent revisions with relatively little major restructuring.

No doubt many will consider these suggestions to be good philosophical practice, but how many of us make a deliberate effort to throw away our first attempts in order to create a more structurally coherent successor? As Brooks himself says, there is ‘no silver bullet’ to managing complexity—or in this case to writing substantially better philosophy—but it’s possible that at least some of the problems inherent to many philosophical papers could be avoided by following the rapid prototyping maxim of ‘write one to throw away’. (No doubt the same logic also applies to writing blog entries, but one has to draw the line somewhere!)