1. Check your code before you blame others
Think about your own assumptions and other people's assumptions first. Tools from different vendors may have different assumptions built in, and even the same vendor may have different assumptions about different tools.
When others are reporting a problem you can't repeat, check out what they are doing. They may do things that you never thought of, or their order of doing things is very different from yours.
My personal principle is that if I have an undetermined error, then I will first consider whether it is a compiler problem, and then check if the stack is damaged. This is especially true when adding tracking code will cause the problem to move. The multi-threading problem is another source of bugs, sometimes it’s anxious to pull out your hair, or just want to smash your computer. When the system is multi-threaded, it is best to prefer simple code. We can't rely on debugging and unit testing to find any consistent bugs, so design simplicity is the most important.
So, before you blame the compiler indiscriminately, think about Holmes's suggestion. "Once you rule out all kinds of impossibility, no matter how unbelievable the rest is, it must be the truth."
2. Continuous learning
We live in an interesting era. As software development spreads across the globe, you'll find that there are many people who can do your job. So you need to keep learning to stay competitive. Otherwise, you will fall behind and stagnate until one day, the job no longer needs you, or outsourced to a cheaper workforce.
So what can we do? Some employers are very generous and will provide training to broaden your skills. Some people will say that I don't have time or don't have the funds to receive any training. Therefore, the key is to correct the mindset, and learning is responsible for yourself.
Here are some ways to learn. And many resources are available for free on the Internet:
Read books, magazines, blogs, Twitter feeds, and websites. If you want to learn more about objects, consider adding them to a mailing list or newsgroup.
If you really want to learn a certain technology, then you can automatically write the code.
Try to work with your tutor. Although you can learn something from anyone, you can learn more from people who are smarter or more experienced than you. If you can't find such a good teacher and friend, then please continue to look down.
Use a virtual tutor. Find the authors and developers you really like on the web and read what they write. Subscribe to their blog.
Understand the frameworks and libraries you use. Knowing how things work helps you apply them better. If you are using open source resources, then you are really lucky. Use the debugger to step through the code to see what's going on inside. You can also check out how people who are really smarter than you are writing and reviewing code.
When you make a mistake, fix a bug, or have a problem, try to really understand what's going on. It's quite possible that other people have already encountered the same problem and posted it online. Google search is really useful.
Another good way to learn things is the so-called "teaching." When others are listening to your words and asking you questions, you will learn something. User groups or local meetings can be established.
Join or start a research group (model community) for your own language and technology, or create a local user group.
Join the meeting. If you can't go, you can also watch it online. Many conferences will publish their conversations online for free.
Listen to the podcast.
Have you ever run a static analysis tool on the codebase, or have you checked your IDE warning? Learn what they reported and why.
Of course, if you have the super power of Neo in "The Matrix", naturally this is just a piece of cake for you. But unfortunately, we are all ordinary people, we need time and energy, and continuous efforts to promote continuous learning. However, you don't have to study all day long. As long as you can consciously spend some time to learn, even if it is an hour a day, there is better than nothing. People are not living for work, you should also have your own life.
3. Don't be afraid to destroy things
Every programmer with industry experience must have participated in a project that is at stake in the code base. The system is terrible, and changing this side will always break the unrelated features on the other side. Every time you add a module, the programmer can only think about changing the code as little as possible, and every time he releases it, he is scared. The skyscraper of this software is likely to collapse at any time. The reason for changing the code is so nerve-wracking because the system is too bad. But even if you know that there is something wrong with the system, you have to listen to it because of the scam. Any surgeon knows that if a wound wants to heal, it must be removed. Although surgery can bring pain, it is definitely better than any wound inflammation and ulceration.
Don't be afraid of your code. No one cares if something is temporarily broken when you bang the code. As long as the changes you make won't bring the project back to the starting state, it won't crash. Time-to-refactoring allows you to benefit from the entire lifecycle of your project. There is an added bonus to this, because you have had this experience dealing with critically ill systems, so you are very good at how it should work. Be good at applying this knowledge and don't dislike these precious treasures. Redefine internal interfaces, refactor modules, refactor copy-and-paste code, and simplify design by reducing dependencies. You can significantly reduce the complexity of your code by eliminating special cases, because special cases are often caused by incorrect coupling characteristics. Slowly transition from the old structure to the new structure and test along the way. If you want to complete a big refactoring at once, you will often consider giving up halfway because of various problems.
4. Professional programmer
One of the most important features of a professional programmer is responsibility. Professional programmers are responsible for their careers, budgets, schedule commitments, mistakes, skills and skills. A professional programmer will not shirk responsibility to others.
If you are professional, then you need to be responsible for your career. You have a responsibility to read and learn. It is your responsibility to keep an eye on the latest industries and technologies. But many programmers think this should be the job of their employer. NO, big mistakes. Think about a doctor? Think about a lawyer? They all cultivate and train themselves on their own. Their working hours are mostly used in reading magazines and magazines. They are always watching the latest news. So, we should be like this too. The relationship between you and your employer has been detailed in the employment contract, in short: your employer is committed to paying your salary and you are committed to doing the job.
Professional programmers are responsible for the code they write. Unless they know that the code is valid, the code will not be released. Now, think about this question: If it is you, will you release the code directly without understanding the code? Professional programmers don't want QA to find any bugs because the code was released after he tested it. Of course, QA will still find some problems, because no one is perfect. But as a professional programmer, our attitude should be to make QA unable to find any defects.
Professional programmers are also good team members. They are responsible for the output of the entire team, not just their own work. They are helpful, good at learning from each other, and even helping each other when needed, for the sake of the project.
5. Take advantage of code analysis tools
The value of testing is an idea that is instilled in the early stages of programming to software developers. In recent years, the rise of unit testing, test-driven development, and agile methods has confirmed that we are beginning to focus on testing at all stages of the development cycle. However, testing is just one of many tools you can use to improve code quality.
Looking back, when C is still a new thing, CPU time and any type of storage are invaluable. The first C compiler noticed this, so it chose to reduce the number of passes between code by removing some semantic analysis. This means that at compile time, the compiler may only detect a small portion of the bugs that can be detected. To make up for this shortcoming, Stephen Johnson wrote a tool called lint -- it will remove some worthless things from your code -- to implement some static analysis functions that have been removed by its sibling C compiler. . However, static analysis tools are acclaimed for warnings that can give a wide range of false positive warnings and static style conventions that do not have to be followed.
The design of today's languages, compilers, and static analysis tools is quite different. Since memory and CPU time become relatively cheap, the compiler can afford to check for more errors. Almost every language has at least one tool for checking the style guide's violations, common problems, and some embarrassing mistakes that can sometimes be difficult to capture, such as potentially dereferencing null pointers. More advanced tools, such as C's Splint, and Python's pylint, are configurable, which means you can use configuration files to let the tool choose which errors and warnings to pass through the command line switch or in the IDE. Splint even lets you annotate your code in comments to better hint at how your program works.
6. Care about the code
There is no doubt that good programmers can write good code. Bad programmers... can't (they can write good code, it's not a bad programmer, haha). They are always producing monsters that others have to destroy. Your goal is to write good code, right? Then you should be a good programmer.
Good code doesn't come out of thin air, and you can't rely on luck and then happen to let your cat meet dead mice. In order to get good code, you have to work hard to improve. The process is tough. But if you really care about the code, then you can certainly get the code.
Technology alone does not make good programming. I've come across some very clever programmers who can produce impressive algorithms, memorize language standards, but write the most horrible code. This kind of code is very painful to read, it is very painful to use, and it is even more unpleasant to modify. I have also encountered some very humble programmers, because the simple code is adhered to, so the program written is more elegant, easier to express his meaning, and they work very happy.
Based on my years of software production experience, I have come to the conclusion that the real difference between a poor programmer and a great programmer is: attitude. Good programming lies in professional methods and expectations of trying to write the best software.
To be a good programmer, you have to be responsible for your own code, really care about the code - to develop a positive attitude. The great code was carefully crafted by the master, not written by the sloppy programmers.
The use of liquid crystal display under strong light is one of the development directions of liquid crystal display devices. At present, the liquid crystal display of the mainstream liquid crystal display device can get better display effect under the ordinary environment light. Hengstar can provide 10.4~55 inch high brightness Industrial LCD screen with brightness of 1000nits and above. Outdoor bright industrial LCD panel can meet the requirements of clear and visible in strong sunlight. For outdoor high brightness LCD screen selection, please find hengstar.
sunlight readable monitors,sunlight viewable monitor,sunlight readable computer monitor,sunlight readable display,sunlight readable touch screen monitor,direct sunlight monitor
Shenzhen Hengstar Technology Co., Ltd. , https://www.angeltondal.com