What is a software development model, and what are the common software development models?

Software development model refers to the structural framework of all software development processes, activities and tasks. Common software development models include: change-while-doing model, waterfall model, rapid prototyping model, incremental model, spiral model, evolution model, fountain model, intelligent model, hybrid model, and RAD model.

Software Development Model refers to the structural framework of all software development processes, activities and tasks.

Software development includes requirements, design, coding and testing phases, and sometimes also includes maintenance phases. The software development model can express the entire software development process clearly and intuitively, clearly stipulates the main activities and tasks to be completed, and is used as the basis for software project work.

For different software systems, different development methods can be adopted, different programming languages ​​can be used, personnel with various skills can participate in the work, different management methods and means can be used, and different software can be used. Tools and different software engineering environments.

Typical Development Model

1. Build-and-Fix Model

Unfortunately, many products are Developed using the "change as you go" model. In this model, there are neither specifications nor designs, and the software is constantly modified again and again according to customer needs.

In this model, developers get the project and write it immediately according to the requirements. After debugging the program, the first version of the software is generated. After being provided to users, if an error occurs in the program or the user makes new requirements, the developer will re-modify the code until the user is satisfied.

This is a workshop-like development method, which is not bad for writing small programs of several hundred lines. However, this method is unsatisfactory for development of any scale. Its main The problem is:

(1) Lack of planning and design links, the structure of the software is getting worse with continuous modifications, making it impossible to continue modifications;

(2) Ignoring the demand link, giving Software development brings great risks;

(3) There is no consideration of testing and program maintainability, and there is no documentation, making software maintenance very difficult.

2. Waterfall Model

In the waterfall model, various activities of software development are carried out strictly in a linear manner. The current activity accepts the work results of the previous activity and the implementation is completed. Required work content. The work results of the current activity need to be verified. If the verification passes, the result will be used as the input of the next activity and the next activity will continue. Otherwise, it will be returned for modification.

The waterfall model emphasizes the role of documentation and requires careful verification at each stage. However, the linear process of this model is too ideal and is no longer suitable for modern software development models. It has almost been abandoned by the industry. Its main problems are:

(1) The division of each stage is completely fixed, and the stages A large number of documents are generated during this period, which greatly increases the workload;

(2) Since the development model is linear, users can only see the development results until the end of the entire process, thus increasing the risk of development;

(3) Early errors may not be discovered until the testing phase of late development, which may have serious consequences.

We should realize that "linear" is the easiest way of thinking for people to master and skillfully apply. 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. A software system as a whole may be complex, but a single subroutine is always simple and can be implemented in a linear manner, otherwise the work will be too tiring. Linearity is a kind of simplicity, and simplicity is beauty. When we understand the spirit of linearity, we should no longer rigidly apply the appearance of the linear model, but should make use of it. For example, the incremental model is essentially a segmented linear model, while the spiral model is a continuous curved linear model. Shadows of the linear model 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 customers or future users and the system. Prototypes are evaluated to further refine the requirements for 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 builds on the first step to develop a software product that satisfies the customer.

Obviously, the rapid prototyping method can overcome the shortcomings of the waterfall model and reduce development risks caused by unclear software requirements, and has significant effects.

The key to rapid prototyping is to build software prototypes as quickly as possible. Once the real needs of the customer are determined, 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 quickly built and then modified quickly to reflect the customer's needs.

4. Incremental Model

Also known as evolutionary model. 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. Each component is composed of code fragments that provide specific functions formed by a variety of interacting modules. The incremental model is Each stage does not deliver a complete runnable product, but a subset of the runnable product that meets the customer's needs. The entire product is decomposed into several components, and developers deliver the product component by component. The advantage of this is that software development can better adapt to changes, and customers can continuously see the developed software, thereby reducing development risks

5. Spiral Model

In 1988, Barry Boehm officially published the "Spiral Model" of software system development, which combined the waterfall model and the rapid prototyping model, emphasizing what other models ignored. Risk analysis is particularly suitable for large and complex systems.

The spiral model undergoes several iterations along the spiral. The four quadrants in the figure represent the following activities:

(1) Formulate plans: determine software goals, select implementation plans, and develop Clear the constraints of project development;

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

(3) Implementation engineering: implement software development and verification;

(4) Customer evaluation: Evaluate the development work, propose corrections, and formulate next steps.

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

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

(2) If performing risk analysis will greatly affect the profit of the project, then performing risk analysis is meaningless. Therefore, the spiral model is only suitable for large-scale software projects.

(3) Software developers should be good at looking for possible risks and accurately analyzing risks, otherwise it will bring greater risks

The first step for a stage is to determine the goal of the stage and complete it Select solutions and their constraints for these goals, and then analyze the development strategy of the solution from a risk perspective, trying to eliminate various potential risks, sometimes by building prototypes. If certain risks cannot be eliminated, the program is terminated immediately, otherwise the next development step is initiated. Finally, evaluate the results of this phase and design the next phase.

6. Evolution model

The evolution model is a global software (or product) life cycle model. Belongs to iterative development method.

The model can be expressed as: first iteration (requirements->design->implementation->testing->integration)->feedback-> second iteration (requirements-> ;Design->Implementation->Testing->Integration)->Feedback->......

That is, based on the basic needs of the user, an initial runnable version of the software is constructed through rapid analysis , this initial software is usually called a prototype, and then the prototype is improved based on the opinions and suggestions made by users during the use of the prototype, and a new version of the prototype is obtained. By repeating this process, you can finally get a software product that satisfies users. The development process using the evolutionary model is actually the process of gradually evolving from the initial prototype to the final software product. Evolutionary models are particularly useful when there is a lack of accurate understanding of software requirements.

7. Fountain model

(also called object-oriented lifetime model, OO model)

Comparing the fountain model with the traditional structured lifetime, With a more incremental and iterative nature, lifecycle phases can overlap and iterate multiple times, and sub-lifecycles can be embedded throughout the project's lifetime. Just like water that sprays up and falls down again, it can fall in the middle or at the bottom.

8. Intelligent model (fourth generation technology (4GL))

The intelligent model has a set of tools (such as data query, report generation, data processing, screen definition, code generation, high-level graphics functions and spreadsheets, etc.), each tool enables developers to define certain features of software at a high level, and automatically generates source code for these software defined by developers.

This method requires the support of fourth generation language (4GL). 4GL is different from the third generation of languages. Its main feature is that the user interface is extremely friendly, even untrained non-professional programmers can use it to write programs; it is a declarative, interactive and non-procedural programming language. 4GL also features efficient program code, intelligent default assumptions, a complete database and application generator. Popular 4GLs on the market (such as Foxpro, etc.) all have the above characteristics to varying degrees. However, 4GL is mainly limited to the development of small and medium-sized applications for transaction information systems.

9. Hybrid model

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

10. RAD model

The Rapid Application Development (RAD) model is an incremental software development process model. Emphasis on extremely short development cycles. The RAD model is a "high-speed" variant of the waterfall model. It uses a large number of reusable components and adopts a component-based construction method to win rapid development. If the requirements are well understood and the scope of the project is constrained, then comes data modeling, process modeling, application generation, testing and iteration. The software process using the RAD model is shown in the figure on the right.

The above is the detailed content of What is a software development model, and what are the common software development models?. For more information, please follow other related articles on the PHP Chinese website!