During my sophomore year in college, one of my capstone projects for CS321: Intro to Web Application Development class was to build a complex e-commerce website for a local business in our college town. It involved getting in touch with the business, gathering some requirements, then building the application. Once I got the requirements, I got excited, hopped on in front of my computer and started typing away some code.
I was confident that I could create something extraordinary and unique that would not just impress my classmates and professor but also would be an actual product the business would adopt launching my career as the next Steve Jobs!
Weeks turned into months and I poured my heart out into this project. However as deadline started creeping in, cracks in my codebase started emerging, features that were working smoothly started causing some unexpected errors and crashes. Each day I got more and more anxious.
No matter how hard I tried to fix up the mess of technical debt I'd built up, it just wasn't going anywhere. I had to face the harsh truth that my project was heading straight for failure. At one point, I threw my hands up and stuck the project on the shelf, thinking maybe some time away would help me tackle the issue later. But the problem was, the longer I left it there, the tougher it became to muster the motivation to pick it up again. It wasn't until the deadline was almost breathing down my neck that I snapped back to my senses and forced myself to dive back in.
In a moment of humility, I decided to reach out to my professor. I went into his office during his office hour and there we were looking at the spaghetti code that I had served in front of him. With his help I was able to figure out that because of my overengineering, I forgot to see the bigger picture and started complicating the auxiliary processes, causing the actual process to behave strangely. Those hours were truly humbling, as my enthusiasm had blinded me to the importance of maintainability and scalability.
In the end, I was able to finish the project, albeit with a smaller set of features than I had initially planned. While I failed to impress the local business enough for them to adopt my website, the failure itself became one of the most valuable lessons I learned. I learned the significance of maintaining a balance between ambition and practicality. More importantly, I learned that embracing failure and learning from it is an integral part of becoming a better developer. This lesson is still prevalent today as a professional software developer. Whenever I am getting overconfident I am able to think back to this moment.
So why did I share this anecdote?
Because I found that this is a common phenomenon among people and even developers. We tend to forget that our failure is a gold mine of knowledge. And I would like to share the nugget of golds I extracted from this failure with you. In this article I would like to introduce everyone to two terms
- Ostrich Effect
- Overconfidence Bias
1. Ostrich Effect:
Originating from the myth that ostrich bury their head when there is danger around, the “Ostrich Effect” is a psychological phenomenon where an individual shows the tendency to avoid situations or information that seems distressing or dangerous. People often show this phenomenon with a false belief that the situation or information that they are ignoring will resolve itself or go away if they choose to not acknowledge it.
I was acting like an ostrich with my head buried in the sand when I began noticing the cracks in my codebase. To avoid confronting the situation, I resorted to shelving my project. Unfortunately, this also made it increasingly challenging to regain the motivation to dive back into the project, confront the challenges, and learn from them.
Here are five strategies to prevent succumbing to the Ostrich Effect:
1. Confront Challenges:
Instead of avoiding problems, actively address them. Embrace difficulties as opportunities for growth, and tackle them with a proactive mindset.
2. Seek Information:
Stay informed and seek out relevant information even when it might be uncomfortable. Being well-informed empowers you to make better decisions and take appropriate actions.
3. Stay Open to Feedback:
Welcome constructive criticism and feedback. By listening to different perspectives, you can gain valuable insights and make necessary improvements.
4. Set Realistic Goals:
Set achievable and measurable goals, ensuring that you have a clear understanding of the task at hand. Realistic expectations help prevent the tendency to underestimate challenges.
5. Practice Self-Awareness:
Recognize your own biases and tendencies to avoid uncomfortable situations. Cultivate self-awareness to identify when you might be tempted to ignore problems and take steps to address them proactively.
2. Overconfidence Bias
This term refers to the tendency to have excessive confidence in one's abilities or judgments, often leading to taking on tasks that are more complex or challenging than one can handle. In my anecdote, the initial confidence in building an extraordinary and unique website might be an example of overconfidence bias.
My confidence led me to dive into coding without fully understanding the scope and potential difficulties. As a result, I encountered technical issues and unexpected errors that challenge my initial assumptions. This overconfidence bias contributes to the development of technical debt and the subsequent realization that the project is more challenging than initially perceived.
Do not fall into this bias and follow these five tips:
1. Stay Grounded:
Maintain a realistic assessment of your capabilities and avoid underestimating the complexity of tasks or challenges.
2. Embrace Humility:
Acknowledge that mistakes and setbacks are natural parts of learning. Embracing humility allows you to learn from failures and continuously improve.
3. Seek Diverse Perspectives:
Engage with others and welcome different viewpoints. This helps you gain a broader understanding of situations and make well-informed decisions.
4. Challenge Assumptions:
Question your assumptions and beliefs to prevent unwarranted confidence. Critical thinking helps you approach tasks with a balanced perspective.
5. Learn from Experience:
Reflect on past successes and failures. Analyzing your experiences provides valuable insights and helps you make more informed choices.
In closing, remember that some of the most significant growth as a developer emerges from failures. While successes may shine brightly, there's an art to learning from our missteps. Take a moment to look back, and you'll find that mastering this art of embracing failures can be a crucial part of your journey.
Top comments (0)