Shulou(Shulou.com)06/02 Report--

I would like to share with you what the common software development models are on the Internet. I believe most people don't know much about it, so share this article for your reference. I hope you will learn a lot after reading this article. Let's learn about it!

The common software development models are: 1, change model while doing; 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: windows10 system, Dell G3 computer.

Common software development models are:

1. Modify the model while doing it (Build-and-Fix Model)

Unfortunately, many products are developed using the "change while doing" model. In this model, there is neither specification nor design, and the software is constantly modified again and again according to the needs of customers. In this model, developers write programs according to the requirements immediately when they get the project, and generate the first version of the software after debugging. After providing it to the user, if there is an error in the program, or if the user puts forward a new request, the developer remodifies the code until the user is satisfied. This is a workshop-like development approach, which is not bad for Mini Program, which writes hundreds of lines, but it is not satisfactory for development of any scale. The main problems are:

(1) due to the lack of planning and design links, the structure of the software is getting worse and worse with continuous modification, so that it is impossible to continue to modify.

(2) ignore the requirement link, which brings great risk to software development.

(3) without considering the maintainability of the test and program, and without any documentation, the maintenance of the software is very difficult.

2. Waterfall model (Waterfall Model)

The famous "waterfall model" was put forward by Winston Royce in 1970, and it was the only widely adopted software development model until the early 1980s. In the waterfall model, as shown in the figure, the software life cycle is divided into six basic activities: planning, requirements analysis, software design, programming, software testing and operation and maintenance. and stipulate their fixed order from top to bottom, connecting with each other, like the waterfall, falling step by step. In the waterfall model, the activities of software development are carried out strictly in a linear manner, and the current activity accepts the results of the previous activity and implements the required work content. The work result of the current activity needs to be validated, and if the verification passes, the result will be used as input to the next activity and proceed to the next activity, otherwise the modification will be returned. The waterfall model emphasizes the role of documents and requires careful verification at each stage. However, the linear process of this model is so idealized that it is no longer suitable for modern software development models and has almost been abandoned by the industry. the main problems are:

(1) the division of each stage is completely fixed, and a large number of documents are produced between the stages, which greatly increases the workload.

(2) because the development model is linear, users will not see the development results until the end of the whole process, thus increasing the risk of development.

(3) early errors may not be found until the testing phase in the later stage of development, which will lead to serious consequences.

We should realize that "linearity" is the easiest way for people to master and skillfully apply it. When people encounter a complex "non-linear" problem, they always do everything possible 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 complex, while a single subroutine is always simple and can be implemented in a linear way, otherwise the work will be too tiring. Linearity is a kind of simplicity, simplicity is beauty. When we understand the spirit of linearity, we should not rigidly apply the appearance of the linear model, but should use it. For example, the incremental module is essentially a piecewise linear model, while the spiral model is a continuous curved linear model, and the shadow of the linear model can also be found in other models.

3. Rapid prototyping model (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. Users or customers evaluate the prototype and further refine the requirements of the software to be developed. By gradually adjusting the prototype to meet the customer's requirements, the developer can determine what the customer's real needs are; the second step is to develop customer-satisfied software products on the basis of the first step. Obviously, the rapid prototyping method can overcome the shortcomings of the waterfall model, reduce the development risk caused by unclear software requirements, and has a significant effect. The key to rapid prototyping is to build a software prototype as quickly as possible, and once the customer's real needs are determined, the prototype will be discarded. Therefore, the internal structure of the prototype system is not important, it is important that the prototype must be quickly established and then quickly modified to reflect the needs of customers.

4. Incremental model (Incremental Model)

Incremental model (Incremental Model) is also called evolution model. Like building buildings, software is built step by step. In the incremental model, software is designed, implemented, integrated and tested as a series of incremental components, each of which is composed of code fragments formed by a variety of interactive modules to provide specific functions. The incremental model does not deliver a complete runnable product at each stage, but a runnable product that meets a subset of customer needs. The whole product is divided into several components, and the developer delivers the product one by one. The advantage of this is that the software development can better adapt to the change, and the customer can constantly see the developed software, thus reducing the development risk. However, the incremental model also has the following shortcomings:

The main contents are as follows: (1) because each component is gradually incorporated into the existing software architecture, the addition of components must not destroy the constructed 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 the incremental model can make its ability to adapt to this change much better than the waterfall model and rapid prototyping model, but it is also easy to degenerate into a model that changes while doing, so that the control of the software process loses its integrity. When using the incremental model, the first increment is often the core product that implements the basic requirements. After the core product is delivered to users, the next incremental development plan is formed after evaluation, which includes the modification of the core product and the release of some new features. This process is repeated after each incremental release until the final perfect product is produced. For example, use incremental models to develop word processing software. It can be considered that the first incremental release has basic file management, editing and document generation functions, the second incremental release has more perfect editing and document generation functions, and the third increment implements spelling and grammar checking functions. the fourth increment completes advanced page layout functions.

5. Helix model (Spiral Model)

In 1988, Barry Boehm officially published the "Spiral Model" of software system development, which combines the waterfall model and the rapid prototyping model, emphasizes the risk analysis ignored by other models, and is especially suitable for large and complex systems. As shown in the figure, the spiral model iterates several 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 plan, and clarify 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: implementation of software development and verification

(4) customer evaluation: evaluate the development work, make corrective suggestions, and make the next step plan. The spiral model is risk-driven, emphasizes options and constraints to support software reuse, and helps to integrate software quality into product development as a special goal. However, the helix model also has certain limitations, as follows:

The main results are as follows: (1) the spiral model emphasizes risk analysis, but it is not easy to require 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 the implementation of risk analysis will greatly affect the profits of the project, then risk analysis is meaningless, so the spiral model is only suitable for large-scale software projects.

(3) Software developers should be good at finding possible risks and analyzing them accurately, otherwise they will bring more risks. First of all, a stage is to determine the goals of this stage, to complete the choice of these goals and their constraints, and then analyze the development strategy of the scheme from the perspective of risk, trying to eliminate all kinds of potential risks, sometimes through the construction of prototypes. If some risks cannot be eliminated, the solution will be terminated immediately, otherwise the next development step will be initiated. Finally, evaluate the results of this stage and design the next stage.

6. Fountain model (fountain model)

Fountain model (fountain model) (also known as object-oriented lifetime model, OO model) fountain model has more incremental and iterative properties than the traditional structured lifetime. Each stage of the lifetime can overlap and repeat many times, and sub-lifetimes can be embedded in the whole lifetime of the project. Just like water sprayed up and down, 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 certain features of the software at a high level. and the software defined by the developer is automatically generated into source code. This approach requires the support of the fourth Generation language (4GL). Unlike third-generation languages, 4GL is characterized by an extremely friendly user interface that can be used by even untrained non-professional programmers to write programs; it is a declarative, interactive, and non-procedural programming language. 4GL also has efficient program code, intelligent default assumptions, a complete database and an application generator. At present, the popular 4GL in the market (such as Foxpro, etc.) have the above characteristics in varying degrees. However, at present, 4GL is mainly limited to the development of small and medium-sized applications of transaction information systems.

8. Hybrid model (hybrid model)

Hybrid model (hybrid model) process development model, also known as hybrid model (hybrid model), or metamodel (meta-model), combines several different models into a hybrid model, which allows a project to develop along the most effective path, which is called 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 choose a software development model that is suitable for the organization and should change with the specific product features currently under development to reduce the shortcomings of the selected model and make full use of its advantages. the following table lists the advantages and disadvantages of several common models. Advantages and disadvantages of various models: model advantages and disadvantages waterfall model document-driven system may not meet customer needs rapid prototyping model attention to meet customer requirements may lead to poor system design and inefficiency, it is difficult to maintain incremental model development, early feedback and timely, easy to maintain requires open architecture, may be poorly designed, inefficient, risk-driven risk analysts need to be experienced and fully trained

9. RUP model (iterative model)

RUP (Rational Unified Process) model is a set of development process model proposed by Rational Company. It is a general business process of object-oriented software engineering. It describes a series of related software engineering processes, which have the same structure, that is, the same process architecture. RUP provides a normative approach to assigning tasks and responsibilities among development organizations, with the goal of ensuring that high-quality software that meets the needs of end users is developed within a predictable schedule and budget. RUP has two axes, one of which is the time axis, which is dynamic. The other axis is the workflow axis, which is static. On the timeline, RUP is divided into four phases: the initial phase, the elaboration phase, the construction phase, and the release phase. The concept of iteration is used in each stage. On the workflow axis, RUP designs six core workflows and three core supporting workflows. The core workflow axis includes: business modeling workflow, requirements workflow, analysis and design workflow, implementation workflow, test workflow and release workflow. The core supporting workflow includes: environment workflow, project management workflow and configuration and change management workflow. RUP brings together the best experiences from many aspects of modern software development and provides a flexible form to meet the needs of various projects and organizations. As a business model, it has very detailed process guidance and templates. But at the same time, because the model is more complex, it costs a lot of money to master the model. In particular, it puts forward higher requirements for project managers. It has the following characteristics:

(1) incremental iteration, each iteration follows the waterfall model, which can control and solve the risk in the early stage.

(2) the complexity of the model requires the project manager to have strong management ability.

10. IPD model

IPD (Integrated Product Development) process is a set of integrated product development process proposed by IBM, which is very suitable for complex large-scale development projects, especially those involving the combination of software and hardware. From the point of view of the whole product, IPD takes into account all the processes from system engineering, research and development (hardware, software, structural industrial design, testing, data development, etc.), manufacturing, finance to market, procurement, technical support, etc. Is an end-to-end process. The IPD process is divided into six stages (concept phase, planning phase, development phase, verification phase, release phase and life cycle phase), four decision evaluation points (concept stage decision review point, plan stage decision evaluation point, availability decision evaluation point and life cycle end decision review point) and six technical evaluation points. The IPD process is a phased model with the shadow of a waterfall model. The model uses comprehensive and complex processes to decompose a large and complex system and reduce risk. To some extent, the model is to improve the quality of the whole product and gain market share through process cost. Because the process does not define a mechanism for process fallback, it is not suitable for projects where requirements change frequently. And for some small projects, it is not very suitable to use this process.

These are all the contents of the article "what are the common software development models on the Internet?" Thank you for reading! I believe we all have a certain understanding, hope to share the content to help you, if you want to learn more knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.