What is the software development model?

What is the software development model?
Software development model refers to the structural framework of all processes, activities, and tasks of software development. Software development includes the stages of requirement, design, coding and testing, and sometimes maintenance.
The software development model can clearly and intuitively express the entire process of software development, and clearly defines the main activities and tasks to be completed as the basis of software project work.
The earliest software development model was the waterfall model proposed by W. Royce in 1970. The model provides a fixed sequence of transition from the previous stage to the next stage, just like downstream, and finally gets the developed software products for use. However, when computing is widely used in fields such as statistical analysis and Business Affairs, most programs are written in advanced languages such as Fortran and Cobol. The waterfall model also has shortcomings, such as lack of flexibility and failure to clarify inaccurate requirements through concurrent activities.
 
Typical development models include: ① waterfall model; ② Incremental Model/evolution/iteration (incremental model); ③ prototype model ); ④ spiral model; ⑤ fountain model; ⑥ intelligent model; 7. hybrid Model)
1. Build-and-fix Model)
Unfortunately, many products are developed using the "make and modify" model. In this model, there is neither specification nor design, and the software is constantly modified as the customer needs it.
In this model, developers get the project and immediately write programs as needed. After debugging passes, the first version of the software is generated. After the application is provided to the user, if a program error occurs or the user puts forward a new requirement, the developer re-modifies the code until the user is satisfied.
This is a development method similar to workshops. It is good for writing hundreds of lines of small programs, but this method is not satisfactory for any scale of development. The main problem is:
(1) The software structure cannot be modified because of the lack of planning and design processes;
(2) Ignoring demand links brings great risks to software development;
(3) It is very difficult to maintain the software without considering the testing and program maintainability and without any documents.
2. Waterfall Model)
Winston Royce proposed the famous "Waterfall Model" in 1970. It was the only widely used software development model until the early 1980s S.
The waterfall model divides the software life cycle into six basic activities, including planning, demand analysis, software design, programming, software testing, and operation and maintenance, they also define a fixed order of top-down and interconnection, like waterfall flow, falling down step by step.
In the waterfall model, various activities of software development are carried out in a linear manner. The current activity accepts the work results of the previous activity and the work required for implementation. The work result of the current activity needs to be verified. If the verification is successful, the result is used as the input for the next activity to continue the next activity. Otherwise, the modification is returned.
The waterfall model emphasizes the role of the document and requires careful verification at each stage. However, the linear process of this model is too idealistic. It is no longer suitable for modern software development models and almost abandoned by the industry. The main problem is:
(1) The division of each stage is completely fixed, and a large number of documents are generated between stages, greatly increasing the workload;
(2) because the development model is linear, the user can see the development results only at the end of the entire process, thus increasing the development risk;
(3) Early errors may not be detected until the test phase at the end of the development stage, resulting in serious consequences.
We should realize that "Linearity" is the easiest way for people to master and use it skillfully. When people encounter a complicated "non-linear" problem, they always try every means to break it down or convert it into a series of simple linear problems, and then solve them one by one. A software system may be complex as a whole, and a single subroutine is always simple and can be implemented in a linear way. Otherwise, it will be too tired to work. Linear is concise, and concise is beautiful. When we understand the spirit of linearity, we should not just use the appearance of a linear model, but live it. For example, the incremental model is essentially a linear model with segments, while the spiral model is a series of curved linear models. The shadows of linear models can also be found in other models.
3. Rapid Prototype Model)
The first step of the rapid prototyping model is to build a rapid prototype to realize the interaction between the customer or the future user and the system. the user or the customer evaluates the prototype and further refine the Needs of the software to be developed. By gradually adjusting the prototype to meet the customer's requirements, developers can determine what the customer's real needs are. The second step is to develop the customer's satisfied software products based on the first step.
Obviously, the rapid prototyping method can overcome the shortcomings of the waterfall model and reduce the development risks caused by unclear software requirements, with remarkable results.
The key to rapid prototyping is to build software prototypes as quickly as possible. Once the customer's real needs are identified, the prototypes will be discarded. Therefore, the internal structure of the prototype system is not important. What is important is that the prototype must be established quickly and then the prototype must be modified quickly to reflect the customer's needs.
4. Incremental Model)
Similar to building, software is also built step by step. In an incremental model, software is designed, implemented, integrated, and tested as a series of incremental components, each component is composed of code fragments that provide specific functions formed by multiple interacting modules.
Incremental models do not deliver a complete product that can run at each stage, but deliver a subset of products that meet customer needs. The entire product is divided into several components, and developers deliver the product one by one. The advantage of this is that software development can better adapt to changes, and customers can constantly see the developed software, this reduces development risks. However, the incremental model also has the following defects:
(1) Since each component is gradually incorporated into the existing software architecture, adding the component must not destroy the structure of the system, which requires the software to have an open architecture.
(2) demand changes are inevitable during the development process. The flexibility of the incremental model makes it better to adapt to this change than the waterfall model and the rapid prototype model, but it is also easy to degrade to the side-to-side modeling, instead, the control of software processes loses integrity.
When using the incremental model, the first increment is usually the core product that meets basic requirements. After core products are delivered to users for use, they form the next incremental development plan, which includes modifications to core products and release of some new features. This process repeats after each incremental release until the final perfect product is produced.
For example, you can use an incremental model to develop a word processing software. You can consider that the first step is to incrementally release basic file management, editing, and document generation functions, and the second step is to release more comprehensive editing and document generation functions, the third step implements spelling and grammar check functions, and the fourth step completes Advanced page layout functions.
5. Spiral Model)
In 1988, Barry Boehm officially published the software system development "spiral model", which combines the waterfall model with the rapid prototype model and emphasizes the risk analysis ignored by other models, it is particularly suitable for large and complex systems.
The spiral model carries out several iterations along the spiral line. The four quadrants in the figure represent the following activities:
(1) Develop a plan: Determine the software objectives, select the implementation scheme, and clarify the constraints of project development;
(2) Risk analysis: analyzes and evaluates the selected scheme and considers how to identify and eliminate risks;
(3) Implementation Project: implement software development and verification;
(4) customer evaluation: evaluates the development work, proposes amendments, and develops the next plan.
A spiral model is driven by risks and emphasizes optional solutions and constraints to support software reuse. This helps to integrate software quality into product development as a special goal. However, the spiral model also has certain restrictions, as shown below:
(1) The spiral model emphasizes risk analysis, but it is not easy for many customers to accept and trust this analysis and make relevant responses. Therefore, this model is often suitable for large-scale internal software development.
(2) If the implementation of risk analysis will greatly affect the profit of the project, it is meaningless to carry out risk analysis. Therefore, the spiral model is only suitable for large-scale software projects.
(3) software developers should be good at finding possible risks and accurately analyzing them; otherwise, they will bring greater risks.
One stage is to first determine the objectives of the stage, complete the selection scheme and its constraints for these objectives, and then analyze the development strategies of the scheme from the perspective of risks, and strive to eliminate various potential risks, sometimes it is necessary to build a prototype. If some risks cannot be ruled out, the solution is terminated immediately. Otherwise, start the next development step. Finally, evaluate the results of this stage and design the next stage.
6. Incremental Model)
Mainly for software development that cannot be fully defined in advance. You can provide the core requirements of the system to be developed. When you see the implementation of the core requirements, you can effectively provide feedback to support the final design and implementation of the system. Software developers first develop core systems based on user needs. After the core system is put into operation, users can try it out to complete their work and put forward the need to refine the system and enhance the system capabilities. Software developers implement the iterative development process based on user feedback. The first iteration process is composed of requirements, design, coding, testing, integration, and other stages. A Customizable and manageable subset is added to the entire system.
In the development mode, we adopt the batch cyclic development method to develop some functions in each cycle. They become new features of the product prototype. As a result, the design continues to evolve into a new system. In fact, this model can be seen as repeated execution of multiple "waterfall models ".
The "evolutionary model" requires developers to be able to break down project product requirements into different groups for batch and cyclic development. This type of grouping is not absolutely random, but should be determined based on the importance of the function and the impact on the overall design infrastructure. Experience points out that each development cycle takes six weeks to eight weeks as the proper length.

7. fountain model (Object-Oriented survival model, oo model ))
Compared with the traditional structured survival model, the fountain model has more incremental and iterative properties, and each stage of the survival can overlap with each other and repeatedly, in addition, the sub-lifetime can be embedded throughout the entire life cycle of the project. Just like the water sprayed up and down, it can fall in the middle or at the bottom.
8. Intelligent Model (four-generation technology (4gl ))
A smart model has a set of tools (such as data query, report generation, data processing, screen definition, code generation, high-level graphical functions, and workbooks ), each tool enables developers to define certain features of software at a high level and automatically generate the Software Defined by developers into source code. This method requires the support of four generations of languages (4gl. 4gl is different from three generations of languages. Its main feature is that the user interface is extremely friendly and can be used to program even non-professional programmers who have not been trained; it is a declarative, interactive, and non-procedural programming language. 4gl also has efficient program code, smart default assumptions, complete databases and application generators. Currently, the popular 4gl (such as FOXPRO) in the market has the above features to varying degrees. However, 4gl is currently mainly limited to the development of medium and small applications in transaction information systems.
9. Hybrid Model)
A process development model is also called a hybrid model or a meta-model. It combines several different models into a hybrid model, it allows a project to develop along the most effective path. This is the process development model (or hybrid model ). In fact, some software development units use several different development methods to form their own hybrid models.
Comparison of various models
Each Software Development Organization should select a software development model suitable for the Organization and change with the specific product features being developed to reduce the disadvantages of the selected model and make full use of its advantages, the following table lists the advantages and disadvantages of several common models.

Model	Advantages	Disadvantages
Waterfall Model	Document-driven	The system may not meet the customer's needs
Quick prototyping	Focus on meeting customer needs	Poor system design, low efficiency, and difficult to maintain
Incremental Model	Early Development Feedback is timely and easy to maintain	Open Architecture is required, which may result in poor design and low efficiency.
Spiral Model	Risk-driven	Risk analysts need to be experienced and fully trained