Software quality isn't automatic, especially in organizations not using code inspections. For them, testing is the only way to find out about the quality level of the project. Testing departments tend to be large and even if there aren't many testers, at least the time reserved for testing tends to be fairly high. In such organizations, all the eggs are in the same basket. There's only one quality method, testing.

Paradoxically, the high amount of man-power or scheduled time is not enough. This is the symptom. You have relatively much testing resources, but you still can't manage. Something is missing from the equation. The situation isn't balanced. Without the informative checkpoints provided by regular code inspections, a project can veer out of control long before testing can even begin. It is rather likely to hear constant complaints about under-resourced testing departments or not having enough time for testing.

The testing seems always to come late and the view is not completely false. Because testing comes after coding, any delays in coding will show up in testing. Any defects found in testing cause rework in coding, after which re-testing is necessary.

Sometimes testing uncovers critical problems very late. This might be because other defects have been masking the problems before. Testing needs to execute the code and as long as the code isn't executing, it won't get tested. For instance, defects that prevent using a certain feature, prevent also the testing of it. Any defects in the feature itself remain uncovered until the feature can be accessed. Code inspections don't need the code to execute, but that is a property test-only organizations lack.

(Warning! A literary reference is imminent. Shakespeare, Hamlet. Proceed with caution!) Just like in the state of Denmark, there's something rotten in the fatalistic thinking in test-only organizations. They think that all software faults are unavoidable. Testing becomes bloated because defects are inevitable.

"Because there are going to be many defects, we'd better reserve a lot of testing time"

is a self-fulfilling prophecy, which turns Steve McConnell's thought in the excellent "Code Complete" upside down:

"We haven't planned much time for testing because we're not going to find many defects."

The more time and resources you plan for testing, the more acceptable it seems to leave defects in the code. People, especially software developers, in test-only organizations seem to be convinced that testing will find the faults anyway, why bother trying to avoid them?

Another symptom in organizations focusing their quality activities on testing and not doing inspections is the animosity between testing staff and programming staff. This applies assuming there are two separate groups of specialists in the organization. From the testers' point of view the programmers are careless and leave too many defects in their code before testing. From the programmers' point of view the testers are mostly complaining about minor issues. The relationship between the groups is often fragile and the communication minimized. It is almost as if the two groups were enemies instead of working for the same goal of producing quality software according to the plan.

Hostile tester-programmer relationships, belief in the inevitability of software faults and huge testing departments desperate for ever more growth are symptoms of excessive dependence on testing. Code inspection as a new means to control software quality could relieve this kind of testing addiction.

Testing seems to me to be overestimated since it is not the cure, testing just points (approximately even) to the need of more careful working. Preventing errors, learning quickly from one's mistakes are the only possible ways of becoming truly better in software. With Tick-the-Code, it is possible, feasible and makes the job so much more fun.