There are always those devs who think they're infallible, but even expert developers make mistakes. Is this a bad thing? Read on for some insight.
When pressed, I bet you can think of an interesting dichotomy in the software world. On the one hand, we programmers seem an extraordinarily helpful bunch. You can generally picture us going to user groups, conferences, and hackathons to help one another. We blog, record videos, and help people out on Twitter.
But then, we also seem to tear each other apart. Have you ever hesitated before posting something on Stack Overflow? Have you worried that you’ll miss some arcane piece of protocol or, worse yet, that you’ve asked a stupid question? Or, spreading our field of vision a little wider, have you ever seen nasty comment sections and ferocious arguments?
We programmers love to help each other, and we also like to rip each other to shreds. What gives?
But let’s set that aside for a moment. Instead, let’s try to squish the programming community into a single (if way over-generalized) human being. How can this person be so helpful, but also so rude?
In the programming community, we gravitate toward conceptual, meritocratic ladder ranking. 'Expert' thus becomes a hard-won, carefully guarded status in the community. Show any sign of weakness, and you might worry that you’ll fall down a few rungs on the ladder.
As a result, many in the field try to exude an air of infallibility. Most commonly, this manifests in the form of that guy that never, ever says “I don’t know.” More generally, you can recognize it in the form of constant weighing in on all sorts of topics. In this field, we do tend to build up an impressive beachhead of knowledge — algorithm runtimes, design patterns, API calls, tips and tricks, etc. Armed with that, we can take up residence in the expert’s chair.
But no matter how we try to disguise it, we inevitably make mistakes. Perhaps we do something as simple as introducing a bug. Or maybe we make a fundamentally bad call about some piece of architecture, costing lots of time and effort. Big or small, though, it happens. The interesting question is why? If we log Malcolm Gladwell’s famous 10,000 hours of practice and have heavy incentives to show no weakness, why do we still make mistakes?
Perhaps most simple and obvious, lapses in concentration will lead to mistakes. This applies no matter who you are, how much you practice, or what you know. This can happen in immediately obvious ways. For instance, your mind might wander while doing relatively repetitive programming tasks, like updating giant reams of XML configuration or something. Generally speaking, monotonous work creates a breeding ground for mistakes (which speaks to why doing such work is a smell for programmers).
But it goes beyond the most obvious as well. Feeling tired or distracted can lead to concentration lapse mistakes. Interruptions and attempts to multitask do the same. I don’t care how much of a programming black belt you may be — trying to write code while half paying attention to a status call will lead to mistakes.
As I mentioned earlier, in the giant ladder ranking of programmer meritocracy, “I don’t know” can knock you down a few rungs (I’ll leave it to the reader to evaluate whether this happens in actuality or only in our minds). This leads to a behavior wherein we may try to “wing it,” even in unfamiliar territory.
When we do this, we have no one but ourselves to blame for the inevitable mistakes. On my own blog, DaedTech, I once gave a label to those who frequently posture and fail this way: expert beginners. Of course, that label talks about someone of marginal competence, but even a bonafide expert can fall victim to too much self-assurance. The field of programming presents such an immense and complex surface area that you will always have blind-spots. Pretending you don’t will lead to mistakes.
Programming is knowledge work. This means that we, as programmers, solve problems rather than perform any sort of repetitive labor. Sure, you might write a handful of custom web apps that prove similar in nature. But this is a far cry from the cookie-cutter nature of, say, assembly line work. Even when writing somewhat similar apps, all of our work involves solving problems that no one has yet solved.
I’ll conclude by going even further than a labeling mistakes as an inevitability. You should make mistakes. In the first place, I think that a culture wherein we consider mistakes signs of weakness is counter-productive and asinine. Having prominent experts say, “gosh, I really don’t know” encourages us all to do the same and it generally promotes a more productive culture.
But the benefit runs deeper. I’ve heard it said that, if you’re not making mistakes, you’re probably not doing anything interesting. And I firmly believe in that. Pushing the envelope means making mistakes. But, even beyond that, whether we make mistakes or not is less important than developing robust recovery mechanisms. We should design software and systems not with an eye toward perfection, but with an eye toward minimizing the impact of mistakes. After all, software is so fluid that today’s correctly functioning system becomes tomorrow’s ‘mistake’ when the requirements change. So you might as well get good at recovering.