The concept of mentorship of a senior developer to a junior developer is often looked at as beneficial to the junior developer. However, pairing a senior developer with a junior developer is not only beneficial for the junior. It is actually quite beneficial for the company who intentionally pairs both engineers together.
Senior developers who have worked on multiple projects have a much deeper understanding of how to develop maintainable systems and code. They have a good sense of which projects are worth doing and can help manage stakeholder expectations. All of this boils down to them being able to see around corners and keep junior engineers from building software that is overly complicated and doing work that might have little to no impact for the company.
This all impacts the company's bottom line. Yet, it doesn't seem like every company does this. I recall my first job, where I was the only technical person on my team and had to support five analysts. Honestly, I doubt anything I built is still maintained today because I often built only to meet some functional requirement, and there was no one there who could provide input into design, maintainability, etc. (Luckily this changed at my next job.)
That said, I want to lay out three reasons it's very important to pair junior developers with senior developers. Again, this isn't just so the junior developers can grow; this is to ensure the software being built is sustainable and has the right features that will benefit the company.
To Know What Is Maintainable
https://www.monkeyuser.com/2018/workaround/
Have you ever built an automated process, website, or framework on your computer? Now, have you ever taken that same new system and implemented it into a larger system where there might be thousands, maybe millions of users. Then ... have you had to maintain it for multiple years?
If you have, you know it is several magnitudes more difficult to develop a system that is sustainable. You have to constantly make design decisions that have pros and cons. Sometimes, due to time or technical constraints, you might need to circumvent certain limitations. This can lead to technical shortcuts and some tech debt being taken on. All those small shortcuts you might take and bad design decisions you don't think through can quickly come back to bite you (like it did at Chernobyl).
Even doing something small like changing an integer column to a float could be a weeklong endeavor between finding all the fields references, updating them, and then running tests.
Creating maintainable and sustainable code all starts with good design. However, many junior developers will either start coding or forget to think of important aspects about a design. This is where senior developers can step in and help guide junior developers in design reviews and pair programming.
Having a senior developer provides insights into the possible pitfalls a junior developer's design might have. They won't see every problem, but they can help think through edge cases that the junior missed. In turn, this teaches the junior developer what they need to think through in the future.
To Help Manage Expectations
Many of us who built our first programs in college often built websites, applications, and side projects in a few weeks. However, once we started working in the industry, it felt like what used to take a few days or weeks suddenly started taking months. Suddenly, the concept of project management is very important.
Simple requests for changes or updates required a lot more than just updating code. An entire analysis often needs to be done to see how a change might impact modules downstream. Suddenly, a code change that would have been quick and simple can take a much longer time because it could have multiple downstream dependencies.
Being able to manage these expectations helps ensure that the development teams aren't overpromising timelines. I recall promising timelines that took weeks for projects that would have taken several months.
The problem is you run into issues like people going on vacation, operational tasks that get in the way, meetings, and other normal daily functions that take tasks that might seem quick and extend them greatly over time.
Senior developers are more accustomed to these distractions and can come up with more realistic expectations. Don't get us wrong, management will probably still cut the timeline in half. But at least you tried!
To Know What A Bad Project Is
https://marketoonist.com/2018/05/being-agile.html
Knowing what might be a bad project is a difficult skill to acquire. This is why a junior developer won't know when they're asked to work on something that might have little to no impact for the company or prove too large to take on by themselves.
Bad projects aren't often obvious. They can start as one-off initiatives that a new director feels will improve the company even though it doesn't line up with current goals. It could be a hype project where some salesperson went to a conference, heard about some new AI feature, and is now demanding the engineering team add it to their products.
Wherever the source, these projects lead to unnecessary stress and often features that don't provide value to the end user. Having a senior developer who can spot some of the characteristics of bad projects and show them why the project isn't an effective use of time will help improve the company's bottom line.
Conclusion
Overall, there are a lot of other great reasons to pair junior and senior developers together. But, as someone who has been a junior developer and was provided no senior developer to act as a guide, it was not only detrimental to my growth but also to the impact I had on the company. It's really hard to tell when you're making a bad decision because you have never been there before. There are so many assumptions and decisions that engineers need to work through, and without the experience to guide you, you can quickly find yourself in a bad situation. Again, this doesn't just cost the junior developer; it costs the company.
Want to read more about programming, data science and machine learning:
Analyzing Healthcare Data With BigQuery
The Software Engineering Study Guide
Statistics Review For Data Scientists
Learning Data Science: Our Top 25 Data Science Courses
The Best And Only Python Tutorial You Will Ever Need To Watch
4 Must Have Skills For Data Scientists
What Is A Data Scientist
Top comments (17)
Personally, I do think the senior developer gains better communication skills as well as possible leadership skills.
and over time, hopefully another senior
And not just that, you gain better understanding of a lot of concepts.
There are things you don't realise until you mentor or help with mentoring someone, but there are a lot of concepts which you think you completely understand and yet you can't explain properly.
Mentoring improves both your communication skills, as SeattleDataGuy pointed out, + your understanding of those concepts. And not only that but forces you to continously challenge the practices you KNOW for a fact that are beneficial vs. the ones you just follow for a mere sense of inertia.
I wish I had a senior developer to work with on some projects in my current position! Currently, we all work on our own projects and at times, as a junior dev, it's been a daunting experience. It's hard to ask for help when the senior devs don't have visibility on your code work, your daily pushes to the main repo and so on, so they aren't able to jump in and offer input.
Now I look at my old code and cringe, and try to refactor when the time allows.
Sounds about right! It is usually nice to at least get a Sr. developer to look at it before you push it to the main repo..but sometimes that just isn't the case.
Sidenote, if you're old code doesn't make you cringe. You're not learning :).
That's what I tell myself to get through bad days! :)
I think it also benefits the Senior Engineer. It's not like they've reached the end game in their career and they will want to progress at some point.
Mentoring and pairing junior members of the team will help them push their career forward as communicating clearly and effectively is important the more senior you become as your stakeholders aren't always going to be technical.
I agree!
Yeah have a Senior developer is an advantage for you as a Junior developer. Because the senior developer have the experience have worked on many projects pass through many Errors, So its really a big advantage
It is interesting that you mention learning things take longer and knowing when you can't do it alone.
The fact that you are not alone is one of the main reasons for all of that. Small projects grow because the need to be more accessible, not just the UI but how to update and change the UI.
Don't get me wrong, doing it alone does not mean smooth sailing, but it does aliminate initial challenges.
Great article! In many ways senior developers have probably gone all through the pitfalls of wasted time and money that they could keep new juniors from doing. It’s hard to quantify, but it’s pretty obvious how it could save time and money down the road, so it’s hard to see why more companies wouldn’t want to make sure their juniors have guidance!
There's also the aspect that teaching makes you to organize your knowledge, and fill in any blanks in your own understanding.
Teaching a junior will make the junior and the senior better.
Also true!
Good points. I wish I had a senior dev to help me out when I started. They just threw me into the fire.
I think it is more common than most of us hope!
thanks for sharing such a beautiful information
Anyone able to give input on how to get a senior dev, if you a junior In a position without much guidance