You're a good driver. You wear your seatbelt, you signal all your turns and lane changes, you don't drive tired, and you always check your blind spot. And yet, more than once in your driving career, you don't - you get viciously honked at by the minivan that's been sitting in your blind spot for 15 minutes, you swerve back into your lane, and once your heartbeat returns to normal you vow never to make that mistake again. After a while - months, or years - the same thing happens, and you wonder, "I KNOW about blind spots, I KNOW not to make this mistake again, but I still did. What's wrong with me?"
No, I'm not talking about Mark's driving. You've probably guessed that I'm leading up to software engineering. Over time, I've noticed that every project I've worked on develops its own set of blind spots - problem areas that tend to get ignored because they're not part of the main focus, but they keep popping up again and again.
In my previous life maintaining a software product for the health care industry, every release went as smoothly as anyone could hope. We made mistakes, learned from them, improved the process, and avoided them in the future. All except one class of mistakes: those dealing with peripherals - printing, fax, email. These were minor features that were part of version 1 (before our time), and because they were never related to new features, they often fell into our blind spot, and caused a disproportionate amount of problems. Every time that happened we said "we'll learn from our mistakes, next time we'll do better" - but next time there it was again, the same damn minivan in our blind spot asking why the fax isn't working.
ClutterMe is developing a few blind spots of its own. One example is IE. As a Firefox user, I know IE support is essential, I know most of our users will be using IE (though so far only about 30% do), I know I need to constantly test in both Firefox and IE, and I usually do - except when I don't. And then I have to backtrack, fix the problem, and ask myself why I didn't check in IE that one time.
In a way this is to be expected. In a small team, everyone's juggling a long list of tasks. The ones at the top are usually the most important, the most critical, or the most interesting. Eventually the tasks at the bottom bubble up to the top and get done - but some are stuck at the bottom forever. Classic case of
resource starvation, where the resource can be the developer's time, interest, or self-discipline. So what's the solution?
One obvious answer is to improve the process - like, say, coming up with a release checklist with the things that are often forgotten. Makes sense on paper, but ultimately a checklist doesn't feel very satisfying - having an "oh crap" moment one week before release is only marginally better than having it one day after. The blind spots are still there.
A drastic solution is to eliminate the blind spot entirely. Do people really still need to send faxes in 2007? (the answer, unfortunately: yes). If the feature that's always causing problems is minor and unrelated to the core functionality, can it simply be axed? If yes, great, but in many cases you're stuck supporting it.
Maybe increasing visibility is the answer. Tools can help: my skin crawls every time I click on the blue "e" icon? I can start using
IE Tab. Constant performance problems? Might be worth investing in a profiler.
None of these solutions work in all cases. If blind spots are indeed a common class of problems, it feels like there should be a common solution, but I haven't been able to find one.
What is your experience? How do you deal with blind spots (software or otherwise)?
Labels: blind spots, software engineering