今日推薦開源項目：《狗言狗語 dogescript》
今日推薦英文原文：《The Differences Between a Junior, Mid-Level, and Senior Developer》
今日推薦開源項目：《狗言狗語 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/
我！想成為那個senior developer！
昨天開源項目是貓言貓語，今天是狗言狗語，有意思。