My views on the significance of fixing bugs in software projects in the future

As we all know, fixing bugs are essential for all software projects in the future. Some unexpected problems exist for programmers when a software is delivered to a customer or handed over to a tester for testing. There are mature bug tracking systems, such as bugzero, bugzilla, and redmine.
Solving bugs is a headache. It is generally caused by the following reasons:
(1) design defects;
(2) not fully considered when writing code;
(3) Testers are born out of nothing;
(4) The plug-ins on which the framework depends and the defects of the framework.

First case: it is the most tricky to modify the program architecture, which is time-consuming and labor-consuming, but it cannot be changed. You can follow your program. No way. Change it.
Case 2: Okay. Check if the problem occurs. You can modify the code. But after the change, check whether it will affect other modules or functions. In general, if the impact is great, the coupling degree between modules is too high. If it is not a high-quality code, the changes will become messy.
Case 3:
A. When writing a requirement document, the design of the software requirements is vague, which can lead to ambiguity. For example, when writing demand documents, consider leaving people with space to use their imagination or conflicts.
B. Testers or software developers do not really need to understand, for example, cultural differences lead to different understandings.
C. Test your revenge. Haha ..
Case 4:
The more software is developed to the end, the more difficult the bug is. At this time, your slight changes to the Code may lead to new bugs. No matter how well your design is, how low the coupling between modules is, are inevitable. Deep-seated problems are gradually exposed, that is, the things on which your project depends, such as third-party plug-ins, framework defects, or misuse caused by lack of understanding. These bugs are the biggest headache. It's a pity to abandon it.

However, as a persistent programmer or software engineer, the basic professional ethics is still necessary, and the bug cannot be solved. In fact, although no new things can be learned to solve bugs, there are still advantages:
(1) You can gain a deeper understanding of yourself and the "defects" you have been ignoring ".
(2) test your patience, patience, and limits.
(3) increase the communication between programmers and promote emotional communication.
Let's talk about this. If you encounter a bug that you cannot solve, ask the person who can solve the problem to help you. If you have advanced instructions, you can also learn more, I learned not how to solve this bug, but how people think about problems is wider than you. After finding the cause, you can be as omnipotent as you are. Haha...
(4) You can take advantage of your power in your spare time.
In the early and middle stages of the project, the project is busy with tasks and there is basically no spare time. In the later stages, people with fewer bugs can spend more time on their own. Well, you are using this.

The above are my thoughts on the significance of fixing bugs in software projects in the later stage, hoping to inspire the majority of software workers. We also encourage those who are not in silence in the bug to let themselves go.