11.

Learning in a Fast-Paced World

The trends in agile computing and open-source projects can help to meet some of the increased demand for reliable software. But the quality and safety of the software produced inevitably depends on the skill and experience of the programmers involved. And the available supply of experienced programmers is smaller than the demand for them.

Tip 

Teaching developers to recognize bug patterns is a way to leverage the experience of many programmers to improve the effectiveness of each.

To address this shortage, we need ways to quickly convey to new programmers more than just the theoretical knowledge traditionally taught in computer science classes. We need to convey the kind of practical skill in developing robust systems that is normally gained through many years of experience.

Some of this experimental knowledge consists of various design patterns that have proven themselves to work in a variety of contexts and are now taught regularly in computer science curricula, alongside basic algorithms and data structures. But quite a bit of the working knowledge gained by experienced developers isn't demonstrated by such design patterns.

Part of this working knowledge consists of the ability to efficiently diagnose and fix bugs exhibited by a software system-in other words, effective debugging.

Effective debugging is far from a trivial skill. In fact, tracking and eliminating bugs constitutes a significant portion of the development time in a software project. If this task can be made more efficient, the resulting software will be more reliable and it will be developed more quickly.

While educating new developers, both in industry and academia, I've noticed some general tendencies in the ways they learn to debug software. Beginning programmers often work against themselves when considering the potential causes of a bug. They tend to:

1. Blame the underlying system (as opposed to their own code) far too quickly;

2. Convince themselves that the bug they are witnessing can't possibly occur (an idea that could never be anything but a delusion); and

3. Thrash about, randomly changing code until the symptoms of the bug go away.

All of these tendencies diminish with experience. If novice programmers are made aware of them, they can learn to avoid them before they start real-world programming. But there is more to becoming a good debugger (which is a component of becoming an agile, effective developer) than just overcoming bad tendencies.