Common software development models include: 1. Change while doing model; 2. Waterfall model; 3. Rapid prototyping model; 4. Incremental model; 5. Spiral model; 6. Fountain model; 7. Intelligent model; 8. Hybrid model; 9. RUP model; 10. IPD model.
The operating environment of this tutorial: Windows 10 system, Dell G3 computer.
Common software development models are:
1. Build-and-Fix Model
Sorry Unfortunately, many products are developed using a "change-as-you-make" model. In this model, there are neither specifications nor designs, and the software is constantly modified again and again as customers need it. In this model, developers get the project and immediately write the program according to the requirements. After debugging, 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 fine for writing small programs of a few hundred lines, but this method is unsatisfactory for development of any scale. The main problem is:
(1) Lack of planning and design links, the structure of the software becomes worse and worse with continuous modification, making it impossible to continue modification;
(2) Ignoring the demand link brings great consequences to software development Risks;
(3) The maintainability of testing and programs is not considered, and there is no documentation, making software maintenance very difficult.
2. Waterfall Model
In 1970, Winston Royce proposed the famous "Waterfall Model". Until the early 1980s, it had been the only widely used model. The software development model adopted. In the waterfall model, as shown in the figure, the software life cycle is divided into six basic activities such as planning, demand analysis, software design, program writing, software testing and operation and maintenance, and their top-down and interconnected activities are stipulated. A fixed sequence, like a waterfall, falling step by step. 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 implements the 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 for people to master and skillfully apply it. 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, and 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 in the rapid prototyping model is to build a rapid prototype to realize the interaction between customers or future users and the system. Interactively, users or customers evaluate the prototype and 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, and then discard the prototypes once the customer's true needs are determined. 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
Incremental Model is also called 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 multiple interacting modules. The incremental model does not deliver a complete runnable product at each stage, but a subset of the runnable product that meets customer 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. However, the incremental model also has the following flaws:
(1) Since each component is gradually integrated into the existing software architecture, adding components must not destroy the already constructed system parts, which requires The software has an open architecture.
(2) During the development process, changes in requirements are inevitable. The flexibility of the incremental model can make its ability to adapt to such changes much better than the waterfall model and rapid prototyping model, but it can also easily degenerate into a model that is modified while doing it, so that the control of the software process loses integrity. When using an incremental model, the first increment is often the core product that fulfills the basic need. After the core product is delivered to users, the next incremental development plan is formed after evaluation, which includes modifications to the core product and the release of some new features. This process is repeated after each incremental release until the final, polished product is produced. For example, use the incremental model to develop word processing software. It can be considered that the first increment releases basic file management, editing and document generation functions, the second increment releases more complete editing and document generation functions, the third increment implements spelling and grammar checking functions, and the fourth increment implements spelling and grammar checking functions. Incrementally complete advanced page layout functions.
5. Spiral Model
In 1988, Barry Boehm officially published the "Spiral Model" of software system development, which combined the waterfall model and rapid prototyping. The model combines to emphasize risk analysis that other models ignore, and is particularly suitable for large and complex systems. As shown in the figure, the spiral model undergoes several iterations along the spiral. The four quadrants in the figure represent the following activities:
(1) Make a plan: determine the software goals, select the implementation plan, and clarify Restrictions on 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, make suggestions for corrections, and formulate next steps. The spiral model is risk-driven, emphasizes 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 finding possible risks and accurately analyzing risks, otherwise it will bring greater risks. A stage first determines the goals of the stage, the options for completing these goals and their constraints, and then analyzes the development strategy of the program 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. Fountain model
Fountain model (also known as object-oriented lifetime model, OO model) Fountain model and traditional Compared with structured lifetime, it has more incremental and iterative nature. Each phase of the lifetime can overlap with each other and be repeated multiple times, and sub-lifetimes can also be embedded in the entire lifetime of the project. Just like water that sprays up and falls down again, it can fall in the middle or at the bottom.
7. 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 of which enables developers to define the software at a high level. Certain features and automatically generate source code for these software defined by developers. This approach requires fourth generation language (4GL) support. 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. The popular 4GLs currently on the market (such as Foxpro, etc.) all have the above characteristics to varying degrees. However, 4GL is currently mainly limited to the development of small and medium-sized applications for transaction information systems.
8. Hybrid model
Hybrid model (hybrid model) process development model is also called hybrid model (hybrid model), or meta model (meta-model), combines several different models into a hybrid model, which allows a project to develop along the most efficient path. This is the process development model (or hybrid model). In fact, some software development organizations use several different development methods to form their own hybrid models. Comparison of various models. Each software development organization should choose a software development model that is suitable for the organization and should change with the specific product features currently being developed to reduce the shortcomings of the selected model and make full use of its advantages. Next The table lists the advantages and disadvantages of several common models. Advantages and disadvantages of various models: Model Advantages Disadvantages Waterfall model Document-driven system may not meet customer needs Rapid prototyping model Focus on meeting customer needs may result in poor system design, inefficiency, and difficulty in maintaining Incremental model development Early feedback is timely and easy to maintain An open architecture is required and may be poorly designed and inefficient. Spiral model risk-driven risk analysts need to be experienced and fully trained
9. RUP model (iterative model)
The RUP (Rational Unified Process) model is a set of development process models proposed by Rational. It is a common business process for object-oriented software engineering. It describes a series of related software engineering processes that have the same structure, that is, the same process architecture. RUP provides a standardized method for allocating tasks and responsibilities within a development organization, with the goal of ensuring that high-quality software that meets end-user needs is developed within a predictable schedule and budget. RUP has two axes, one is the timeline, which is dynamic. The other axis is the workflow axis, which is static. On the timeline, RUP is divided into four stages: initial stage, refinement stage, construction stage and release stage. The concept of iteration is used at each stage. On the workflow axis, RUP has designed six core workflows and three core supporting workflows. The core workflow axis includes: business modeling workflow, requirements workflow, analysis and design workflow, implementation workflow, and testing workflow. and publishing workflow. Core supporting workflows include: environment workflow, project management workflow, and configuration and change management workflow. RUP brings together the best practices in modern software development and provides a flexible format to suit the needs of various projects and organizations. As a business model, it has very detailed process guidance and templates. But also because the model is relatively complex, it requires a relatively large cost to master the model. In particular, relatively high requirements are put forward for project managers. It has the following characteristics:
(1) Incremental iteration, each iteration follows the waterfall model to control and resolve risks in the early stage;
(2) The complexity of the model requires project Managers have strong management capabilities.
10. IPD model
IPD (Integrated Product Development) process is a set of integrated product development processes proposed by IBM, which is very suitable for complex large-scale development projects. , especially projects involving the combination of software and hardware. IPD starts from the perspective of the entire product, and the process comprehensively considers all processes from system engineering, research and development (hardware, software, structural industrial design, testing, data development, etc.), manufacturing, finance to marketing, procurement, technical support, etc. It is an end-to-end process. The IPD process is divided into six stages (concept stage, planning stage, development stage, verification stage, release stage and life cycle stage), and four decision review points (concept stage decision review point, planning stage decision review point, Availability decision review points and end-of-life decision review points) and six technical review points. The IPD process is a staged model with shadows of the waterfall model. This model breaks down a large and complex system and reduces risks by using comprehensive and complex processes. To a certain extent, this model uses process costs to improve the quality of the entire product and gain market share. Since this process does not define a mechanism for process rollback, this process is not suitable for projects with frequently changing requirements. And for some small projects, this process is not very suitable.
Recommended learning:PHP Chinese website
The above is the detailed content of What are the common software development models?. For more information, please follow other related articles on the PHP Chinese website!