Avoiding problems is faster than solving them
Ben "The Hosk" Hosking
September 7, 2022
5
min read
Most developers are clever at writing code, in many situations the cleverness is a strength and a weakness.
Common sense, street smarts and experience can help developers avoid problems rather than solving them. Knowing when to reach for code and when to reject a requirement.
Knowing when to keep silent, when to fight and when to run and hide gives the wise (senior) developer the advantage over the clever (junior) developer.
Developers spend only 50 percent of their time writing code
In general senior developers are wise and junior developers are clever but haven’t made the mistakes yet to be wise. The difference between junior developers and senior developers is experience, knowledge, and skill.
Experience is the difference. Once developers make a mistake, they (hopefully) avoid it by making the same mistake in the future. This gives them the opportunity to make new mistakes and over time, developers know how to avoid more mistakes.
Mistakes in software development can be hard to see coming because the consequences and pain are far into the future. Simple mistakes give quick feedback, you find it and fix it fast.
Trickier mistakes are something like hard coding a value and there doesn’t seem any downside initially. Later, you need to do a complete release to change the value and you can pay for this decision many times.
A clever person solves a problem. A wise person avoids it — Albert Einstein
All developers want to write code. It’s what they are good at and it’s what they enjoy doing. The skill senior developers learn is when to write code, when to clarify and identifying when code doesn’t need to be written at all.
Junior developers are like a person with a golden hammer where everyone's requirement and problem seems like an opportunity to write code.
Writing code should be the last option because everyone line of code once created becomes a liability to the development team. Once you create code, it must be maintained and adds to the complexity of the code base.
In the short-term code is an excellent solution but in the long term it takes longer, increases complexity and adds to the maintenance overhead.
It’s more effective to write less code, which will reduce the chance of failure. Senior developers know you write code when you must and when you have validated the requirements.
The wise developer reduces the code created by including only the must have requirements and ignoring the nice to have requirements.
Requirements can be achieved by changing business processes instead of writing code. Don’t automate everything, sometimes the manual choice is the best choice.
You gotta know when to hold ’em, know when to fold ’em, know when to walk away, know when to run. Kenny Rogers
The wise (senior) developers know when to write code, when to validate, check and not create code. Junior developers are skilled at writing code and they want to use these skills as often as possible.
This highlights the difference in output but there is a bigger a difference between junior (clever) developer and senior (wise) developers and it’s knowing when to write code.
Junior developers want to create code straight away, often before they understand why the business needs the code and what it needs to do.
Senior developers look for assumptions and validate requirements. It doesn’t matter how well you create code if it’s doing the wrong thing.
You create software faster by writing code with validated requirements. There is a lot overhead with code such as updated dependent code, related code, documentation, tests, builds, documentation. Sometimes developers go faster later by starting slower and creating the right software.
The first principle is that you must not fool yourself and you are the easiest person to fool. Richard P. Feynman
Carpenters measure twice and cut the wood once. Developers are rarely so careful.
The wise (senior) developers understand they are the expert in creating software and users are the experts in their business. Creating software is a collaboration between business and technical experts.
Junior developers forget and listen to some requirements, stop listening and move to creating a technical solution. The senior developers focus on the business goals and processes so they can understand the purpose of the software. It’s only once you understand the purpose of the business, team and individual role that you can create software to help them.
The common mistake happens when junior developers read the requirements enough to understand the happy path and create that. Later, when the unhappy path and exceptions appear, the junior developer has to keep changing the code to fix one bug after another.
What seemed like fast progress at the beginning, slowly bug by bug falls behind. A good senior developer creates the code once, and it glides through the environment.
Senior developers know when to ask questions, when to listen and when to talk.
“Silence is a lesson learned from the many sufferings of life.” — Seneca
Software development needs a team to do it, and that needs everyone to do their job.
Being helpful is a double-edged sword, it can help the other person in the short term but hurt yourself in the long term. The more you do other people's work, the less time you have to do your own.
Wise developers make sure the people who handle areas of the project, do that work.
Developers need to protect their time and push the responsibilities and decisions for the people who handle that.
Junior developers get sucked into doing other people's work, get stuck and run out of time to do their work. If you do this enough and you keep working longer hours and are heading towards burnout.
“Yesterday I was clever, so I wanted to change the world. Today I am wise, so I am changing myself” — Rumi
Things will go wrong, problems will happen, plans will go wrong and designs will change. You cannot fight reality. Adapt to the environment and change with it.
Junior developers fight reality, senior developers align with it.
You cannot stop problems, bugs and issues, but you can prepare for them and make sure they end in disaster. Technical Disasters Should Not Catch Developers Unprepared
The difference between a clever person and a wise person is really not worth worrying about
