As developers, it’s easy to fall into the trap of believing that everything we develop will have its intended effect.
We like to believe that what we make will be a success, so we plan for a project with the high expectations that it’ll yield a positive outcome and high return on investment. So, we allocate a lot of time and resources to a project, seeing it all the way through to completion without batting an eye. Then, once it’s done, we deploy it happily — glad that it’s packaged and finished.
The Naivety of Blind Optimism
Dare I say, planning only for success is extremely naive. Optimism is good, but blind optimism is a recipe for disaster. And planning with the assumption of success is a clear-cut example of the kind of blind optimism that can have disastrous consequences. Unfortunately, this problem plagues the culture of many tech companies both large and small.
You might be familiar with the consequences that come with blind optimism. For example, you may have spent days, weeks or even months building out a component, project or some sort of tool that never sees the light of day. Worse yet, maybe you tried constructing an app of your very own just to quit halfway through or utterly fail because you either didn’t plan properly or were too overwhelmed by the black swans and other obstacles that you encountered along the way. Regardless of whatever situation you might have faced, it’s hard to escape that sinking feeling that comes along with failure that dashes your optimistic assumptions of success.
This approach to problem-solving — building first and verifying later — can bring about many unintended consequences that we fail to foresee. Blind optimism causes us to only see the end goal and dismiss all the factors required for success along the way. It’s as if we stop planning, stop designing and stop thinking about the audience.
Etsy, the online arts-and-crafts-selling platform, learned this lesson the hard way. The company invested months of time and hundreds of thousands of dollars in resources to build out an infinite scroll feature for its product pages, fully expecting that this feature would increase turnover rates. Despite all the resources poured into it, however, the infinite scroll actually decreased turnover rates. This failure was likely due to the Paradox of Choice , which suggests that the more options we have to choose from, the less likely we’ll be satisfied with our choice. Therefore, we often opt not to choose at all.
Don’t be Etsy. Don’t plan, develop and architect code with the mindset that it can only succeed. More than likely, you’ll find that you made a poor investment.
Instead, do the complete opposite. Plan for failure.
Yes, optimism is important, as is visualizing success. Having a clear-cut goal to pursue with discipline, a forthright attitude and high hopes allows developers to persist through obstacles and see a project through to completion. It allows us to get things done.
The truth is, though, we’re not omniscient. We can’t know the actual impact our products will have, if any at all.
I’m not saying that you have to exclusively expect that you’ll fail, but you must make yourself acknowledge the possibility that what you build might not work. Your development work may be for naught, the components you build may be unscalable, and all your investment of time and resources may turn out to negatively impact your organization or clients in a way that causes the company to suffer or customers to bolt.
In the ancient world, the Stoics ordered their world around this very principle. Their philosophy was later summed up by the Latin proverb premeditatio malorum , encouraging the premeditation of evils that may lie ahead. In other words, they assumed that they would fail and imagined everything that could potentially go wrong during any endeavor. They visualized disaster not as a means to be pessimistic, but as a strategy to be more resilient in the face of adversity.
When you see in your mind’s eye that whatever you develop will, at one point, inevitably crash and burn, you can then plan accordingly. You can strategize and cultivate your development process such that you’re more focused, meticulous and calculated about what and how you engineer.
This way, when the worst comes your way, you’re less emotional about the situation. Rather, you’re more logical when you evaluate how to resolve broken processes, scalability issues, poor user engagement, and heavily coupled/dependent relationships between functions and classes. You can take a step back and think deeply about how you want to implement new processes. You’re primed to test often, share your progress with others, and write code in a very clean, structured manner so that it will survive and make sense to others.
Etsy’s leadership learned this lesson from their catastrophic failure. They came to the realization that you can’t gamble on the success of a project. Therefore, with every project moving forward, they decided to build out 10 percent of their project really well, and perform A/B testing on what they had. At that point, they decided whether or not they should continue the project and evaluated what changes they needed to make. It’s a useful strategy that paid off big-time for their company’s stability and success . Best of all, it allowed them to be flexible.
Follow suit and you too will find yourself becoming a more resilient and effective developer.
The Right Attitude
Now, I don’t want you to walk away from this article believing that I’m preaching that you must think more negatively. That’s the wrong message.
Rather, I want you to use pessimism as a strategic means to build a more optimistic development career. Use negative visualization to advance your abilities and complement your optimism. The caveat is that you shouldn’t let such negative visualizations cripple your confidence in what you build.
Developers play a heavy hand in advancing the world of technology and business. To be able to be an effective contributor, you must be more realistic and down-to-earth on the potential roadblocks that you’ll face , which is something I believe we need to see from more developers.
Don’t let the idea of failure scare you. Let the idea of failure allow you to flourish and become better.
Essentially. find a way to be an optimist without being a fool.