开源日报 每天推荐一个 GitHub 优质开源项目和一篇精选英文科技或编程文章原文,坚持阅读《开源日报》,保持每日学习的好习惯。
今日推荐开源项目:《狗言狗语 dogescript》
今日推荐英文原文:《The Differences Between a Junior, Mid-Level, and Senior Developer》
开源日报第506期:《狗言狗语 dogescript》
今日推荐开源项目:《狗言狗语 dogescript》传送门:GitHub链接
推荐理由:一个被编译成 JS 的奇妙编程语言——只不过需要使用者拥有充分的 Doge 适性才能很好阅读与编写 dogescript。如果要想写出自己的编程语言,以一个现有的语言为基础,改变关键字等等是个不错的好主意,毕竟你要做的只是混入自己的思想,而不是真的制造一个新的语言——虽然那样也很不错,但是有的时候好玩比好用更重要不是吗?
今日推荐英文原文:《The Differences Between a Junior, Mid-Level, and Senior Developer》作者:Daan
原文链接:https://medium.com/better-programming/the-differences-between-a-junior-mid-level-and-senior-developer-bb2cb2eb000d
推荐理由:虽然等级只是个参考,保持学习还是不能落下的,不管是写代码还是其他技能

The Differences Between a Junior, Mid-Level, and Senior Developer

Being a junior, mid-level, or senior developer doesn’t solely have to do with the years of programming experience that you have. A junior developer can even be older than a senior developer. It all comes down to skill. This doesn’t mean that a senior developer has to be an expert in everything, but it’s safe to say that senior developers are far more skilled than junior and mid-level developers.

But more than just coding skills differentiate the senior developer from the mid-level and junior developer. So what exactly are the differences?

Knowledge

Obviously the senior developer has far more knowledge than the junior and mid-level developer. Knowing design patterns, architecture, automating testing, performance, security, etc. is a good way for a junior developer to close the knowledge gap with the mid-level and senior developers.

It’s important to know how things in software development should be done. But just knowing all this stuff doesn’t make you a senior developer. Knowledge isn’t the biggest difference between developers—it’s just one of the factors.

Coding

Despite what most people think, coding is not about communication with a computer. Coding is about communicating with humans and instructing computers. Eventually, code gets compiled and translated to zeroes and ones.

Code has to make sense for other developers that have work with it in the future. A new team that has never seen the code before should be able to open the code and start working on new features or bug fixes. This is where the big difference is between junior and senior developers.

I will leave out the mid-level developer in this comparison because the mid-level developer is kind of a gray area when it comes to coding skills. Obviously, it is somewhere in between the junior and senior. It probably leans more towards the senior side. This mainly has to do with experience, since mid-level developers have probably been through the whole development cycle at least once. They have made a lot of the most simple mistakes and learned from them.

How to sniff out the junior developer?

Junior developers are inexperienced. Some just graduated and are starting their first full-time job. The mindset of a junior developer often is to just make the code work. Working software and good software are considered the same.

Programming straightforward code is hard. And it’s something that junior developers don’t do. Junior developers write fancy code. You can recognize the junior developer by quirky one-liners and overly complex abstractions. This is the junior developer’s way of showing off and letting the other developers know how good they can code. And it’s wrong.

Junior developers focus on the computer side of the code at the expense of the human side.

And what about the senior developer?

When looking at the code of a senior developer, you might think: is this all there is? Where’s the rest of the code? A senior developer writes simple, straightforward, and maybe even dumb code. This is one of the biggest qualities that a developer can have when it comes to programming. A senior developer follows the KISS principle: Keep it simple, stupid.

A senior developer thinks about their code in a different way than the junior developer. Code written by a senior developer will be made with maintainability and scalability in mind. This is a totally different mindset than the junior developer has—the senior is thinking about the people who have to work with the code, while the junior is just thinking about making it work for the computer.

More Than Just Coding Skills

Besides coding skills, there are some other factors that can tell you who’s what type of developer.

Junior developers, in general, do the most simple tasks or tasks with low impact. They don’t do any design of architecture. Mid-level developers are not designing solutions either, they just perform tasks. The difference with the junior developer is that they perform those tasks with less supervision as long as they are assigned to relatively routine tasks. Senior developers can develop an application completely on their own.

It doesn’t mean that the senior developer doesn’t have any questions along the way. Every developer has a lot of questions every day and that won’t change. That’s no different for senior developers.

The difference is that senior developers know how to ask the right questions and how these questions get handled. Mid-level developers can ask the right questions when it comes to their relatively routine tasks, but need help on more complex tasks.

The senior developer is never lost and knows how to follow up the question with the right action. This doesn’t mean that a senior developer can’t ask help from other developers. Sometimes the best way is to just ask other developers with experience in that area for help.

The mid-level developer should be able to ask the right questions as well, as long as he doesn’t get assigned highly complicated tasks that require an in-depth level of knowledge.

You shouldn’t expect a junior developer to ask the right questions straight away. Since junior developers are inexperienced, they need guidance from a more experienced developer. The junior developer needs to get provided with the necessary resources or a big push in the right direction.

Getting to the Next Level

We all want to improve ourselves and get better as a developer. But what are the steps that you can take to get to the next level?

Junior to mid-level

Since junior developers are inexperienced, it is important to go through the whole development cycle at least a couple of times. This way you will fall into a lot of traps and learn how to avoid them the next time.

When it comes to coding, you should learn how to write simple code. Think about the next person that is going to work on that piece of code. You should also learn how to debug, since this will give you a better understanding of what’s going on in the process.

Furthermore, you should get familiar with best practices and learn about architecture, performance, security, etc. Close the knowledge gap that is required to get to the mid-level.

Mid-level to senior

Getting from mid-level to senior can be quite hard. Some developers will stay mid-level for the entire length of their career.

Senior developers know what corners can be cut and what corners should never be cut. These are hard-learned lessons by making mistakes in the past.

If you want to get to the senior level, you have to be prepared to take the tasks that no one knows how to fix. You should know more than just how to get the job done.

As a senior developer, your job is also to help the less experienced developers. You are the fallback for other developers when they don’t know how to do something.

And it might not surprise you that senior developers master their tech stack. There is more than just coding skills. Get to know all the tools and applications that are being used within the company that you work for.

Conclusion

The difference between a junior, mid-level, and senior developer isn’t all about years of experience. Sure, it’s safe to say that senior developers are more skilled than junior and mid-level developers. But knowledge is not the most important factor.

Senior developers write easier code and come with a different mindset than junior developers. But it’s about more than just coding skills. Knowing what questions to ask and how to follow up on those questions is essential. And it is something that only the senior developer, with their wealth of experience, knows how to do in all situations.

To grow as a junior developer you should focus on writing simple code and going through multiple development cycles. To get from a mid-level to senior developer you should focus on learning more than just fixing routine tasks. You should be willing to take the hardest tasks and be a master of your tech stack. Another responsibility of a senior developer is to be the fallback for less experienced developers.

I’ll leave you with a quote from Martin Fowler: “Any fool can write code that a computer can understand. Good programmers write code that humans can understand.”
下载开源日报APP:https://openingsource.org/2579/
加入我们:https://openingsource.org/about/join/
关注我们:https://openingsource.org/about/love/