Software Design (1)-avoiding problems

 After the software is developed, there are only two groups to contact him. One is a user and the other is a developer. Therefore, when designing software, the two groups should consider simultaneously and weigh the key points of each design point from each angle.

The developed software is intended for users and users to deal with it every day. As a result, the interface is beautiful, functional, and easy to operate, data transmission speed and close business logic are important to users.

For developers, after the software development is completed, it is not necessary to worry about it. The maintenance of the software is also very important and cumbersome. Over time, users will constantly change their needs and require you to improve the software. Of course, you will block some requirements and implement them through the existing conditional variants, but there will always be some that you need to add or modify. At this time, is your software flexible enough to start the design, and you will know when you modify it.

If the maintenance software gives you a headache and you would rather than re-develop it than modify it, it means that the software design is not successful.

 

If you want to avoid software corruption and make future maintenance easier, you should avoid the following problems when designing the software:

1. Rigidity ( Rigidity ): Difficult to change Design

When a user raises a new requirementProgramYou can changeCodeIt is found that although a small function is added, many aspects are involved. Such a single change leads to chained changes in dependency modules, so the design is rigid. No one is willing to move the whole mountain for a small piece of jade. The spirit of yugong's mountain migration is not worth promoting here.

 

2. Vulnerability ( Fragility ): The design is easily damaged.

After the user completes the modification of the function he wants to add and re-tests it, he finds that other functions that are not conceptually associated with the new function have encountered an error. Correcting these problems will lead to more problems. Like nailing on Glass--The more nails, the more broken.

 

3. Robustness ( Immobility ): Difficult to reuse design

Similar systems always have many similarities, and even some are identical. After being treated as a project, another project is connected. The functions of these two projects are similar, but they are only used by different customers. The business logic is slightly different, however, personnel management and permission management are basically the same. At this time, you want to copy the personnel management and permission management in the previous project and use it for modification. However, it is found that the workload of the changes is huge and it is better to redo it, this shows that the previous project has poor reusability during design.

 

4. sticky ( viscosity ): it is difficult to do the right thing

When you change a function, there are often multiple ways to change it. Some of these methods will maintain the initial design, while others will undermine the initial design. Generally, you choose to retain the initial design method, but you find that the changes to the design-preserving method are more difficult to deal with than those that damage the design method, this indicates that the initial design is highly viscous.

 

5. Unnecessary complexity ( Needless complexity ): Over-design

It doesn't mean that the more complex the software is, the better the software. Isn't the more functions the appliances are, the easier it is to break down! The same is true for software. The more complicated the design, the more complicated the logic will be, and the more time it will take to develop. There are only three fields on the Type list page.10Record. You have to add a flip control to the page. Isn't that a superfluous addition!

 

6. Unnecessary repetition ( Needless repetition ): Misuse of the mouse (disorderly copying)

Copying and pasting can improve development efficiency, but sometimes lead to excessive abuse. The system has a formula for calculating the total amount, which is used in many places, so every developer

Copy and paste it into your own program. After a while, the country's policies have been adjusted, and the calculation formula has to be changed. Now everyone is dumpily looking for this formula process when the project is full. Time-consuming and labor-intensive.

 

7. obscure ( opacity ): chaotic expression

Development modules are hard for others to understand. A software is sometimes written by many developers. If the module naming and programming formats are all developed in their own way, it takes a long time, the more painful the developer is to take over the code, the more difficult it is to open the code, according to the name in it does not know what this code is for, it always takes a lot of time to first understand the code.