Ignite the growth path of the Java Senior Architect!

Java Advanced Step
Links: https://www.nowcoder.com/discuss/72575
Source: Niu Ke Net

Gold three silver four job-hopping season, everyone wants to have a high-paying, good environment, and stable work, now is the April, the job-hopping season remains the last one months, you are ready? Do you have a very skilled meal? Are you ready to go into the famous enterprise? The main thing is, are you a senior architect? Want to be an architect? or continue to work overtime every day the bridge to write code?????? Only you can understand and solve these problems by yourself.

Now is the time for us to seriously consider how to improve our programming ability, how to work hard to become a Java architect, the following points are based on my years of experience summed up. We can learn from the reference.

First: Remind yourself how much you haven't learned
The first step in learning something new is knowing what is lacking. This sounds simple, but it takes a long time for some experienced programmers to overcome this assumption. A lot of computer majors graduated with a haughty head and said, "This is nothing, I know all about" bluff like this,

As soon as I got to work, I seemed to prove my ability to every colleague.

You know, "I know all will" will hinder us from learning new things, and this kind of output strong certainty is called reliable.

Second: Don't try to prove that you're right
To become strong, not just good, you have to learn from experience to grow. But be careful, experience can prevent us from repeating bad habits, but also can make bad habits. We've all met programmers for eight years, but for eight years, he's 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, but also prove that their code is no defect. And really good programmers are proactively looking for things that can go wrong, knowing that end users will find flaws that programmers miss.

Third: "Code validity" is not the place to stop, but the place to start
Yes, for the first time, you can always write high-quality code that satisfies the specification. But most developers declare "done" in this place and continue to the next step.

Once "done" stops, this code is like taking a snapshot, it is not a finished product. Good programmers know that the first iteration is just a rough piece of the object. Now, let's turn it into a better artwork.

Part of this process is the definition of "better" meaning. Is it worth it to speed up? Easier to make a log? MORE reusable? More reliable? The answer may vary for each application, but the process does not apply.

Four: Write three times
A good programmer can write software that can be run. Great programmers write software that works very well. But this rarely happens for the first time. The best software is written three times:

1. First of all, you write software is feasible to yourself (or user) to verify the solution. Other people may not know this is just a proof of concept, but let's do it first.

2. The second time, you get the code to work.

3. The third time, you let the code work correctly.

When you see the best developers working, these levels of work may not be as obvious. Everything they do is so good. But what you don't see is that, including stars, pianists, and tech bulls before they show them the software, they may have thrown the first and second or even more versions. Being good at discarding code and starting over again can be a powerful way to include "better" in your personal workflow.

If there is no better way, "write three times" teaches us many ways to solve problems and prevent us from getting into a dilemma.

Five: To have a complete and systematic learning system for their own learning
First, source code analysis

Second, distributed architecture

Third, micro-services

Four, performance optimization

Five, team collaboration

Six, e-commerce topics

The above curriculum system is I summed up and is a more comprehensive Java architect must learn the course problem map, this figure is divided into six major sections, each topic each knowledge point corresponds to our usual work in the technical points, if you want to upgrade their technology, want to learn the above technical points, you can add group to obtain, Here I recommend an Exchange Learning Group: 725633148.
It will share some of the video footage recorded by a veteran architect: the principles of Spring,mybatis,netty source analysis, high concurrency, performance, distributed, microservices architectures, and JVM performance optimizations are the necessary knowledge systems for architects.

Sixth: Read the code, read a lot of code
Maybe you like to lead people to see the code. In fact, this is the most common and valuable way to improve your programming ability.

You may find it boring at first, because it's not a literary poem, and you'll see how others are solving problems in programming, and they think of it as a lesson and a challenge. In order to make yourself better, we might ask ourselves some of these questions:

1, if I how to write this procedure? Now that I have seen how other people solve it, if it is you how to solve it?

2. What have I learned? How do I apply this technique to the code I wrote in the past? I don't want to call with recursion ...

3. How will I improve this code? If the project participates in open source, if you are sure there is a better solution, do it!

4. Write the code according to the original author's style. Practicing coding in accordance with this rule will help you get into the original author's mind and can further improve the empathy of the code.

Note: Do not think that a good programmer can easily read a large number of source code, as an admirer does not improve his prose in the case of reading a great literary works like not much progress.

Many developers use open source or other downloaded source code to "Find answers", and may also copy and paste code similar to the problem.

If you do this often, you may become a poor programmer! Because you have not gone through your own thinking and inspection, blindly accept the wisdom of others!

It's as easy as our summer picnic, but we don't take the time to understand it, and you never realize that this might introduce a series of bugs.

Seventh: Write code, not just finish work
A person will experience many advantages in programming work. First, it provides an opportunity to learn about the technologies and tools available to you in your current job, which will allow you to adapt to the next tool and market. Whether you are contributing to an open source project or working on a company project, we are able to acquire technical skills and trust.

Another benefit of developing software is that it "forces" you to find ways to solve problems. We cannot leave the difficult things to others, so we must not ask for help too soon.

It is worth mentioning that: Do not select only projects that have no challenges. We also need to fail! Although you may not want to fail at work or to a deadline.

Eighth: Work with other developers as best as possible
This helps to listen to other people's voices. You can use pair programming, or go to a hackathon or programming user group, such as the Beijing Python user group. When you have contributed to an open source project, pay more attention to the feedback from users and other developers. For example, what are some of the common problems you see in your criticisms?

If you can find a trusted personal tutor in the team, from programming skills to career decisions and planning, he can give you more guidance, don't go wrong and waste a lot of time.

Nineth: Learning technology rather than tools
There are a variety of programming languages, tools and methods, which is why you can learn as many languages and frameworks as possible to get different experiences. Focus on the basics of programming, because basic things never change; more than programming is about architecture.

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

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

Ignite the growth path of the Java Senior Architect!