Golden three silver four job-hopping season, everyone wants to have a high salary, good environment, and stable job, now it is April, the last month of job-hopping season, are you ready? Are you good at eating? Are you ready to join a famous company? Most importantly, are you a senior architect? Want to be an architect? Or continue to work overtime every day to write the bridge code ？？？？？？ These are problems that only you can understand and solve for yourselves.

Now is the time for us to seriously consider how to improve our programming skills and how to work hard to become a Java architect. The following points are based on my years of experience. You can use it for reference.

One: Remind yourself of how much you still have to learn

The first step to learning something new is to recognize your limitations. This sounds simple enough, but it takes a long time for programmers with some experience to overcome this assumption. There are a lot of computer science majors who graduate with their heads held high and said, “It’s nothing, I know all about it.”

When I just got to work, I seemed to prove my ability to every colleague.

After all, “I know it all” can prevent us from learning new things, and the output of this powerful certainty is called certainty.

Second: Don’t try to prove yourself right

To be strong, you have to learn and grow from experience. But be careful, experience can prevent us from repeating bad habits, and can also create them. We’ve all had eight years of programmers who have been doing the same thing over and over again. To avoid this problem, look at everything we do and ask ourselves, “How can I do better?”

Novice software developers and many experienced developers like their own code, even if they write their own tests, to prove that their code is flawless. Really good programmers actively look for things that could go wrong, knowing that the end user will find bugs that the programmer missed.

Third: “code effectiveness” is not a place to stop, but a place to start

Yes, your first time will always produce high-quality code that meets the specification. But most developers declare “done” at this point and move on.

Once it’s “done,” stop. The code is like taking a snapshot. It’s not a finished product. Good programmers know that the first iteration is just a rough piece of work. Now, let’s make it a better work of art.

Part of this process is defining what “better” means. Is it worth speeding up? Easier to log? More reusable? More reliable? The answer may vary from application to 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 verify to yourself (or your users) that the solution works. Others may not recognize this as 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 make the code work correctly.

When you look at the best developers at work, the level of work may not be obvious. They are so good at everything they do. But what you don’t see is that celebrities, pianists, technical gurus may have thrown away the first and second versions or more 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 a problem and prevent us from getting stuck.

Fifth: to have a complete and systematic learning system for their own learning

One, source code analysis

Distributed architecture

Third, micro services

Fourth, performance optimization

5. Teamwork

Vi. E-commerce topics

Above course system is I summed up and the comprehensive Java architects will learn course system diagram, the image is divided into six major parts, each project every knowledge point corresponds to the use of technology in our normal work points, if you want to improve their technology, the main technical points of the want to learn more, you can add access, Here I recommend an exchange learning group: 685167672, which will share some senior architects recorded video: Spring, MyBatis, Netty source code analysis, high concurrency, high performance, distributed, microservice architecture principle, JVM performance optimization these become architects necessary knowledge system. I can also get free learning resources, which I benefit a lot from now. (Plus group note: Good news: George recommended)

Number six: Read code. Read lots of code

Maybe you enjoy leading others through code. This is actually the most common and valuable way to improve your programming skills.

While it may seem boring at first, because it’s not literary poetry, you’ll 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 can ask ourselves these questions:

1. How would I write this program? Now that I’ve seen how others solve it, how would you solve it?

2. What did I learn? How do I apply this technique to the code I’ve written in the past? Why didn’t I try to call recursively…

How can I improve this code? If the project is open source, if you are convinced there is a better solution, do it!

4. Code like the original author. Practicing coding by following this rule will help you get into the mind of the original author, which can further improve your code’s empathy.

Note: don’t assume that a good programmer can easily read a lot of source code, just as an admirer can read great literature without improving his prose writing.

Many developers will use open source or other downloaded source code to “find the answer,” possibly cutting and pasting code similar to the question.

If you do this often, you might be a bad programmer! Because you have blindly accepted the wisdom of others without considering and examining it yourself!

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 that this could introduce a whole bunch of bugs.

Number seven: Write code, not just get the job done

One can experience many advantages in programming. First, it provides an opportunity to learn the skills and tools acquired in your current job, which will allow you to adapt to the next tool and market. Whether we contribute to open source projects or work on corporate projects, we can gain technical skills and trust.

Another benefit of developing software is that it “forces” you to think of ways to solve problems. We can’t leave difficult things to others, so we should never ask for help too early.

It’s worth noting that don’t just pick projects that don’t present challenges. We need to fail too! Although you probably don’t want to fail at work or fail at a deadline.

8. Work with other developers as much as possible

It helps to listen to other people. Pair programming can be used, or hackathons or programming user groups such as the Beijing Python user Group. When you have contributed to open source projects, pay attention to feedback from users and other developers. For example, what common problems do you see in criticism?

Find a personal mentor on your team that you can trust to guide you on everything from programming skills to career decisions and planning. Don’t waste too much time taking things for granted.

Ninth: Study technology rather than tools

There are so many different programming languages, tools, and methods, that’s why it’s important to learn as many languages and frameworks as you can to get a different experience. Focus on programming basics, because basics never change; More profound than programming is the focus on architecture.

If you have the right thing to do, check in real time. Dogma can hinder our ability to learn new things, and we need to embrace change.

Conclusion:

We need to move on, but the key principle of self-improvement is knowing when to stop.