THIS Is Why You’re A Junior Developer
Even Though Your Title Says Senior
--
The speed of promotion in software engineering roles is astounding. That isn’t an issue in itself, but sometimes the wrong people are being promoted — those that are fast at completing simplistic tasks alone and not those who focus on collaboration and quality solutions.
As a result it is possible to find senior developers who seem to behave as one might expect a junior developer to operate. How might we find these Peter Principle beneficiaries within our own organizations? Take a look at the following tell-tale signs:
Your Arrogance Clouds Judgement
It’s fairly normal for software engineers to be rather judgemental. It even creeps into areas where they do not have professional knowledge, this is true. However when a software engineer gets the senior badge applied to their job title they should listen more than speak. Find the solutions that a more junior programmer already has rather than insisting on their own solution.
That is: have an open mind about the work that is going on, and your place within it.
To think you’re always right? A junior trait.
Code Reviews Are Superficial
Code reviews can actually be used for different things within various organizations. We might expect that most minor mistakes are picked up by a linter, and quickly move on.
However, we might see comments about increasingly trivial matters. Those that the linter doesn’t have a rule for, while also not impacting the maintainability, performance or functionality of code.
Trivial Code Review? A junior trait.
Lacking Depth of Knowledge
You might not have a degree. Great! We don’t need everyone to have qualifications for work that doesn’t require it and you can make up the gap in knowledge through experience (and that might actually be of more value than a qualification). However, senior developers who copy-paste solutions from their previous employment? That isn’t good, unless you’ve considered the wider context around the solution.
What do you mean, it worked there so you think it is “the way to go” in this business too?
Shallow knowledge? A junior trait.
Lack Decisions Based on Data
When making changes to a process or a codebase, it makes sense to take the pulse of a situation. Once you’ve taken a baseline it’s possible to see if the changes you make are for good or for ill. If not, how do you know?
Something as simple as taking the number of crashes on your application can be fraught with difficulty. You might see people excluding crashes for one reason or another from their new solution, and not doing the same for the baseline. In other words, cheating. When a senior developer cheats, it’s probably worse than being a junior come to think of it.
Emotional decisions? A junior trait.
Complicated Solutions
When a competent developer looks at an issue they come up with a solution in their head. A lesser approach is to try a number of solutions until they work, hacking around on the machine.
This can lead to a convoluted and difficult to understand solution. This doesn’t mark you out as a junior developer though, everyone does it sometimes and this also depends on the complexity of the issue in hand.
What marks out higher quality code is the last step of development (after testing, which isn’t even included in this list BTW), making the code easy to read and maintainable.
Anyone can write code that a machine can understand, the skill is in writing code that humans can understand (paraphrasing Fowler).
Complex solutions? A junior trait.
The New Hotness
When a new technology reaches the market, it’s great to find out about it. Creating toy solutions at home to become familiar with that technology is indeed great.
Bringing a half-baked solution to work? Makes the code difficult to maintain and understand. It might be a great solution to a problem. But is it the solution that works for the whole team? Does it require documentation that inevitably is not read by half the team? So many questions, but you’ve already implemented and pushed your code now. Frustrated that your colleagues aren’t bright enough to understand your solution?
Failure to consider colleagues? A junior trait.
Assumptions
When you make assumptions, you leave yourself open to creating a solution which might be sub-optimal. It’s a natural human trait to try to create a story around incomplete information, and to come to quick solutions. When looking at complex computer code however, this can be fatal. How many code reviews make the fundamental attribution error and fail to consider the situation?
This is the same quick-thinking that has led to some assuming this authors gender, coding skill, parentage and more. Jumping to solutions in code can have more serious consequences, and sometimes these consequences can damage whole teams.
Quick solutions over considered answers? A junior trait.
About The Author
Professional Software Developer “The Secret Developer” can be found on Twitter @TheSDeveloper and regularly publishes articles through Medium.com
