Phase 4: Revision

In fact, the entire development cycle is not over yet, and it is now entering a phase that is traditionally known as "maintenance." "Maintenance" is a more ambiguous salutation, which can be used to indicate the meaning of "keep it on track", "join a customer who has forgotten to declare a function" or more traditional "get rid of all exposed bugs" and so on. So we have a lot of misunderstanding about the word "maintenance", some people think: "Maintenance" of things, it is not good, or defective! Because the word means you actually build a very "raw" program, you need to make frequent changes, add new code, or prevent it from falling behind, degraded, and so on. Therefore, we need to use a more reasonable term to address the future needs of work.
The word is "edited". In other words, "The first thing you do is not perfect, so you need to leave a deep learning, cognitive space, and then go back to make some changes." For the problem to be solved, as you learn and understand it more deeply, you may need to make a lot of changes. One of the drivers of these efforts is that, with constant reform and optimization, it is finally possible to get a return on your efforts, whether it takes a shorter or longer period.
When is it called "to achieve the desired state"? This does not just mean that the program must work as required, and that it adapts to the various specified "usage conditions", which also means that the internal structure of the code should be perfect. At the very least, we should be able to sense that the whole structure works well. There are no clumsy grammars, no bloated objects, no flashy things. In addition, we must ensure that the program structure has a strong vitality. For many reasons, subsequent changes to the program are essential. But it must be determined that the changes can be done conveniently and clearly. There is no fancy here. You need to understand not only what you are building, but also how the program evolves. Fortunately, the Object-oriented programming language is particularly suitable for such continuous modifications-the boundaries established by the object can effectively guarantee the integrity of the structure and prevent unnecessary interference and destruction of unrelated objects. You can also make some seemingly drastic changes to your program without destroying the integrity of the program and not spilling it into other code. In fact, the support for "editing" is a very important feature of OOP.
By editing, you can create something that is at least as close to your own imagination. Then look at your work as a whole, compare it to your own requirements, and see what's missing. You can then take a leisurely look back and redesign and implement the inappropriate parts of the program (note ⑩). You may need to address some of the unavoidable issues or at least one aspect of the problem before you finally get the right solution. and generally to "edit" a few times to do ("design paradigm" here can play a great help. For its discussion, please refer to chapter 16th of this book.
When building a system, "editing" is almost inevitable. We need to constantly compare our needs to understand whether the system is actually needed. Sometimes only by actually seeing the system can you realize that you need to solve a different problem. If you think that this form of editing is bound to happen, then it is best to come up with your first version as soon as possible, check whether it is their own hope, so that their ideas continue to mature.
Repeated "revision" and "incremental development" related to the inseparable relationship. Incremental development means starting with the core of the system and implementing it as a framework, and then gradually building up the rest of the system on the basis of that framework. Subsequently, the various features (attributes) to be provided are added one after another. The most challenging technique here is to set up a framework that facilitates the expansion of all of the target features (for this matter, we can refer to chapter 16th). The advantage of this is that once the core framework is operational, each feature to be added is like a small project within itself, rather than part of a larger project. In addition, new features synthesized in the development or maintenance phase can be added more easily. OOP provides support for incremental development, because if the program is well designed, each increment can become a perfect object or group of objects.

⑩: It's kind of like "quick styling." At this point should focus on building a simple, clear version, so that you can have a clear grasp of the system. Throw this prototype away and formally build one. One of the most troublesome cases of rapid prototyping is that people do not throw out prototypes, but build them directly on the basis of them. If coupled with the lack of "structure" in programmed design, it will lead to a chaotic system, resulting in increased maintenance costs.