Let’s begin by setting some common ground. What defines a developer as senior? This is my premise:
- A senior developer has confidence.
- A senior developer sees the big picture.
I have been lucky to work in three different countries, with three extremely different work cultures and ethics. But there is a trend I have seen everywhere, a significant misconception of what defines a developer as senior.
Obviously what makes a developer senior is not the number of years in the craft. There is a difference between having five years of experience, and having the same year of experience five times. And it hurts deeply when I see hiring managers that refuse to see it that way.
What makes a developer senior is not the amount of encyclopaedic knowledge a developer might have about a specific language, API or framework either.
The difference between a senior and a junior developer is confidence . A senior developer makes faster and better decisions. But not only because he has more experience, but because a senior developer is capable of seeing the big picture.
Now, it can be argued, with reason, that confidence can be a liability more than an asset. And I tend to agree with that as well.
So allow me to clarify: confidence is not refusing to be open to other people’s opinions, it is not thinking that you already have all the answers, it is not thinking that you are the smartest person in the room.
A confident developer will be open to fresh ideas, when not actively pursuing them, that challenge his current knowledge, and a confident developer will always approach a technical discussion trying to find better solutions than his own to solve the problem at hand.
Confidence is also what makes the senior developer want to share his knowledge and experience with others.
A senior develop must be humble and respectful, honest and transparent, and willing to challenge others and himself.
A senior developer would assume that his knowledge of certain areas of his daily practice is outdated. And a senior developer can be sure that there will always be another developer in the team that knows more than him about one or more of those areas.
And you know what? That is great. Remember, this software thingy is not a pissing contest, this is about building great products, with code of the highest possible quality. A senior developer, a team/technical lead in particular, should be able to recognise when others know more than him, and encourage them to use that knowledge for the greater good (the final product).
We all learn by making mistakes. A senior developer has, most likely, reached that point in his career due to all the mistakes he/she has made in the past.
Also, due to the aforementioned confidence, a senior developer won’t be scared of making more mistakes, because the senior developer knows that what matters is not writing perfect code, but recovering from the inevitable mistakes fast and with elegance.
By being honest and transparent, but alway thinking out loud in the open, by discussing his approach with the rest of the team, by showing his thought process in the most possible honest and open way, the senior developer will help others understand that what matters is having an actual thought process, and that what matters is taking time to consider the trade-offs before starting to write code like crazy.
I believe there is nothing more valuable for a junior developer that seeing someone, with way more experience, struggle with the same issues that he struggles with.
A senior developer always attacks problems with an analytic approach, and a senior developer always has in mind those things that junior developers are usually not aware of yet: business requirements, trade-offs, and the big picture. And makes the importance of those constraints crystal clear.
Because a senior developer always sees the big picture. The senior developer always has a long term plan. The senior developer is relentlessly moving towards the goal posts, no matter what it takes.
Constructing that big picture, that master plan, and setting the placement of the goal posts openly, in front of everyone, rationalising and explaining every single decision is the best that the senior developer can do to mentor others.
Because mentoring is not lecturing, mentoring is not only suggesting using an obscure class in the system frameworks, mentoring is showing, with your own actions, day after day, that a master plan, and a thought process to fulfil it, are necessary.
A senior developer cares deeply about what he does, and cares deeply about the end result of his practice. That means a senior developer cares about excellence.
A senior developer has to be a living and breathing example of how excellence does not happen by accident. Because excellence requires work, dedication, commitment, and the will and drive to actually achieve it.
A senior developer will always challenge himself. A senior developer is never satisfied with the current state of the code, and is always willing to improve it in some way. And he is open, even vocal, about it.
A senior developer will also challenge junior developers by asking them challenging questions. There is nothing worse than telling a junior developer, straight away, that something he implemented is not good enough, or plain wrong.
However, there is nothing better than reading carefully a junior developer’s code and ask the kind of questions that will make that developer understand that the code can still be improved.
A senior developer will not provide direct solutions, but gently steer the junior developer towards those spots in the implementation that do not align with the big picture, the masterplan. Because, remember, the senior developer always has the masterplan in mind.
A senior developer will always end a code review with some open ended question or suggestion to the junior developer. A simple “do you think the functionality of this particular part of the system would be easy to extend?” makes wonders. A “do you think there is a way to make this code simpler”, accompanied by a “by the way, have you heard about the builder pattern?” will provide a great learning opportunity to another developer.
And a senior developer will carefully consider when to let others make mistakes. Because mistakes and the lessons learnt from them, are what made the senior developer, well, senior.