Thirty-five years of experience sharing: eight methods for advanced programmers

   These eight methods are very reliable and will improve your coding skills, so you should save them. It's time to improve your programming skills, be serious + serious, go! If your goal is simply to improve yourself, it's easy to achieve, but if your goal is to be a great programmer, it's not easy. A lot of people are willing to say, I want to be better, but what better is is vague and people don't know how to do it. Here I share eight methods to help you smoothly improve your programming skills. These little wisdoms come from 30 years of deep cultivation in the field, many of which are familiar to you, and you may have recognized them long ago.


  1. Remember, you are not omniscient
   . There is a huge roadblock in your way, and its name is "I know everything". College students who have graduated from computer science and experienced programmers are prone to such mistakes. Actually, it's a trap, and it's hard to climb up if you fall in it. However, you still have to get over it. Only people are willing to think that they know everything, but the characteristic of human beings is that they can recognize their own shortcomings and then learn new knowledge. So, you have to understand that the first step to becoming a better programmer is to realize that you always have something new to learn and maintain a humble attitude. This is the consistent way to learn.


  2. Stop trying to prove how right you are
   Learning from experience makes you great, not just okay. But beware, experience can also cause us to repeat wrong behaviors that lead to bad habits. If you're a programmer with 8 years of experience, chances are you've been repeating the same mistakes for 8 years in a row. The way to overcome this fallacy is to constantly examine yourself and keep asking: Could I be better at this point? To give an interesting example, an experienced software developer wrote code that made him envious, so he thought the code was so perfect, he kept writing articles to prove how correct he was, the code What an excellent function. What about nitrogen? People never saw him go all the way to prove his code was wrong. In fact, really good programmers like to prove their faults, that is, to prove how wrong they are, because they know that in the long run, users will definitely find problems and mistakes in the software, and they hope that they will find these first. problems, rather than waiting for others to find out. Now, do you see the difference between the good and the mediocre?


  3. Code is not dead, it is always alive
   Yes, your first step is always to write high-quality code to meet the special needs of users, but where is the difference between excellent and mediocre? If you're just rushing into the next mission, you're inevitably going to be the poorest. After a piece of code is written, it does not die, it is always alive. What does this mean? Just because you wrote the code doesn't mean your work is over, on the contrary, it's just the beginning and you don't need to rush to the next site. Stopping only means showing and appreciating in stages, but great programmers know one thing well, and that is that everything can be better, the product is running, which is great, but your work is not over. Rely on iteration to make the product better and better.
How to make the product better? Depending on the application, we will ask different questions, such as, is faster adding value to the product? Easier to record isn't it? What about easier reuse? more reliable? Although these problems are different, the motivation of programmers to pursue the product is the same. do you understand? You keep thinking about how to make the product better, that's the same thing, but your approach is to ask different, different questions.


  4. Write it three times
   Good programmers think that the software they write works just fine, and great programmers think that the software needs to work perfectly. But this rarely works the first time, and the best software is usually written three times. First, you write software to prove to yourself or your users that a problem can be solved. Others may not realize that this is a time of conception, but you know it well. Then, you make the software work. Finally, you get it working correctly. You don't see this level of workflow evidently in the best developers, they do everything they do looks so smart, but behind them, even star developers, how many times do they The first and second editions go in the trash, you don't know. If you want to be better, you need to incorporate the powerful method of ditching the code and starting over into your own workflow. If there are no special circumstances, "Write Three Times" can teach you to realize that there are many ways to solve a problem, and it will save you from hanging from a tree.

  5. Read code as much as possible, the more the better
   I can't give more advice here, I can only tell you that to improve your programming skills, you have to read other people's code. This is so important. You can read other people's code and find out how they solve a programming problem. But don't just use them as references, use them as a class or challenge to learn skills and improve your coding skills. You can ask yourself: oh, look at this pile of code I wrote, how is yours different from mine? Did you find another solution? What can I learn? How can I use it in my code? I never thought I could do this before! What can I do to improve the quality of my code?
   Now that these resources are open to you, you can have the confidence to find a better solution, go for it! Write code with the mentality of being a writer. This practice will help you reach out to the best minds, so that it will resonate with them. Don't imagine the process too loosely. Whether you're used to private magazines, blogs, code review programs, or community platforms with many developers, you need to share the results of your thinking. For example, explaining a problem to a friend can help you clarify your thinking. Another example is sharing your analysis, which can help you understand why you feedback other people's code with a solid idea. That's all there is to the self-reflection I mentioned earlier. Introspection will help you calmly judge your own strengths and weaknesses.
   Note: reading a lot of code doesn't make you a great programmer, just as someone who wants to surpass a great writer reading a lot of good literature doesn't necessarily improve their writing skills. A lot of developers just read to simply solve a problem, they're desperate to find an answer, so most of the time, they just copy and paste someone else's code. If you do, you will become a particularly bad programmer because you are blind to the wisdom of others. Plus, if you just copy and don't take the time to understand, you're eating bugs instead of summer lunches. In this way, you effectively become a bug factory.


  6. Don't code just for work
   There are many benefits to a personal programming project. For example, not only will you have the opportunity to acquire tools and techniques that are difficult to learn in your current job, but it will also give you a better market perspective. Whether you contribute to an open source project or take on a pro bono project organized by a local community, you will gain technical competence and confidence. Plus, your private projects prove to your potential employers that you are someone who will not stop active learning. Another benefit of coding for love is that you can easily solve many problems on your own. You can't throw your troubles on others, you stop asking for help as soon as you have a problem. TIP: Don't just pick private projects you're sure about, you need to experiment with something you're not sure about. But you probably don't want to fail when faced with a deadline.


  7. Collaborate as closely as possible with other developers
   Listening to others is a fundamental principle of cooperation. Whether you're coding in a team or participating in a hackathon, or just participating in a coders federation, such as the Vermont Coders Federation. When you selflessly contribute to an open source project, you need to pay attention to feedback from users and other developers. Do you see those commonalities in these comments? You are fortunate enough to have trusted personal advisors who can guide you on a range of coding skills and career options you need. Don't waste these opportunities.


  8. You learn technology, not
   tools That's why you need as much experience as possible with languages, frameworks. You have to focus on the fundamentals of programming, because the fundamentals remain the same; you also have to focus on building rather than writing. Anytime you believe that there is only one right path to truth, it is time for you to reflect on yourself. Dogma can prevent you from learning new things and make you reluctant to change. The truth is endless, but the core point of self-improvement is that you know where to stop.