6 Mistakes You Should Never Do as a Software Professional
Posted on April 18, 2020
You often hear the phrase software craftsman, or a true professional. While the thousands of things these people do right may differ from title to title and company to company, the things they never get wrong are more or less the same.
Consider the following checklist to make sure you are avoiding these common mistakes:
1. Never Blame Technology For Not Working as You Expect it to Work.
When starting a project or taking on software maintenance tasks it is impossible to foresee every possible problem and corner case. Even after decades of hand-on experience, surprises can arise when you least expect them.
When you are tempted to blame technology for the things that don’t work on your side consider the following:
Is this solution/technology/language successfully used by millions of people for similar purposes?
If yes, then surely it is reasonably well defined and reliable. Thus it is your understanding of it that may need improving.
If not, then maybe the technology isn’t a good enough fit for the problem, in which case, your understanding of the problem’s domain may need improving to switch to the right tools.
In short, an effective professional takes steps to solve the problem instead of pointing fingers at inanimate objects.
2. Never Be Biased in Favor of the Technologies You Already Master
As an effective software engineer you need to follow the trends and understand the limitations of the tools you master. When new and more suitable technologies become available, you should embrace them early on instead of resisting them. In the end, for the client it’s all about achieving the business result effectively, not the technology being used.
Fullstack developers earn significantly more than other software engineering jobs for this reason. They can use the right tool for the job faster and cheaper than having specialized teams for each component.
Therefore, as a good software engineer you will aim to understand the specifics of the problem. Then you will solve it using the technologies that are likely to work, instead of blindly beating it as a nail when all you have is a hammer.
3. Never Resent Stakeholders for Changing the Requirements
From a business perspective, the client might not have a perfect idea of what needs to be done off the bat. In fact this is the norm. So much so that almost all software development companies have shifted to agile methodologies to cater to fast changing requirements.
As a professional software engineer, you need to be prepared for changes in the requirements. It’s easier said than done because people get attached to their solutions and their code. A client coming in late to change something fundamental to the system’s design will cause a lot of existing code to be thrown away and that brilliant architectural solution to be obsolete before actually proving itself useful.
So the right attitude is to expect and embrace change. Don’t get too attached to the current implementation. After all, an acceptable solution to the right problem is infinitely more valuable than a perfect solution to nobody’s problem (at least not the client’s).
4. Never Shy Away From Speaking Up
A professional in any domain must be authoritative and it’s true for software engineers as well.
That of course does not mean you should be disagreeable or obnoxious. Instead, it means that whenever your experience suggests there might be difficulties ahead or wrong decisions being made, it is your responsibility to communicate that to the other stakeholders. Sometimes, your judgment might be over-ruled, but that’s ok.
5. Never Use Your Job Title to Enforce Your Ideas
In essence this can be exemplified by the follosing statement: “I am your supervisor/architect/chief and you will do this so and so”.
You, as a professional should be authoritative, not authoritarian, otherwise your team will view you as a jerk instead of a knowledgeable teammate.
That being said, mentoring less experienced colleagues is part of your duty, even if it’s not written in your contract. It is the best source of authoritativeness.
It’s also worth mentioning that being wrong in an authoritarian manner, will make you eat your hat at the end, metaphorically speaking.
6. Never Attempt to Make Yourself Irreplaceable
A true professional will never hide behind a smokescreen of complexity to make him feel irreplaceable within the company. For example writing very complicated code, defying standards and not providing documentation describing the solution.
Such tricks will be performed by insecure charlatans, but quality engineers take pride in the simplicity and standard-compliant solutions they create.
Can you think of more things a professional software developer should never, ever do? Write down your thoughts in the comments below.