Author Archives: Tim Hall

Good blog post on Waterfall, Reality Avoidance & People Who Say “No”

One of the problems some managers have with iterative software development is that, when it’s done well – seeking early and frequent feedback and acting on it, as opposed to just incrementally executing a waterfall plan – it reduces the scope for avoiding reality.

On a waterfall project, reality can be avoided for months or even years. The illusion of progress can be maintained, through form filling and the generation of reams of reports that nobody ever reads, right up until the point that software needs to be seen to be working.

If it were my money, this would scare the shit out of me – not knowing what my money’s been spent on until the last moment.

But I can see the attraction for managers. It’s not their money. And typically they get rewarded for this illusion of progress, which can go as far as pretending the software is ready the night before it’s deployed into a live environment.

I think most of us who have worked in the software industry for any length of time will be nodding at that one. Been there, done that, got the polo shirt.

The whole thing is well worth a read, with some real life war stories leading to the inevitable conclusion.

Managers need to be rewarded for testable achievements, and steered away from peddling illusions. The reason this doesn’t happen more often, I suspect, is because the value of illusion increases the further up the ranks you go. If a PM gets a pat on the back for saying “we’re on track”, the CTO gets a trip to Disneyland, and the CEO gets a new Mercedes. Hence, the delusion gets stronger as we go higher. People running governments tend to be the most delusional of all, such is their power and influence. This effect is what produces the sometimes gargantuan IT failures only governments seem capable of creating.

Indeed. Though quite how you can stop politicians behaving like politicians isn’t an easy problem to solve.

I don’t often post about the testing I’m currently working on, but a current project has thrown up some interesting challenges that are worth commenting on.

The new feature I’m testing is a batch update process that replicates the functionality of some existing GUI forms, using another object in the system as the source data. The actual processing is quite complex with a lot of validation and data update rules. The GUI front-end hasn’t yet been built, so I’m starting out by testing the Oracle server-side procedures by calling them through TOAD, populating the temporary tables that drive them through some simple SQL scripts.

We’re not using the main system test environment with its strictly-controlled weekly builds, but a separate environment where the developer can apply changes as soon as required. This means there’s a much swifter turnaround than I’d become accustomed to when it comes to fixing bugs I raise. Sometimes I’ve found an issue, to see it fixed in minutes.

Because none of the code under test has reached the point of a formal build the bugs aren’t going into the bug tracking system. Initially we were just using an email thread between me, the developer and the business analyst to keep track of the bugs, but after a bit that started getting unwieldy so I started recorded them in a simple spreadsheet instead.

I’m still using an exploratory testing approach, with the added advantage that the persistent data in the “temporarily” tables can serve as a record of the test cases I’ve tested. As for the source of those test case, there are very detailed functional specifications, but I’m finding the best “oracle” is actually the equivalent GUI functionality, which I’ve tested and regression tested often enough to have memorised most of the validation rules. Indeed, a significant proportion of the bugs I’ve been finding have turned out to be specification issues rather than coding errors, or edge cases that weren’t covered by the new business rules.

It’s not the usual way I’ve been working on this project, which is very Waterfall, but I’m finding working closely with the developer and seeing bugs turned round far more rapidly is a very productive way of working. Of course, once the GUI front-end is built and it’s all included in the build and spun into the proper system test environment, I’m going to have to test it all over again. But at least we’ll have pre-emptively squashed most of the bugs, and it will take far fewer iterations for it to become stable.