Why Getting Problems Wrong Can Lead to Getting Them Right
As programmers, we all make mistakes. It’s a fact of life. Some people seem to get problems right all the time, while others can’t seem to get them right no matter how hard they try. But what about the people who get it wrong but immediately get it right and become better at what they got wrong? These people possess a special resilience that allows them to overcome obstacles and turn failure into success. In this post, we’ll explore the three kinds of programmers and why the ones who get it wrong and then get it right are the most impressive.
The three kinds of programmers:
- Those who get it wrong all the time on the same problems.
- Those who get it right all the time on the same problems.
- Those who get it wrong immediately get it right and improve at the problem they got wrong.
The first two kinds of people are self-explanatory. The person who gets it wrong always on the same problems struggles with learning from their mistakes and may lack the motivation or ability to improve. Maybe they insist on using the same design patterns for situations where it doesn't apply, or they always solve a problem by trying to use brute force, and somebody else has to intervene.
The person who gets it right all the time on the same problems may have a natural talent or skill and read the right resources, but may also be risk-averse and unwilling to take chances in other directions of thought or experiment. They may insist on solving a problem by the book, and the impact on runtime is not bad but also not great, or they never design upfront because it’s the “Agile way”.
But it’s the third kind of person that is truly impressive. These people make mistakes but quickly learn from them, returning stronger than ever. They are adaptable and resilient in the face of failure and have the ability to turn setbacks into opportunities. They’re the ones who see nuances and try to solve the problem not by following a standard path but by deviating from it while making it clear it could be the wrong path, but at least we may learn something new.
Do you know that CRUD you’re building for the tax system? Maybe it needs a little more thought, so let’s do something minimal and wait for customer feedback, as we don’t know exactly what they want, although we pretend to. Do you know those microservices you’re building? Maybe we should go for a modular monolith and incur the development cost before we risk an even greater development cost by designing too early.
Why Resilience Matters
Resilience is an important trait in any area of life, but it’s especially valuable in a programming workplace. In today’s fast-paced and ever-changing tech environment, teams need programmers who can adapt to new situations and bounce back from setbacks. Resilience is also key for personal growth and development, allowing us to learn from our mistakes and become better versions of ourselves. It works for you, for the team and for your project.
No one is perfect, and we all make mistakes. But how we respond and prepare for those mistakes sets us apart. The most impressive people are not the ones who get it right all the time but rather the ones who can turn failure into success or actively design to induce controlled failure. We can become the best possible versions of ourselves by cultivating resilience and learning from our mistakes.
So don’t be afraid to take risks, jump in the wrong way, make mistakes, and learn from them. After all, the path to success is rarely a straight line.
Thanks for reading. If you have feedback, contact me on Twitter, LinkedIn or Github.
Top comments (0)