What Is the Systems Development Life Cycle?

The software life cycle (SDLC, software life cycle) is the life cycle of the software from its generation until its retirement. There are problem definitions, feasibility analysis, general descriptions, system design, coding, debugging and testing, acceptance and operation, maintenance and upgrade to obsolescence. At this stage, this time-based thinking method is a ideological principle in software engineering, that is, step by step and step by step. Each stage must be defined, worked, reviewed, and documented for communication or reference for improvement. The quality of the software. But with the maturity of new object-oriented design methods and technologies, the guiding significance of software life cycle design methods is gradually diminishing.
Synonym system development life cycle generally refers to software life cycle

The software life cycle (SDLC, software life cycle) is the life cycle of the software from its generation until its retirement. There are problem definitions, feasibility analysis, overall description, system design, coding, debugging and testing, acceptance and operation, maintenance and upgrade to obsolescence At this stage, this time-based thinking method is a ideological principle in software engineering, that is, step by step and step by step. Each stage must be defined, worked, reviewed, and documented for communication or reference for improvement. The quality of the software. But with the maturity of new object-oriented design methods and technologies, the guiding significance of software life cycle design methods is gradually diminishing.

Chinese name: Software life cycle
Foreign name: Systems Development Life Cycle
Alias: Software life cycle or system development life cycle

Method of thinking: A thought principle in software engineering
Use: Determine software development goals and their feasibility
Concept: The life cycle of the software until its retirement

Software life cycle overview

Introduction to Software Life Cycle

Software life cycle The software life cycle is also called software life cycle. It refers to the entire process from the formation of the concept of development software, after the software developed is used, until the value of use is lost.

Generally speaking, the entire life cycle includes three periods of planning (definition), development, and operation (maintenance), and each period is divided into several phases. Each stage has a clear task, which makes it easy to control and manage large-scale, complex structures and complex software development.

Software Life Cycle Model

A model that describes how various activities are performed during software development. A simplified abstract description of a software engineering process.

Waterfall model

Evolutionary model

Spiral model

Fountain model

Incremental model

Software life cycle life cycle stages

The software life cycle generally includes the following stages:

Software life cycle · Software planning and feasibility study (problem definition, feasibility study)

·demand analysis

· Software design (summary design and detailed design)

·coding

·software test

Software life cycle · Operation and maintenance

Software life cycle life cycle division

The tasks of each phase are relatively independent of each other as much as possible, and the nature of each task of the same phase is as same as possible, thereby reducing the complexity of the tasks of each phase, simplifying the connection between different phases, and facilitating the organization and management of the software development process.

Software Life Cycle Life Cycle Baseline

Functional baseline

Functional baseline refers to the formal review and approval of system design specifications at the end of the system analysis and software definition phase

Software life cycle The specification of the development system; or the specification of the software system to be developed as stipulated in the agreement or contract signed by both the project entrusting unit and the project undertaker; The specification of the software system to be developed as specified in the project task book. A functional baseline is an initially approved functional configuration identification.

Assigned baseline

An assigned baseline is a specification of a software requirement that has been formally reviewed and approved at the end of the software requirements analysis phase. The assignment baseline is the initially approved assignment configuration ID.

Product baseline

Product baseline refers to the specification of all configuration items of the developed software product after formal review and approval at the end of the software assembly and system testing phases. A product baseline is an initially approved product configuration identification.

SDLC Six phases of the software life cycle SDLC

Software life cycle definition and planning

At this stage, the software developer and the demander discuss together to determine the software development goals and feasibility.

Software life cycle requirements analysis

When it is determined that software development is feasible, detailed analysis is performed on each function that the software needs to implement. The requirements analysis phase is a very important phase. When this phase is done well, it will lay a good foundation for the success of the entire software development project. "The only constant is the change itself." The same requirements are constantly changing and in-depth throughout the software development process, so we must develop a demand change plan to cope with such changes to protect the smooth progress of the project.

Software life cycle

Software life cycle software design

At this stage, the entire software system is designed based on the results of the requirements analysis, such as system framework design, database design, and so on. Software design is generally divided into overall design and detailed design. Good software design will lay a good foundation for writing software programs.

Software life cycle program coding

This stage is the transformation of the results of software design into computer-executable program code. It is necessary to formulate a uniform code in the program, which complies with the standard writing specifications. In order to ensure the readability of the program, easy maintenance, and improve the operating efficiency of the program.

Software life cycle

Software life cycle software testing

After the software design is completed, it must undergo rigorous testing to find out and correct the problems in the software during the entire design process. The whole test process is divided into three stages: unit test, assembly test and system test. There are two main testing methods: white box testing and black box testing. During the testing process, a detailed test plan needs to be established and tested in strict accordance with the test plan to reduce the randomness of the test.

Software life cycle operation and maintenance

Software maintenance is the longest duration of the software life cycle. After the software development is completed and put into use, due to various reasons, the software cannot continue to adapt to user requirements. To extend the life of the software, it is necessary to maintain the software. software

Software life cycle The maintenance includes two aspects: corrective maintenance and improved maintenance.

Software Life Cycle Model

Any software starts with the most vague concepts: designing office processes for a company; designing a business letter printing system and putting it on the market. This concept is unclear, but it is a prototype of the highest-level business requirements. This concept is accompanied by a purpose, such as in a "bank deposit system" to improve the efficiency of work. This purpose will become the core idea of the system and the criterion for the success or failure of the system. In 1999, a lot of OA systems were installed in government departments. People who have learned a bit of Lotus Notes have made a fortune (not to mention IBM), but it is more common that many government departments have not changed the original processing model. Instead, it adds a set of automated processes. The original intention to improve productivity has led to completely different results. Is such software successful?

From the moment the concept is proposed, the software product enters the software life cycle. After going through requirements, analysis, design, implementation, and deployment, the software will be used and enter the maintenance phase, until it eventually dies due to lack of maintenance costs. Such a process is called the "Life Cycle Model".

Typical life cycle models include waterfall models, rapid prototyping models, and iterative models. The Waterfall Model was first proposed by Royce. The model is known for resembling a waterfall. In this model, the requirements are first identified and validated by the customer and the SQA team. Then formulate the specifications, and after passing the verification, enter the planning stage ... It can be seen that the most important point in the waterfall model is that only when the documentation of one stage has been prepared and approved by the SQA team can the next stage be entered. In this way, the waterfall model provides mandatory documentation to ensure that each stage can complete the task well. But in reality it is often difficult to do, because the entire model is almost document-driven, which is difficult for non-professional users to read and understand. Imagine that when you go to buy clothes, the salesperson shows you a thick specification of the clothes, how do you feel. Although the waterfall model has many good ideas to draw on, it has inherent flaws in process capability.

Iterative model The iterative model is a periodic model recommended by RUP and is the basis of our discussion in this series of articles. In RUP, iteration is defined as: iteration includes all development activities that produce a product release (stable, executable product version) and all other peripheral elements necessary to use the release. So, to a certain extent, development iteration is a process that goes through all workflows at once: (at least including) requirements workflow, analysis and design workflow, implementation workflow, and test workflow. In essence, it resembles a small waterfall project. RUP believes that all phases (requirements and others) can be broken down into iterations. Each iteration produces a product that can be released, which is a subset of the final product. The idea of iteration is shown in the figure above.

The biggest difference between iteration and waterfall is the exposure time of the risk. "Any project involves a certain amount of risk. If you can ensure that risks are avoided early in the life cycle, your plan will naturally become more precise. There are many risks that are not discovered until you are ready to integrate the system. Regardless of the development team's experience It is impossible to predict all the risks. "(RUP) The difference between the two is shown below:

Software life cycle Due to the characteristics of the waterfall model (documents are the main body), many problems will be exposed at the end. The risks to solve these problems are huge. "In an iterative lifecycle, you need to choose new incremental content to develop in an iteration based on a list of major risks. A test executable is generated each time an iteration is completed, so you can verify if it has been reduced Target risk. "(RUP)

The Rapid Prototype model is another model I like to adopt. The rapid prototyping model is functionally equivalent to a subset of the product. Note that this is functional. The disadvantage of the waterfall model is that it is not intuitive enough, and the rapid prototyping method solves this problem. Generally speaking, according to the needs of customers, we can solve the most urgent needs of users in a short time and complete a product that can be demonstrated. This product only implements some of the functions (most important). Its most important purpose is to determine the real needs of users. In my experience, this method is very effective. Users who did not have the slightest idea about computers are often vocal in front of your prototype, and some of the ideas make you very surprised. After getting the user's needs, the prototype will be abandoned. Because the speed of prototype development is very fast, there is almost no design consideration. If you keep the prototype, it will pay a great price for it in subsequent development. As for retaining the prototype, there is also a model called the incremental model that does this, but this model is not acceptable to everyone and is outside our discussion.

The above models all have their own unique ideas. In fact, software organizations rarely say which model is adopted by standard. There is still a big difference between model and utility.

The development of software life cycle model actually reflects the development of software engineering theory. At the earliest times, the software life cycle was in a disorderly and chaotic situation. In order to be able to control the software development process, some people strictly divide software development into multiple different stages, and add rigorous review between the stages. This is the reason for the waterfall model. The waterfall model reflects one's hope for software processes: strict control and quality assurance. Unfortunately, reality is often cruel. The waterfall model simply fails to meet this demanding requirement, because software processes are often difficult to predict. Instead, it caused other negative effects, such as a large number of documents and cumbersome approvals. So people began to try to improve or replace the waterfall method with other methods. For example, subdividing the process to increase the predictability of the process.