Software Developers Hate Optimism (But They Shouldn’t)
We’ve all been there before. It’s late into a meeting and the product owner comes up with just one more nice-to-have feature to sneak into a work-in-progress. The youthful or inexperienced developer next to you pipes up, “Oh yeah, we can do that. I can have that knocked out in five minutes.” You rub your eyes and then let out a small sigh. You know it won’t take five minutes. And you also know the developer is probably going to stay up all night trying to squeeze in that “simple” addition, so they don’t look like a fool when they realize it wasn’t all that simple. That when you reiterate your age-old developer axiom, “I hate optimism. It throws estimates and make developers look stupid.” And you would be right, if that was optimism.
But it isn’t. What developers and even product managers commonly confuse with optimism is naivety. That’s the problem. The gung-ho attitude is good, and essential to a great developer. The danger lies in the naivety that we so commonly associate with optimism. Only when we slice the two apart does the best developer shine through.
So, let’s break it down. What is optimism? BlueEQ characterizes optimism as “being cheerful, hopeful, and enthusiastic… believing in what’s possible, and expecting and contributing to positive outcomes.” What’s naivety then? Oxford primarily defines naivety as “lack of experience, wisdom, or judgement.” So often younger developers come in with enthusiastic attitudes and coincidentally a lack of experience that’s required to act wisely or express professional judgement or opinions. When a developer wizens, they can become (excuse the pun) bitter and negative, but also possess a great deal of experience that formulates into wise professional decisions that express sound judgment.
All this compounds when our industry rewards pessimism. We’ve all met that one older developer working at the enterprise company who always says, “That won’t work” or “That won’t be easy.” They guard every statement with “maybe,” “might,” or “probably,” and never make promises on anything. They are, in most cases, generally good at their job because of those attitudes. They aren’t likely to take any big risks, and keep their monolithic applications chugging along by batting away the risky integrations and the large changes (well-founded or not) to the codebase architecture.
So, what’s so bad about being a pessimist? Almost sounds like a sweet deal and good call. But as I mentioned before, optimism is essential to a great software developer. A quick look at a pessimistic developer is all you need to do to see this is true. A pessimistic developer is more apt to give-up, and complain about the codebase, co-workers, and the work. They refuse to take on risk because they cannot see a scenario where it will pay off. They don’t often implement new patterns or new technologies because they can’t envision a better future than their current situation – only worse. So, they trudge along complaining that nothing will ever get better and thinking there is no possibility of a bigger brighter future ahead – only a darker future where the codebase is more fragmented and complicated than where it was before. Whew! Depressing. But there is a better way.
An optimistic developer who managed to mature beyond the stage of naivety and get the experience is the person you want on your team. An optimist is not afraid to take risks, and therefore they reap the rewards. Their experience, not mindset, will dictate what risks they take. Some inexperienced optimists will take on unfounded risk. But that should not be a mark against optimism, rather it should be attributed to the inexperience. You can’t dampen their spirits and they can’t wait for the next day and they aren’t deterred by the challenges that may come. Optimists often have high praise for their fellow co-workers, and they love their projects (because they can envision a bright future for them!). But I hear you in the back. What about estimation?
Most would say that optimists are bad at estimating, and consistently “under throw” and therefore their projects often run over-budget. Well, no. Naïve optimists are bad at estimating. The sole purpose of estimation is to render an education guess on how long it will take to accomplish something. Nowhere in that process should emotion affect the outcome. Optimism, by definition, is an emotional mindset and a key component of emotional intelligence. A wise developer will attempt to exclude their current emotions, optimistic or pessimistic (inherently bad as well, but for other reasons), from influencing their estimation.
The sole power of an optimist is to see the positive in the situation. So often the realists are pitched against the optimists, but, realism (coming from experience) and optimism (coming from mindset) combined together make the powerful entity. The realistic optimist seen things as they truly are without the “rose-colored glasses,” but still chooses to focus on the positive. I can think of no better phrase that encapsulates this principle than the common Aptera saying of, “I don’t know if that will work, but let’s give it a shot.”
Be the Leader Who Pushes Software Initiatives Forward
Get an Aptera Team on Your Side