Software Development Life Cycle
Software Development Life Cycle is a well defined, Structured Sequence of stages in software engineering to develop the software product. It is a series of steps through which software is produced. It can be used by system analysts, designers, and developers to plan and implement the application. This helps in on-time delivery of the product.
Purpose of the Software Development Life Cycle
- Leads to good software
- Reduces Risk
- Enable Visibility
- It provides us with a structure in which to work
- delivers high-quality product
- Requirement Gathering & Analysis: We collect all relevant information regarding products from customers to build a product as per the customer’s expectations during this phase. Before starting building the project, we should have all knowledge about the product. Once the requirement is done, the SRS(Software Requirement Specification) document is created.
- Design: In this phase, with the Help of SRS, Software Architecture is derived.
- Coding: When a developer gets Design, he starts coding. The software design is translated into source code.
- Testing: When coding is completed, we start this phase. In this phase, the developed software is tested, and if there were any defects, then that was assigned to developers to get them fixed.
- Deployment: Once the product is tested, User acceptance testing is done on the customer’s expectations. In this phase, customers and developers get the Testing done. If a customer finds that the application is working as expected, and there is no error or defect in the application, the customer accepts that software and makes that software live.
- Maintenance: After User acceptance testing, the next phase is Maintenance. In this phase, if any issue comes in the product or the customer needs any enhancement, the developers fix it. The software is maintained timely by updating the code according to the changes required by the customer.
- Waterfall model
- V-Shaped model
- Spiral model
- Big bang model
- Agile Approach
Waterfall Model is the very first model in SDLC. All the phases of SDLC will linearly function one after another. When the first phase is finished, then only the second phase will start.
In this phase, the outcome of the first phase is the input for the second phase.
- Requirements are gathered, and analysis is done. Once the requirements are collected, and Business case Documentation is prepared, then we can proceed to the next phase.
- In this phase, Software, architecture, and Design are prepared, and SRS(Software Requirement Specification) is created.
- Development is the stable phase where the developer starts coding the software. In this phase, all coding is done according to the instructions received.
- In this phase, the developed code is tested thoroughly to detect defects in the software. The programmer prepares the test plan to check that every function is executable as expected.
- After receiving a “pass” from the testing phase, the software is said to be ready to be released. It can be released.
- The world keeps changing, and as a result of this enhancement into the software product is essential. In this phase, we ensure a customer that he can request to makes changes to their application when required, and if any issue comes in the application, then that is fixed by the developers.
- Simplest model and Easy to understand
- All phases are done step by step.
- Easy to manage
- This model requires more time.
- this approach is not suitable for short duration projects
- You cannot move to the next phase until the previous stage is completed.
- If a customer sends requirements between the software development, then we need to start again from the first phase. It leads to higher costs and becomes more time consuming as we have to start from the first phase.
The waterfall model’s major drawback is we move to the next step only when the previous one is finished, and if any error comes, we cannot go back to the last step. V-Shaped, The model provides means of Testing of Software at each stage in a reverse manner. This model is also known as the verification and validation model.
- Requirement Analysis: In this Phase, customer requirements are gathered and analyzed. Verification activities include reviewing the requirements. This phase involves clear communication with the customer to understand his expectation and needs.
- System Design: Once we understand customer requirements and are very clear with the customer expectation, then we proceed to the next step. In this phase, we analyze and understand the proposed system’s business by studying the user requirements document. They figure-out the techniques by which the user requirements can be implemented. If something cannot be implemented, then the user is informed about the issue.
- High-Level Design: In this Phase, Architectural specifications are understood and designed. Usually, more than one technical approach is introduced in this phase, and based on technical and financial feasibility best approach is selected.
- Low-Level Design: In this Phase, actual software components are designed. It defines the actual logic for each component. The developed system is broken into smaller modules, and each of them is explained so that programmer can start coding directly.
- Coding: In this Phase, the developer starts coding, and module design is converted into code by developers. The coding is performed on the coding guidelines and standards.
- Unit Testing: In this Phase, individual components or modules of software are tested. The purpose of unit testing is to validate each module of the software to works as designed. For example, Let’s take the example of a phone. When a company wants to test its phone, then each unit is tested. The camera’s functionality is tested as a unit, and the audio recording is tested as another unit. By using this, each unit is tested separately, which makes Testing easy.
- Integration Testing: It is the process of testing the interface between two modules. For example, software and hardware components combined and tested until the entire system has been integrated. Testers perform integration Testing.
- System Testing: In this phase, the complete system is being tested. The entire system’s functionality is tested in this phase. Most of the software and hardware compatibility issues can be solved during this phase of Testing. It verifies that functional and nonfunctional requirements have been met. It ensures that the expectation of the developed application is completed.
- Acceptance Testing: This is the final phase of Testing. This is performed in the customer’s environment. It uncovers the compatibility issues with the other systems available in the user environment. It verifies that the delivered application meets the user’s requirements, and the application is ready for use in real-time.
- It is a very simple model, and one can understand this easily.
- This approach is perfect for smaller projects.
- Test activities like test designing, planning happens well before coding.
- Defects are found at an early stage of software development.
- This approach is not suitable for complex projects.
- Requirements change in the later stages would cost high.
- No early prototypes of the software are produced.
- Flawed model for long and ongoing projects.
In the next post, we will study about other Software Development life cycle models which are spiral and Iterative model. Here we are posting some important questions. In the next post, we will answer these questions as well.
- What is Software Testing, and why is software Testing required?
- What are verification and validation?
- Write down the difference between user acceptance testing and system testing?
- What is Functional Testing and nonfunctional Testing?
- Explain the different levels of manual Testing?
- What is the difference between defect and failure?
- What is positive and negative Testing?
- Explain Component Testing?
- What are the advantages of manual Testing?
- Explain the defect life cycle.