决定你是初级还是高级程序员的,可能不只是技术(也不只是发际线)

734

原文标题:The Differences Between a Junior, Mid-Level, and Senior Developer

阅读时长:约7-10分钟

语言难度:2 (1为最容易,5为最难)

原文地址:medium.com/better-prog…


这是一篇关于如何“鉴定”程序员级别的有意思的文章,除了给大家一个自评职称的借鉴之外,也有许多如何让自己迈向下一个台阶的启发。对我来说,最重要的收获有两点

  1. 程序员的能力有一大半是在代码之外

  2. 代码之内的能力,更多的不是在于功能是否完成,而在于这个代码是否能很容易地和“人”而不是“机器”交流

希望大家看完也能有自己的收获。因为文章所用英语比较简单,推荐大家第一次看的时候可以忽略翻译,连贯地阅读整篇文章。

Enjoy!


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?

但是区分开高级开发者和初级及中级开发者的远不止编码技能。那这些区别到底是什么?

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.

知道软件开发中的方方面面很重要。但是这不足以让你成为高级程序员。知识并不是程序员之间最大的区别,而只是其中之一。

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.

和大多数人想的不一样,编程并不是和计算机沟通。编程其实是和人类沟通,然后给计算机指令。最终,代码被编译,然后翻译成0和1.

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.

代码必须让将来需要和它打交道的其他开发者能够理解。一个从没看过代码的团队应该能够打开代码并马上开始为它开发新功能或者修复bug。这是初级程序员和高级程序员之间的一个大区别。

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.

写一段简单直截的代码是有难度的。这正是初级程序员不常做的。初级程序员会写花哨的代码。你可以从一些诡异的单行代码和过分复杂的抽象里面,识别出初级程序员。这是初级程序员炫技和让其他程序员知道他有多NB的方式。但这是错误的。

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.

当你读高级程序员的代码时,你可能会想:就这些代码了吗??剩下的代码在哪儿??高级程序员写简单的,直截了当的代码,甚至可能是看起来愚蠢的代码。这是一个开发者在编程方面最重要的品质之一。高级程序员会遵循KISS原则: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.

高级程序员考虑他们的代码的方式和初级程序员不同。他们在写代码的时候就考虑了维护性和扩展性。这是和初级程序员完全不同的,因为他们考虑了将来需要和这个代码打交道的人,而初级程序员只考虑怎么让程序为计算机工作。

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.

你不能期望一个初级程序员一开始就能问出正确的问题。因为他们不够有经验,他们需要更有经验的人的指导。他们得有人给他们提供足够的资源,以及往正确的方向推上一把。

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.

高级开发者要精通他们的技术栈,这应该不会让你觉得奇怪。除了编程技巧之外,还得熟悉公司内在用的各种工具或者软件。

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.”

最后我给大家一句Martin Fowler的名言,“一个傻瓜也能写出计算机可以理解的代码。好的程序员写出人类能理解的代码”