今日推荐英文原文：《Why Every Junior Developer Needs A Senior Developer》
推荐理由：推荐闲得无聊时尝试的项目，允许 Python 在命令行界面输出表情。即使是用于和其他项目一起食用，多加这么一个依赖项换一个表情包功能似乎有些华而不实……不过在娱乐的时候就不要想着这些了，只要不是用在比较正式的地方，娱乐性强的项目就是应该怎么开心怎么有新意怎么玩的。
今日推荐英文原文：《Why Every Junior Developer Needs A Senior Developer》作者：SeattleDataGuy
Why Every Junior Developer Needs A Senior Developer
Avoiding unmaintainable code, bad projects, and bad expectationsThe 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
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 ExpectationsMany 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
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.
ConclusionOverall, 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.