Exploration Through ExampleExample-driven development, Agile testing, context-driven testing, Agile programming, Ruby, and other things of interest to Brian Marick
|
Tue, 27 Jan 2004I'm sitting in on a sociology of science seminar at the University of Illinois. It's about Andrew Pickering's The Mangle of Practice: Time, Agency, and Science. The idea is that participants will write a paper that may be included in an edited volume of follow-ons to Pickering's book. I'll be using this blog category to summarize Pickering's ideas as a way of getting them clear in my mind. The basic idea is one of emergence, that novelty and change arise from collisions. A scientific fact might arise from the collision of a theory of the world, a theory of instrumentation, and the brute fact of what the instrument does when you use it. A mathematical fact might arise from bashing together algebra and geometry in an attempt to achieve certain goals. What attracts me to Pickering's work is what attracts me to the agile methods: an emphasis on practice, on doing things in the world; the idea that the end result is unpredictable and emergent; the idea that everything is up for grabs, up for revision, including the goals you started with; and a preference for the boundaries of fields over their purest forms. The paper I'm thinking of writing is "The Mangling of Programming Practice from Smalltalk-80 to Extreme Programming". I think it's fairly well-known that the agile methodologists were disproportionately involved in Smalltalk and patterns way back when. What was the trajectory from Kent Beck's and Ward Cunningham's early days at Tektronix to the development of XP as it is today? It's a historical oddity that Smalltalk found a niche in the IT/insurance/business world. What was the effect of bashing the untidiness and illogicality of that world against the elegance of "all objects, all the time"? We see CRC cards being described in 1989. Today, the 3x5 card is practically a totem of XP. So is colocation, big visible charts, and so forth. Here we see an ever-increasing recognition of how the material world interacts with what is so easy to think of as a purely conceptual world. What's going on? Etc. Does Pickering's account of change shed any light on how we got from Xerox PARC to where we are today? And, more important to my mind, does it give us any ideas about where we really are and how we might proceed?
## Posted at 21:03 in category /mangle
[permalink]
[top]
Jonathan Kohl writes about the superbugs that remain after test-driven design. That inspired this ramble. Long ago, I was much influenced by mutation testing, an idea developed by DeMillo, Hamlet, Howden, Lipton, and others. (Jester is an independent reinvention of the idea.) "Strong" mutation testing goes like this:
I quickly grew disillusioned with mutation testing per se.
Nevertheless, I was - and am - enamored of the idea that after-the-fact testing should be driven by examining the kind of bugs that occur in real programs, then figuring out specific "test ideas" or "test requirements" that would suffice to catch such bugs. Back then (and sadly still sometimes today), test design was often considered a matter of looking at a graph of a program and finding ways to traverse paths through that graph. The connection to actual bugs was very hand-wavey.
It was my belief that programmers are not endlessly creative about
the kinds of bugs they make. Instead, they code up the same kinds of
bugs that they, and others, have coded up before. Knowledge of
those bug categories leads to testing rules of thumb. For example,
we know to test boundaries largely because programmers so often
use It was my hope back then that, by studying bugs, we could come up with concise catalogs of test ideas that would be powerful at finding many likely bugs. I published a book along those lines. (I was by no means the only person thinking in this vein: Kaner, Falk, and Nguyen's Testing Computer Software had an appendix with a similar slant. And Kaner has students at Florida Tech extending that work.)
What test ideas were novel in my book were based on bugs I found in
C programs. For some time, I've thought that different
programming technologies probably shift the distribution of bugs.
Java programs have many fewer As I've gotten more involved in test-driven design, it seems to me that micro-process will probably also have a big effect. Jonathan's note increases my suspicion. So now I'm thinking of things we might do at the Calgary XP/Agile Universe conference, which looks set to be a hub of agile testing activity.
It's too late to submit formal proposals to XP/AU, but there's lots of scope for informal activities. |
|