Introduce the principles, advantages and disadvantages of common software process models (waterfall, prototype, increment, spiral)? Good answer. 200 points.

Typical development modes include waterfall mode, incremental mode, prototype mode, spiral mode, fountain mode, intelligent mode and mixed mode.

1, build and repair the model.

Unfortunately, many products are developed using the mode of "doing and changing". In this mode, there is neither specification nor design, and the software is constantly modified again and again with the needs of customers.

In this mode, the developer immediately writes the program according to the requirements after getting the project, and generates the first version of the software after debugging. After providing it to users, if there is an error in the program or the user puts forward new requirements, the developer will modify the code again until the user is satisfied.

This is a workshop-style development method, which is not bad for writing small programs with hundreds of lines, but it is not satisfactory for development of any scale. The main problems are as follows:

1) lacks planning and design links, and the structure of the software is getting worse and worse with continuous modification, so it cannot be modified any more;

2) Ignoring the requirement link brings great risks to software development;

3) It is very difficult to maintain the software without considering the maintainability of the test and program and any documents.

2. Waterfall model

1970, Winston Royce put forward the famous waterfall model, which was the only widely used software development model until the early 1980s.

The waterfall model divides the software life cycle into six basic activities: planning, requirements analysis, software design, programming, software testing and operation and maintenance, and specifies their fixed order from top to bottom, falling step by step like a waterfall.

In the waterfall model, all activities of software development are carried out strictly in a linear way, and the current activity accepts the work results of the previous activity and realizes the required work content. Need to verify the work results of the current activity. If it passes the verification, the result will be used as the input of the next activity and continue the next activity; Otherwise, it will be modified.

Waterfall model emphasizes the role of documents and needs to be carefully verified at each stage. However, the linear process of this model is too idealistic, which is no longer suitable for modern software development mode and is almost abandoned by the industry. Its main problems are:

1) The division of each stage is completely fixed, and a large number of documents are generated between stages, which greatly increases the workload;

2) Because the development model is linear, users can't see the development results until the end of the whole process, which increases the risk of development;

3) Early mistakes may not be discovered until the later testing stage of development, which will bring serious consequences.

We should realize that "linearity" is the easiest way of thinking to master and skillfully use. When people encounter a complex "nonlinear" problem, they always try their best to decompose or transform it into a series of simple linear problems, and then solve them one by one. The whole of a software system may be complicated, but a single subroutine is always simple and can be realized in a linear way, otherwise it will be too tired to work. Linearity is simplicity, and simplicity is beauty. When we understand the spirit of linearity, we should not mechanically apply the appearance of linear model, but use it vividly. For example, the incremental model is essentially a piecewise linear model, while the spiral model is a continuous curve linear model, and the shadow of the linear model can also be found in other models.

3. rapid prototype model (rapid prototype model)

The first step of Rapid prototype model is to build a rapid prototype to realize the interaction between customers or future users and the system. Users or customers will evaluate the prototype and further refine the requirements of the software to be developed. By gradually adjusting the prototype to meet the requirements of customers, developers can determine what the real needs of customers are; The second step is to develop customer-satisfied software products on the basis of the first step.

Obviously, rapid prototyping method can overcome the shortcomings of waterfall model and reduce the development risk caused by unclear software requirements, with remarkable results.

The key to rapid prototyping is to build a software prototype as quickly as possible. Once the customer's real needs are determined, the built prototype will be discarded. Therefore, the internal structure of the prototype system is not important. It is important that the prototype must be established quickly and then modified quickly to reflect the needs of customers.

4, Incremental Model (incremental model)

Just like building a building, software is built step by step. In the incremental model, software is designed, implemented, integrated and tested as a series of incremental components, and each component consists of code fragments that provide specific functions formed by various interactive modules.

The incremental model does not deliver a complete product that can be run at every stage, but a subset of products that can meet the needs of customers. The whole product is divided into several components, and the developer delivers 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, thus reducing the development risk. However, the incremental model also has the following defects:

1) Because each component is gradually integrated into the existing software architecture, adding components must not destroy the built system part, which requires the software to have an open architecture.

2) In the process of development, the change of requirements is inevitable. The flexibility of incremental model can make it much better than waterfall model and rapid prototype model model in adapting to this change, but it is also easy to degenerate into changing the model while doing it, thus losing the integrity of software process control.

When using the incremental model, the first increment is often the core product to realize the basic requirements. After the core products are delivered to users, the next incremental development plan is formed after evaluation, including the modification of core products and the release of some new functions. This process is repeated after each incremental release until the final perfect product is produced.

For example, developing word processing software with incremental model. It can be considered that the first increment releases basic file management, editing and document generation functions, the second increment releases more perfect editing and document generation functions, the third increment realizes spelling and grammar checking functions, and the fourth increment completes advanced page layout functions.

5, Spiral Model (spiral model)

1988, Barry Boehm officially published the "spiral model" of software system development, which combined the waterfall model with rapid prototype model and emphasized the risk analysis neglected by other models, especially suitable for large-scale complex systems.

The spiral model iterates many times along the spiral, and the four quadrants in the figure represent the following activities:

1) make a plan: determine the software objectives, select the implementation scheme, and define the constraints of project development;

2) Risk analysis: analyze and evaluate the selected scheme, and consider how to identify and eliminate risks;

3) Implementation project: implementation of software development and verification;

4) Customer evaluation: evaluate the development work, put forward suggestions for modification, and make the next plan.

The spiral model is risk-driven, and emphasizing the alternatives and constraints supporting software reuse is helpful to integrate software quality into product development as a special goal. However, the spiral model also has some limitations, as follows:

1) spiral model emphasizes risk analysis, but it is not easy for many customers to accept and believe this analysis and make relevant responses. Therefore, this model is usually suitable for large-scale internal software development.

2) If the execution 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 discovering possible risks and accurately analyzing risks, otherwise it will bring greater risks.

A stage is first to determine the objectives of the stage, complete the selection scheme of these objectives and its constraints, then analyze the development strategy of the scheme from the perspective of risk, and try to eliminate all kinds of potential risks, sometimes by building prototypes. If some risks cannot be eliminated, the scheme will be terminated immediately, otherwise the next development will be started. Finally, evaluate the achievements of this stage and design the next stage.

6, evolutionary model (evolutionary model)

Mainly aimed at software development that cannot fully define requirements in advance. Users can give the core requirements of the system to be developed, and when they see the realization of the core requirements, they can give effective feedback to support the final design and implementation of the system. According to the needs of users, software developers first develop the core system. After the core system is put into operation, users try it out, complete the work, and put forward the demand of refining the system and enhancing the system capability. Software developers implement the iterative process of development according to the feedback from users. The first iteration process consists of requirements, design, coding, testing, integration and other stages, adding a definable and manageable subset to the whole system.

In the development mode, the method of batch cycle development is adopted, and each cycle develops a part of functions, which becomes the new functions of the product prototype. Therefore, the design is constantly evolving into a new system. In fact, this model can be regarded as multiple "waterfall models" that are repeatedly executed.

The "evolutionary model" requires developers to have the ability to decompose the product requirements of the project into different groups for batch recycling and development. This grouping is not absolutely random, but should be judged according to the importance of the function and its impact on the overall design infrastructure. Experience shows that the appropriate length of each development cycle is six to eight weeks.

7. Fountain model (object-oriented lifetime model, object-oriented (OO) model).

Compared with the traditional structured life cycle, the fountain model has more incremental and iterative properties, each stage of the life cycle can be overlapped and repeated many times, and the sub-life can be embedded in the whole life cycle of the project. Just like the water sprayed on it, it can fall in the middle or at the bottom.

8. Intelligent Model (4th Generation Technology (4GL))

Intelligent model has a set of tools (such as data query, report generation, data processing, screen definition, code generation, advanced graphics functions and spreadsheets, etc. ), and each tool allows developers to define some features of software at a high level and automatically generate these developer-defined software as source code. This method needs the support of four generations of languages (4GL). 4GL is different from the third generation language, its main feature is that the user interface is extremely friendly, so even if there is no trained non-professional programmer, it can be used to write programs. It is a declarative, interactive and non-procedural programming language. 4GL also has efficient program code, intelligent default hypothesis, complete database and application generator. At present, 4GL (such as Foxpro, etc. ) All the products popular in the market have the above characteristics to varying degrees. However, 4GL is currently mainly limited to the development of small and medium-sized applications in the trading information system.

9. Mixed model

Process development model is also called hybrid model, or meta-model. It combines several different models into a mixed model, allowing the project to develop along the most effective path. This is the process development model (or hybrid model). In fact, some software development companies use several different development methods to form their own hybrid models.

Advantages and disadvantages of the model

The waterfall model document-driven system may not meet the needs of customers.

Rapid prototype model's concern about meeting customers' needs may lead to poor system design, low efficiency and difficult maintenance.

The early feedback of incremental model development is timely, easy to maintain, and requires an open architecture, which may lead to poor design and inefficiency.

Spiral model risk-driven risk analysts need to be experienced and well-trained.

===================

OOA (Object-Oriented Analysis) model consists of five levels (theme layer, object class layer, structure layer, attribute layer and service layer) and five activities (identifying object class, identifying structure, defining theme, defining attribute and defining service). In this method, the structure between two object classes is defined, one is called classification structure, and the other is called assembly structure. The classification structure is the so-called relationship between generality and particularity. Assembly structure reflects the relationship between the whole and parts of the object.

OOA should identify instance connections when defining attributes. Instance connection is a mapping relationship between one instance and another. Identify message connections when defining services. When an object needs to send a message to another object, there is a message connection between them.

Five levels and five activities in OOA continue to run through the process of OOD (Drawing Object Oriented Design). The OOD model consists of four parts. They are design problem domain, design human-computer interaction, design task management and design data management.

Booch believes that software development is a spiral process. In each spiral cycle, there are four steps: identify classes and objects, determine their meanings, identify their relationships, and explain the interface and implementation of each class.

Object modeling technology OMT defines three models, namely, object model, dynamic model and functional model. OMT uses these three models to describe this system. OMT method has four steps: analysis, system design, object design and implementation. Each step of OMT method uses these three models, and each step is constantly refining and expanding these three models.

The object model description system includes the static structure of objects, the relationship between objects, the attributes of objects and the operations of objects. In the object model of OMT, besides objects, classes and inheritance, there are also concepts such as chain, association, generalization, aggregation and module.

Dynamic model is used to describe the system characteristics related to the transformation of values-functions, mappings, constraints and functional dependencies. The functional model is represented by a data flow diagram.