Software development model

As a programmer, the development process is the best learning process, in the process of development, constantly looking for new solutions, learning new development technology, can better broaden our thinking, let us continue to progress.

Near graduation, to prepare for graduation design, I decided to do an online test system, is expected to be completed by the end of April, it took so long to do this project, mainly because I want to use this project, my university four years, learned, not learned things

Do a re-learning, first stop, software development model.

Software development models (software development model) refer to the entire process of software development, including requirements, design, development (writing code), testing, and even maintenance, which are sometimes included.

The software development model can clearly and intuitively express the whole process of software development, and clearly stipulate the main activities and tasks to be completed, which are used as the basis of software project work.

The main development models are:
1. Waterfall type (Waterfall Model)

Waterfall model divides the software life cycle into planning, requirements analysis, software design, program writing, software testing, operation and maintenance, and so on six basic activities, and stipulates them from top to bottom, one by one complete, such as waterfall water, so called waterfall model.

In the waterfall model, the activities of software development are conducted in a linear manner, and the current activity accepts the work result of the previous activity and the work required to complete the implementation. The work result of the current activity needs to be validated, and if the validation is passed, the result will continue with the next activity as input to the next activity, otherwise the modification is returned.
The waterfall model emphasizes the role of the document and requires careful verification at each stage. However, the linear process of this model is too idealistic, no longer suitable for modern software development model, almost abandoned by the industry, the main problem is:
(1) The division of each stage is completely fixed, the stage produces a large number of documents, greatly increasing the workload;
(2) because the development model is linear, users can only wait until the end of the process to see the development results, thereby increasing the risk of development;
(3) Early errors may not be discovered until the late stages of development, leading to serious consequences.

We should realize that "linearity" is the most easily mastered and skillfully applied method of thinking. When people encounter a complex "non-linear" problem, they always try to decompose or transform it into a series of simple linear problems, and then solve them individually. The whole of a software system may be complex, and a single sub-program is always simple, can be implemented in a linear way, otherwise the work is too tired. Linearity is a kind of brevity, simplicity is beauty. When we grasp the linear spirit, we should not rigidly apply the appearance of the linear model, but should live with it. For example, the incremental model is essentially a piecewise linear model, the spiral model is a successive curved linear model, and the shadow of the linear model can be found in other models.

2. Rapid Prototyping (RAPId Prototype model)

The first step in the rapid model is to build a rapid prototype that enables the interaction between the customer or the future user and the system, the user or customer to evaluate the prototype, further refine the needs of the software to be developed, and by gradually adapting the prototype to meet the needs of the customer, the developer can see the real needs of the customer, The second step can be based on the first step to develop a complete customer satisfaction products.

Obviously, the rapid prototyping method can overcome the shortcomings of the waterfall model, and reduce the development risk due to the unclear requirements of software, which has remarkable effect.
The key to rapid prototyping is to build software prototypes as quickly as possible, and once you have identified the real needs of your customers, the prototypes you build will be discarded. Therefore, the internal structure of the prototype system is not important, it is important to quickly set up prototypes, and then quickly modify the prototype to reflect the needs of customers.

3. Incremental models (Incremental model)

As with building buildings, software is built step-by-step. In an incremental model, software is designed, implemented, integrated, and tested as a series of incremental artifacts, each of which is made up of code fragments that provide specific functionality, formed by a variety of interacting modules.

Incremental models do not deliver a complete product that can be run at each stage, but rather deliver a running product that meets a subset of the customer's needs. As the entire product is broken down into several components, the developer is able to deliver the product individually, and the benefit is that software development can adapt well to change, and customers can constantly see the software being developed, thus reducing the risk of development.

However, the incremental model also has the following drawbacks:

(1) Because each component is gradually merged into the existing software architecture, the component must not break the already constructed part of the system, which requires the software to have an open architecture.

(2) In the development process, the change of demand is unavoidable. The flexibility of the incremental model can make it adapt to the change greatly better than the waterfall model and the rapid prototyping model, but it is also easy to degenerate into a side-by-side modification model, thus the control of software process loses its entirety.
When using an incremental model, the first increment is often the core product that implements the basic requirements. Once the core product is delivered to the user, it is evaluated to form the next incremental development plan, which includes modifications to the core product and release of some new features. This process repeats after each incremental release until the final product is produced.

For example, use the incremental model to develop word processing software. Consider the first incremental release of basic file management, editing, and document generation capabilities, the second incremental release of more sophisticated editing and document generation capabilities, the third incremental implementation of the spelling and grammar checker feature, and the fourth incremental completion of Advanced page layout features.
4. Helical models (Spiral model)

In 1988, Barry Boehm formally published the "Spiral Model" of software system development, combining waterfall models and rapid prototyping models, highlighting risk analysis that other models have overlooked, particularly for large and complex systems. The spiral model has several iterations along the Helix, and the four quadrants in the diagram represent the following activities:

(1) Make a plan: Determine the software objectives, select the implementation plan, clarify the constraints of project development;

(2) Risk Analysis: Analysis and evaluation of the selected program, consider how to identify and eliminate risk;

(3) Implementation of the project: the implementation of software development and validation;

(4) Customer Evaluation: evaluation of development work, the proposed amendments to make the next plan.

The Helix model, driven by risk, emphasizes the option 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 restrictions, as follows: (1) The Helical model emphasizes risk analysis, but it is not easy for many customers to accept and believe this analysis and to make relevant responses, therefore, this model is often adapted to the internal large-scale software development.

(2) If performing risk analysis will significantly affect the profitability of the project, then the risk analysis is meaningless, so 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 they will lead to greater risk  
           a stage is first to determine the objectives of this phase, to complete the selection of these objectives and constraints, and then from a risk perspective analysis of the development strategy of the program, and strive to eliminate the various potential risks, Sometimes it needs to be done by building prototypes. If certain risks cannot be excluded, the scenario terminates immediately, otherwise the next development step is initiated. Finally, evaluate the results of this phase and design the next phase.  
5. Evolutionary models (incremental model)  
        primarily for software development that does not previously fully define requirements. Users can give the core requirements of the system to be developed, and when the core requirements are realized, they can effectively provide feedback to support the final design and implementation of the system. Software developers based on the needs of users, the first development of core systems. When the core system is put into operation, the user tries to finish their work, and puts forward the requirement of refinement system and system capability. The software developer implements the iterative process of development based on user feedback. The first iterative process consists of requirements, design, coding, testing, and integration phases, adding a definable, manageable subset to the entire system.

       Evolution model requires developers to be able to break down the product requirements of a project into different groups for batch cycle development. This grouping is not absolutely arbitrary, but depends on the importance of the function and the impact on the overall design of the infrastructure to make judgments. Experience has indicated that each development cycle takes six weeks to eight weeks for the appropriate length.  
6. Fountain models (Fountain model, object-oriented lifetime models, OO models)        

  fountain model, compared with the traditional structured lifetime, has more increment and iterative properties, each stage of the lifetime can overlap and repeat multiple times, and the lifetime of the project can be embedded in the whole life period. Like water spray can fall down, can fall in the middle, can also fall on the bottom.  
7. Intelligent model (four-generation technology (4GL))          

8. Mixed models (hybrid model)          

Comparison of various models   each software development organization should choose a software development model that is appropriate for the organization, and should evolve with the specific product features currently being developed to reduce the disadvantages of the selected model and take advantage of its advantages, the following table lists the pros and cons of several common models.  
Models             Benefits             disadvantage  

Waterfall Model document-driven system may not meet customer needs

Rapid prototyping model focus on meeting customer needs may lead to poor system design, low efficiency and difficult maintenance

Incremental model development Early feedback timely, easy maintenance requires open architecture, may be poorly designed, inefficient

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

These so-called models do not know whether the application is widespread in real development.

Software development model