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

This article mainly introduces what are the common software development models in the computer network, which have a certain reference value. Interested friends can refer to them. I hope you will gain a lot after reading this article. Let the editor take you to know it.

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

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

Software development includes requirements, design, coding, testing and sometimes maintenance phases. The software development model can clearly and intuitively express the whole process of software development, and clearly define the main activities and tasks to be completed, which can be used as the basis of software project work.

For different software systems, we can adopt different development methods, use different programming languages and personnel with different skills to participate in the work, use different management methods and means, and allow the use of different software tools and different software engineering environments.

Typical development model

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 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)

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 "nonlinear" 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 model 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)

Also known as the evolutionary 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 multiple interactive modules that 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 software developed, thus reducing the development risk.

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.

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 greater 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. Evolution model (evolution model)

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

The model can be expressed as: the first iteration (requirements-> Design-> implementation-> Test-> Integration)-> feedback-> the second iteration (requirements-> Design-> implementation-> Test-> Integration)-> feedback->.

That is, according to the basic needs of users, an initial runnable version of the software is constructed through rapid analysis, which is usually called a prototype, and then the prototype is improved according to the opinions and suggestions put forward by users in the process of using the prototype. get a new version of the prototype. Repeat this process, and finally get the software products that satisfy the users. The development process using the evolution model is actually the process of gradually evolving from the initial prototype to the final software product. The evolution model is especially suitable for situations where there is a lack of accurate understanding of software requirements.

7. Fountain model (fountain model)

(also known as object-oriented lifetime model, OO model)

Compared with the traditional structured lifetime, the fountain model has more incremental and iterative properties, each stage of the lifetime can overlap and repeat many times, and the sub-lifetime 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.

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 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. The popular 4GL in the market (such as Foxpro, etc.) have the above characteristics in varying degrees. However, 4GL is mainly limited to the development of small and medium-sized applications of transaction information systems.

9. 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.

10. RAD model

Rapid Application Development (RAD) model is an incremental software development process model. Emphasize a very short development cycle. RAD model is a waterfall model.

A "high-speed" variant of, through the extensive use of reusable components, the use of component-based construction methods to win rapid development. If the requirements are well understood and the scope of the project is constrained, this is followed by data modeling, process modeling, application generation, testing, and iteration. The software process using the RAD model is shown in the figure.

Thank you for reading this article carefully. I hope the article "what are the common software development models in computer networks" shared by the editor will be helpful to everyone? at the same time, I also hope that you will support and pay attention to the industry information channel. more related knowledge is waiting for you to learn!

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.