A senior programmer is an expert who has made all the possible mistakes in his field.
If you classify software developers according to their work experience, it may look like this:
- Elementary: 2-3 years of work experience
- Advanced: more than 10 years of work experience
- Intermediate: between beginner and advanced
There is a problem with this classification by working years. That is: it says nothing about the quality of software development. How much experience and skills did you gain during your working years? This is why the job search and interview facing developers are so complicated. Measuring skills is very difficult, so we conducted a lot of difficult tests for developers during interviews. But these tests are only a rough idea at best, and cannot measure how much experience or professional skills they have to complete the job.
This leads to the next question.
Once you are no longer a junior programmer, when will you become a senior programmer?
Will years of work experience automatically make you a senior programmer? not necessarily.
Take myself as an example. When I was a young junior programmer, I thought I knew everything. I am arrogant and lonely. I consider myself the "God of Code". I don't like working with others. I think writing good code is the most important thing for programmers.
am I wrong? That's right. Coding is really important-programmers have to write working code. But writing code is not the only important thing for him.
I realized this the hard way while working for my first client. I talked to the client for 15 minutes, gathered the key points, and assumed that I knew exactly what the client wanted. I started to write code like a madman, enjoying the process of writing pure code. I delivered the application within 3 days, but the customer did not approve it. Because he said: This is not what he expected.
Needless to say, my self-esteem is bound to be hurt, and I blame it on the client not providing enough information. At that time, I was not mature enough to speak and do things. It now appears that the customer is always right. If I devote more time to analyzing customer needs, the situation may be quite different. But it took me a long time to understand this.
A programmer does not become a qualified programmer because he can write code, but because he analyzes before starting to do anything, and then he comes to work. This is a real programmer. The analysis must be done at multiple levels:
- Self-analysis for better execution
- Customer demand analysis for better delivery
- Analysis of the entire project to help everyone better complete their work
If you want to become a senior developer from junior level, you need to develop these analytical skills to become a truly outstanding senior developer. He is praised for his professional knowledge, not his years of experience.
A good senior developer is like an adult who can take care of himself. His life is no longer erratic, unconscious and experimental. He learned from his mistakes and laid a solid professional foundation for his life. He can look back on the past and be proud of it. He may still be "young", but what he has is a lot of practical and efficient skills, which are far more valuable than his working years.
Below, some methods from beginner programmers to advanced programmers will be given.
Overcoming the Dunning-Kruger effect
The Dunning-Kruger effect is a kind of cognitive bias. People always overestimate themselves. They see themselves as smarter and more capable than they are in reality. In essence, people with low ability will not realize that they are really incompetent, on the contrary they will overestimate themselves.
As a junior programmer, this is definitely a disaster. You might think that you are a superstar programmer and know everything. But the fact is, you know very little, and there is still a long way to go from being excellent. You should be careful not to fall into such a trap.
The difference between junior programmers and senior programmers is that junior programmers think they know everything, while senior programmers know that they still have a lot to learn. Junior programmers often overestimate their own knowledge and abilities, and fail to recognize the skills and abilities of others. This is why they always think that they are more capable and know more than others.
As David Dunning clearly pointed out: in many cases, incompetence does not make people disoriented, confused or cautious. On the contrary, incompetent people are usually blindly confident.
Dunning and Kruger believe that as work experience increases, overconfidence usually decreases and becomes more realistic. When programmers begin to delve into their field, they begin to realize that they lack the corresponding knowledge and ability. When they acquire this knowledge, their professional abilities will increase and their confidence level will increase again.
They proposed the following methods to overcome overconfidence.
- Persist in learning and practice. Once you have a better understanding of a topic, you are more likely to realize how much more needs to be learned. This may avoid assuming yourself as an expert.
- Ask others how you are doing. Asking others for constructive opinions can give you an idea of how others perceive your abilities.
- Question what you know. Constantly challenge your beliefs and expectations. Look for information that challenges your thinking. The more questions you ask, the more you learn.
Remember, erudition is a wonderful feeling. But you need to pay attention to raising your standards. For this, you need to go deeper to understand a particular topic better. This will make you realize how much more needs to be learned.
Know when not to do
Mark Manson talked about the importance of maintaining an identity in his book "The Subtle Art of Don't Care". The fewer definitions of this identity, the better. This is because when we relate to our identity, when we decide on certain behaviors or events, it represents our value as a person.
Simply put, when we decide to do something, it is often based on how it satisfies our ego or childlike obsessions and stimulation, rather than the real need to do it. Manson tells us that when we put our "self" outside the decision, the decision we make is the best decision, because it's probably not about "you". Just ask yourself: "Is this all right?" Okay? Do it then.
This also applies to programmers. In fact, most programmers are born magpies, they always collect shiny things, store them, and then try to glue them to whitewash their nests. If you are not aware of this phenomenon, the typical feature of "Sparkling Toy Syndrome" is to want to have the latest toys, usually without considering the needs of practicality or functionality. Or, before the attention has been shifted to other things, always eagerly want to have it.
If your goal is to grow as a senior programmer, you need to avoid this disease at all costs. The best senior programmers know exactly when and what not to do. They know that it is not always a good decision to rewrite a class library from scratch to improve readability, or switch from an old framework to the latest one. The purpose of these codes should be clear enough that people can understand it in minutes or even seconds. It should be easy for everyone to browse these codes, even if they do not have complex skills.
The key is not to avoid risks, but to choose the right battlefield carefully.
With crazy curiosity
Have you ever wondered what the word "app" means?
Why do we call these small icons smart phone apps? This is because they apply a given workflow or algorithm to our problems and help us solve our needs.
In other words, if you are doing something, you will definitely make mistakes. Reflecting on your work and continuously improving it will bring innovation, and the root of innovation is curiosity about how things work. Remember, this is an important obstacle in the self-improvement process.
Mistakes -> Insights -> …Curiosity -> Innovation -> Mistakes Repeated...
If you want to move on and become a good senior programmer, you need to be crazy curious about everything you do. Curiosity is a tool that becomes better the more you use it. This is exactly what people expect of good senior programmers. Excellent senior developers guide their curiosity in a structured way so that they can use the confidence they have accumulated in emergency situations. If you are interested in Python, you can add the teacher's WeChat: abb436574, get a set of learning materials and video courses for free~
There are some ways to satisfy your curiosity and shape your brand.
- Never stop learning. Choose a course, a book, an online education degree, and use it to enrich your existing ideas and get new ideas.
- Pay attention to basic principles. Make sure you understand how they work, so you can use it as the basis for your work.
- Don't say what you think. Show your project, the idea is overrated anyway. If your ideas are applied and spread, you can build your own brand.
- Consider carefully between new ideas and existing ideas. Don't blindly accept what you "should" know. Challenge the status quo.
- Don't just make it work. Make it expandable, reusable, and pluggable. This is how you build your expertise.
It all starts with curiosity. If you are not curious, you might as well give up. As Albert Einstein said:
"I don't have any special talents. I'm just very curious."