Originally published on stickyminds.com
Some time ago, I was acting as a QA manager in a troubled organization. We were experiencing quality problems: the software was shipping with more defects than we wanted and was becoming less rather than more stable with time. I felt quite certain I knew what the problem was. “We don’t have any coding standards,” I fumed. “We don’t have any guidelines to help developers make good decisions about the tradeoff between improving performance and bullet-proofing. We don’t have any documentation on how to use our own APIs” (Application Programming Interface).
I took the opportunity to bend the ear of a friend in the industry, Brian Lawrence, over a friendly lunch one day. He cocked his eyebrows at me quizzically (a Brian Lawrence trademark) and asked a simple question: “Are you sure that’s the problem?”
At first, I was defensive. “Of course that’s the problem!” I grumbled. But Brian was right. The lack of coding standards was a problem, but it wasn’t The Problem. There were a number of reasons for our quality problems. The most important of those problems was a lack of requirements and design analysis, rather than a lack of coding standards.
It’s Not the Problem?
I often fall into the trap of thinking that the first problem I see must be The Problem that needs to be solved. Perhaps the problem I spotted is indeed worth correcting, but I almost never manage to spot the true critical issue at first glance.
At one company, I thought that The Problem was a lack of unit tests. I started beating the drum for better unit tests. Some of the developers agreed with me and encouraged me. Others politely ignored me until I went away. Still others rolled their eyes whenever I started my “Unit Testing Is Your Friend” stump speech.
Then I attended a meeting in which we were discussing bugs in a particular area of the code. The developer responsible commented, “Oh, good. I was wondering when you guys were going to start finding those bugs.” I was shocked. The developer already knew about the bugs. He didn’t need better unit tests; he needed time to fix the bugs. He knew he wouldn’t get that time until the test group found the bugs themselves.
I had found a problem: in some cases the unit tests were insufficient. However, that wasn’t The Problem. In this case, the deeper problem was that developers didn’t get time to fix the bugs they found. As far as management was concerned, until a tester found it, it didn’t exist.
No, It’s a Symptom
In a meeting toward the end of another project, a developer began talking about some changes he’d made to the way a particular feature worked. “Wait,” I interrupted. “I thought we were in code lockdown phase. Now you’re telling me that you’ve added functionality. What’s going on here?” Three weeks to ship and we were still changing the way the software worked. “Poor change control will sink us!” I thought.
However, it turns out that the changes the developer was making were part of the original plan. The problem wasn’t feature creep or poor change control, it was that the schedule said we were supposed to be done with the feature, so development claimed to be “done” while still implementing functionality outside the process. What we really needed was a more honest schedule, not a better change control process.
My Problem, Your Problem, The Problem
On yet another project, we were in code lockdown phase. Only Sharon, the development manager, was supposed to have access to check in code, thus forcing all changes to go through her. Because we were very late in the process, Sharon was to review all changes before checking them in—enforced code inspection.
I heard a rumor that one of the developers was checking in code on his own, without going through Sharon. That developer’s area was also currently the most bug-ridden. “Aha!” I thought. “Here’s the problem!” “Sharon, I heard that Bob is checking in changes without going through you. Is that true?” I asked in a meeting. Sharon looked at me, then looked away guiltily. “Well, I’m pretty overloaded and I don’t understand what that code does anyway. So I gave Bob permission to check in his stuff without going through me.”
I’d found a problem all right. Bob’s code was so complex that the manager of the department, a fine developer in her own right, didn’t understand it. The problem wasn’t unmonitored changes; it was the complexity of the design.
Solve Symptoms; Keep Looking for Problems
In each of these stories, I really had found a problem. However, I hadn’t found the real problem. I’d found symptoms. So if problems hide behind problems, how can you spot The Problem?
- Open up your mind to other possibilities. Ask yourself, “What if the problem I see didn’t exist? What other problems might be at work here?”
- Talk with others about what you’re seeing and hearing that’s telling you there’s a problem. Listen carefully to their responses. Often people who are not part of the problem have the greatest insight into what might be going on.
- If the problem you noticed is simple enough to address, fix it and see what else crops up.
You might even find out that The Problem is a lack of definition of the problem(s). For more information on defining the problem, see Are Your Lights On? by Gerald M. Weinberg and Donald C. Gause.