What is the Difference Between a Junior and Senior Developer?
One of the most frequent questions from newly minted developers is “How do I become a senior developer?” Not surprisingly, people are interested in how to advance their career. In response, there is a lot written on this topic. Entering “difference between a ju” autocompletes on Google as “difference between a junior and senior developer” for me.
There are many differences, but one stands out above them all. Let’s review the differences that a quick review of online literature provides:
A junior knows the basic syntax of a language and can reasonably code a set of instructions. A senior knows the ins and outs of a language and their code expresses things clearly and succinctly.
A junior can code a solution that is provided to them. A senior can come up with the solution.
A junior can code a class or module in response to a set of requirements. A senior thinks about structure, dependencies, fragility, and resilience. A senior has the SOLID principles down cold.
A junior can write code. A senior can use TDD/BDD/DDD for the proper circumstances.
A junior can write code. A senior can write code that someone else can easily understand. As Kent Beck said, “Any fool can write code that a computer can understand. Good programmers write code that humans can understand.”
A junior can create a solution to simple problems. A senior can break down complex problems into a series of easier to solve simple problems.
A junior can write a function. A senior can utilize functional programming and OOP.
A junior can write procedural code. A senior can write event driven code. A senior can deal with promises, concurrency, and multiple threads.
A junior will write code with if-then-else and switch. A senior thinks about whether polymorphism would work better.
A junior will write a getter with a side effect. A senior knows why that is a bad idea.
A junior knows all of the textbook algorithms. A senior can apply those algorithms and knows when to use a standard library vs creating their own.
A junior understands a module or a specific set of functionalities. A senior understands the entire ecosystem.
And of course, there is the area of domain knowledge that I wrote about in The One Skull Rule.
I’m sure there are other differences that I’ve overlooked. If you can come up with any, let me know in the comments. But there is one difference that hardly anyone talks about.
Software Development is a Team Game
There will be very few times in your career where you will be a team of one. If you are a junior developer, this is a situation you should actively try to avoid. It’s senior developers on your team that can be the best learning resource.
Once you add a person to that one-person team you’ve gone from 0 to 1 in interactions. It’s no longer just a conversation in your head, you now have to deal with another human being. It is hugely more complex. The formula for the number of connections in an N node network is:
N*(N-1).
We use this formula because every connection on a team is bi-directional. Think about this for different team sizes:
3 -> 6
4 -> 12
5 -> 20
6 -> 30
The difference in communication complexity in going from a 3-person to a 6-person team is 5x! And that’s a fairly small team. The numbers escalate rapidly.
It’s even worse than this, because the dynamics of 2 conversations of 2 people each are different than if we put the same 3 people into one conversation. There are things that Bill may say to Sally in a 1:1 that would not come up in a joint conversation with Jill, Bill, and Sally. Yes, the complexity can get mind boggling if you think about it enough.
Now consider that a lot of juniors just get thrown onto a 15-person team (210 connections!), and the only exposure they had to group dynamics was a couple of group projects in school.
That’s why developing soft skills is so important. Working as part of an effective team is really the second most difficult part of the job (next to understanding what users are really asking for).
My advice for developers that want to move from junior to senior:
Do good work. Get really good at each of the items discussed above. But most importantly, be a fantastic team player.
If you found this story interesting, please consider a clap and a follow to keep me writing them. It’d be even better if you shared it on social media.
