In the peak season of job-hopping, everyone wants to have a high salary, a good environment, and a stable job. It is now April, and there is only one month left in the peak season for job-hopping. Are you all ready? Are you skilled at eating? Are you ready to enter the famous enterprise? Most importantly, are you a senior architect? Want to be an architect? Or continue to work overtime every day to write code? ? ? ? ? ? Only you can understand these problems and solve them yourself.
Now is the time when we need to seriously consider how to improve our programming ability and how to work hard to become a Java architect. The following points are summed up based on my years of experience. Everyone can learn from it.
#1: Remind yourself how much you still haven’t learned
The first step in learning something new is to recognize for yourself what you lack. It sounds simple, but it takes a long time for programmers with some experience to overcome this assumption. There are a lot of computer science students graduating with their heads held high and arrogantly saying, "It's nothing, I know it all."
Just arrived at work, seems to be proving his ability to every colleague.
You must know that "I know everything will" will hinder us from learning new things. This kind of output is a strong certainty called reliability.
Second: Don't try to prove yourself right
To be strong, not just good, you have to learn and grow from experience. But be careful, experience can prevent us from repeating bad habits, and can also create bad habits. We've all met a programmer for eight years, but he's been doing the same thing over and over again for eight years. To avoid this problem, look at everything we do and ask ourselves, "How can I do better?"
Novice software developers and many experienced developers love their code, and even writing their own tests proves that their code is flawless. Whereas really good programmers actively look for things that might go wrong, they know that end users will find bugs that programmers miss.
Third: "Code Effectiveness" is not the place to stop, it's the place to start
That's right, your first time will always be able to write high-quality code that meets the specification. But most developers declare "done" here and move on to the next step.
Stop once it's "finished", the code is like taking a snapshot, it's not a finished product yet. Good programmers know that the first iteration is just a rough thing. Now, let's make it a better art.
Part of this process is defining what it means to be "better." Is there value in speeding up? Easier to do logging? more reusable? more reliable? The answer may vary for each application, but the process does not apply.
Fourth: write three times
Good programmers can write software that works. Great programmers write software that works really well. But these rarely happen the first time. The best software is to write three times:
1. First, you write software to prove to yourself (or users) that the solution works. Others may not realize that this is just a proof of concept, but let's do this first.
2. The second time, you make the code work.
3. The third time, you get the code to work correctly.
When you look at the best developer jobs, these levels of work may not be so obvious. Everything they do is so good. But what you don't see is that stars, pianists, technologists may have thrown away the first and second or even more versions before showing them the software. Being good at throwing away code and starting over can be a powerful way to incorporate "better" into your personal workflow.
If there is no better way, "Write Three Times" teaches us that there are multiple ways to solve problems and prevent us from getting stuck.
Fifth: Have a complete and systematic learning system for yourself to learn
1. Source code analysis
2. Distributed Architecture
3. Microservices
Fourth, performance optimization
5. Teamwork
6. Special topics on e-commerce
The above course system is summed up by me and is a relatively comprehensive course subject map that Java architects must learn. This map is divided into six major sections, and each knowledge point of each topic corresponds to the technology we usually use in our work. The main point, if you want to improve your technology and want to learn the above technical points, you can join the group to get it. Here I recommend an exchange and learning group: 685167672, which will share some videos recorded by senior architects: there is Spring, MyBatis, Netty source code analysis, principles of high concurrency, high performance, distributed, microservice architecture, and JVM performance optimization have become a must-have knowledge system for architects. You can also receive free learning resources, which are currently benefiting a lot. (Add group notes good news: George recommends)
Sixth: read code, read a lot of code
Maybe you like to lead others to look at code. In fact, this is the most common and most valuable way to improve your programming skills.
Maybe it's a little boring at first, because it's not literary poetry, but gradually you see how other people solve problems in programming, and they see it as a lesson and a challenge. In order to make ourselves better, we might as well ask ourselves some questions such as:
1. If so, how do I write this program? Now that I have seen how others have solved it, how should you solve it?
2. What have I learned? How can I apply this technique to code I've written in the past? Why didn't I want to use recursive calls...
3. How would I improve this code? If the project is involved in open source, if you're sure there's a better solution, do it!
4. Write code in the style of the original author. Practicing coding according to this rule will help you get into the mind of the original author and can further improve the empathy of your code.
Note: Don't assume that a very good programmer can easily read a lot of source code, just as an admirer can't make much progress in reading great literature without improving his prose.
Many developers will use open source or other downloaded source code to "find the answer", possibly copy-pasting code similar to the question.
If you do this a lot, you're probably going to be a bad programmer! Because you blindly accept the wisdom of others without your own thinking and inspection!
It's as easy as our outdoor picnic in the summer, but we didn't take the time to understand it, and you'd never realize it could introduce a bunch of bugs.
#7: Write code, not just get work done
There are many advantages one can experience in a programming job. First, it provides an opportunity to learn about techniques and tools acquired in your current job that will allow you to adapt to the next tool and market. Whether contributing to an open source project or working on a corporate project, we can acquire technical skills and trust.
Another benefit of developing software is that it "forces" you to find ways to solve problems. We cannot leave difficult things to others, so we must never seek help prematurely.
It's worth mentioning: don't just pick projects that don't have much of a challenge. We need to fail too! Although you probably don't want to fail at work or fail at a deadline.
Eighth: Collaborate as much as possible with other developers
This helps to listen to other people's voices. You can use pair programming, or go to hackathons or programming user groups such as the Beijing Python User Group. When you have contributed to open source projects, please pay more attention to feedback from users and other developers. For example, do you see any common problems in the criticism?
If you can find a trusted personal mentor on the team, he can give you more guidance from programming skills to career decision-making and planning, don't take it lightly and waste a lot of time.
Ninth: Learn technology, not tools
There are so many programming languages, tools and methods, which is why you can learn as many languages and frameworks as possible to get a different experience. Focus on programming fundamentals because the basics never change; deeper than programming is to focus on architecture.
If you have a right thing to do, it needs to be checked in real time. Dogma can hinder our ability to learn new things, and we need to embrace change.
Summarize:
We need to keep going, but the key principle of self-improvement is knowing when to stop.