I'm Fahim, a software developer turned tech founder. This article is part of my series: The Developer’s Launchpad. I'll share my top lessons, hacks, and best practices for learning how to code and launching a new career — things I wish I would've known earlier in my journey. If you're starting out your own coding journey, this series is for you.
Your odds of succeeding in a new endeavor — whether it's martial arts or programming — is largely a matter of mindset. With the right mindset, you can set yourself up for long-term success in your coding journey (and any other journey for that matter).
As it turns out, there's one mindset that separates master coders from the rest: and that's embracing mistakes. As an aspiring developer, learning from mistakes and moments of failure can mean the difference between quitting and achieving the career of your dreams.
Mistakes are inevitable.
I've seen too many people quit coding because they believed their struggles meant they weren't cut out for coding. In reality, mistakes are an inevitable part of the learning process.
As with learning to ride a bike, you expect to get bruised and scraped before you can do tricks. Same goes with learning to code. As a beginner, you will make mistakes on understanding concepts, correctly using syntax, and so on.
Mistakes are not only common — they're allowed and expected. Whether it's an error, bug, or dysfunctional code, even professional developers make mistakes (if they didn't, organizations wouldn’t dedicate timely processes to test or review code).
The sooner you normalize making mistakes, the healthier relationship you'll have with learning. In fact, if you're not making mistakes as you're learning, it's probably a sign that you're not getting enough of the hands-on practice that's essential to your learning.
You can learn by doing with our 50+ hands-on courses and projects for beginners: Learn to Code with Educative.
If you feel like you’re failing in your learning journey, remember that the only true failure is throwing in the towel and giving up entirely.
You're on the same path as the greats.
Every great developer — from Steve Jobs to Linus Torvaldz — has made even the most trivial mistakes. The only difference between them and others is that they persisted despite them.
If we're comparing ourselves to the greats, it can be easy to find their stories unrelatable. However, it's worth noting that the world doesn't often discuss the mistakes famous developers made along the way. Consider James Gosling, the founder of the Java language. Hardly anyone talks about the mistakes he inevitably made while creating a new language. And even fewer people talk about the fact that he was part of a dropped project prior to Java (the Star7 personal handheld computer).
The reason we don't discuss others' mistakes is because they're normal. Most of the time they're not unique, and they surely don't define or disqualify anyone's status as a programmer. In fact, many of your role models have experienced the same troubles you will face in your learning journey.
“It’s fine to celebrate success but it is more important to heed the lessons of failure.” — Bill Gates
Foster the growth mindset early.
While they can be frustrating, mistakes are learning opportunities. Every bug, crash, and non-functioning line of code can guide you toward clarity. When they present themselves in patterns, they point you toward the areas where you need to strengthen your understanding.
Your long-term success as a coder depends on your ability to foster a growth mindset. A growth mindset is characterized by a constant willingness to improve and the resilience to bounce back from failure.
When you're on the hunt for your first developer job, a growth mindset is an essential trait that employers look for. I saw many skilled developer candidates make errors when I interviewed them at Microsoft, Facebook, and my current company, Educative. However, as long as they were able to fail gracefully by owning up to their mistakes and displaying a willingness to learn, they were still able to get my vote as a hire.
Embracing failure makes you a better problem-solver.
You’ll become a good problem-solver with experience. But what will make you an excellent problem-solver is being unafraid of failure.
Why?
Great developers are creative and curious. They’re able to find new, more efficient ways to solve problems. While they exercise reasonable caution, they don’t hold themselves back because of the prospect that their idea won’t work.
By embracing failure yourself, you will become a more innovative programmer. If you’re afraid of failure, you can spend all your time deliberating on an idea instead of executing it to see the outcome. But if you're unphased by failure, you give yourself the courage and freedom to try new things (and if they don’t work, to learn from them).
Mistakes are milestones.
Remember: even the best developers have made the most trivial mistakes. What matters is not how often you fail, but the fact that you learn from failure to become a stronger developer.
Failure is not the opposite of success; it's a part of it. So keep coding, keep making mistakes, and most importantly, keep learning.
Until next time, I'll leave you with one of my favorite quotes about failure:
"Failing is not the falling down, but the staying down." — Mary Pickford
As a reminder, we have 50+ projects and courses for beginners at Educative. You'll code as you learn, and get AI-assisted feedback to help troubleshoot and learn from your errors. Check out our Learn to Code resources with a free trial today.
Top comments (3)
Totally agree. People who are afraid to make mistakes move slow and are very vulnerable to scope creep, because they want to do things right in one go. Making lot's of mistakes and doing quick incremental improvements is much better imho. Faster way to learn and improve.
It's the process to become a good coder. Through mistakes and fine ways to get over it. Completely right.
Great for me this is helpful!