Why lack of confidence can make you a better programmer
What if you're not a superstar programmer? What if other people work longer than you, or harder than you, or have built better projects than you? Can you succeed without self-confidence? I believe you can, and moreover I feel that lack of confidence can actually make you a better programmer.
The problem with self-confidence
It's easy to think that self-confidence is far more useful than lack of confidence. Self-confidence will get you to try new things and can convince others of your worth. Self-confidence seems self-evidently worthwhile: if it isn't worthwhile, why is that self-confident person so confident?
But in fact unrealistic self-confidence can be quite harmful. Software is usually far more complex than we believe it to be, far harder to get right than we think. And if we're self-confident we may think our software works even when it doesn't.
When I was younger I suffered from the problem of too much self-confidence. I wrote software that didn't work, or was built badly... and I only realized its flaws after the fact, when it was too late. Software that crashed at 4AM, patches to open source software that never worked in the first place, failed projects I learned nothing from (at the time)... it's a long list.
I finally became a better programmer when I learned to doubt myself, to doubt the software that I wrote.
Why good programmers lack confidence in themselves
Why does doubting yourself, lacking confidence in yourself, make you a better a programmer?
When we write software we're pretty much always operating beyond the point of complexity where we can fit the whole program in our mind. That means you always have to doubt your ability to catch all the problems, to come up with the best solutions.
And so we get peer feedback, write tests, and get code reviews, all in the hopes of overcoming our inevitable failures:
- "My design isn't great," you think. So you talk it over with a colleague and together you come up with an even better idea.
- "My code might have bugs," you say. So you write tests, and catch any bugs and prevent future bugs.
- "My code might still have UI problems," you imagine. So you manually test your web application and check all the edge cases.
- "I might have forgotten something," you consider. So you get a code review, and get suggestions for improving your code.
These techniques also have the great benefit of teaching you to be a better programmer, increasing the complexity you can work with. You'll still need tests and code reviews and all the rest; our capacity for understanding is always finite and always stretched.
You can suffer from too much lack of confidence: you should not judge yourself harshly. But we're all human, and therefore all fallible. If you want your creations to succeed you should embrace lack of confidence: test your code, look for things you've missed, get help from others. And if you head over to Software Clown you can discover the many mistakes caused by my younger self's over-confidence, and the lessons you can learn from those mistakes.