Software Engineers are biased, and it’s ruining our software

There are an awful lot of software libraries and developer tools out there. So many that a single developer will never see it all. So we go with what we know. But often, what we know is not always the most optimal for a given problem. At the beginning of a project, that’s fine. But down the line, we’ll run into trouble.

Two types of engineers

The skills of Software Engineers can be put into two categories:

• General skills, like abstraction, logical thinking, architecture/design, etc.
• Specific tools and languages, like Java, Spring, Jira, etc.

The general skills are where the magic happens. It will allow someone to pick up new language and tools, build robust systems, reconsider design decisions, etc. That’s what makes the difference over the longer term. Knowledge of tools and languages is nice, but it makes developers biased: they are likelier to select those tools, even when it’s not the best solution to a given problem.

The problem is that companies hire and hone the second category almost exclusively. When I was hired as a Java Developer, I was tasked with solving Java problems in the application process. Throughout my career, I was paid for writing Java code and became better at Java. Even when Java wasn’t the best solution, I would use Java, because that was the only thing I knew.

How to make super-engineers

To solve this problem, companies should focus on diversifying engineers’ skills. Instead of training engineers to be experts in one tool or language, companies should encourage them to learn multiple languages and tools spanning all paradigms. This approach will give engineers a broader set of skills, enabling them to make unbiased tool selections for new projects and find the information they don’t yet know.

Companies can create “super-engineers” by encouraging engineers to switch teams frequently and allowing them to experiment with new things. They should help engineers to learn new skills and expose them to different parts of the software development lifecycle. By doing so, companies can create more versatile engineers who are better equipped to tackle new challenges and make unbiased tool selections for new projects.

Conclusion

Deep knowledge of specific languages/tools is overrated in the constantly evolving software industry. To succeed, we must cultivate a flexible mindset and focus on developing our general skills while gaining exposure to various programming languages and tools. Companies can help by encouraging engineers to work on different teams and providing opportunities for experimentation and growth. Doing so can make us more versatile and valuable assets to any software project.