software development life cycle (SDLC)
The software development life cycle (SDLC) is a framework used in project management to describe the stages and tasks involved in each step of writing and deploying the instructions and data computers use to execute specific tasks. An SDLC model maps the complete software development process from its initial planning through maintenance and eventual retirement and replacement of the completed application.
An important goal of the SDLC is to quickly and efficiently produce high-quality software in a series of phases that are called steps. The number of steps in an SDLC will vary depending on the business and its software product goals. For example, at the most basic level, software is designed, developed, tested and then released. Upon release, the software is maintained until it is discontinued. Typically, there will be between five and seven steps—although there can be more.
Software development life cycle steps
In general, the SDLC process follows these phases:
- Evaluate the existing software. If there is existing software in place, then any deficiencies in that software are identified before its retirement. This can be done by interviewing users and consulting with support personnel, as well as by reviewing metrics gathered through application performance monitoring (APM) tools. This step provides insight into the strengths and weaknesses of the current software and what can be implemented in the new software.
- Plan the new software requirements. Deficiencies in the existing software must be addressed. Moreover, specific proposals are made for improvements, such as new features and functionality. If no previous software is in place, this phase is simply defining the requirements for proposed software. Requirements can include hardware, operating systems, programming and security.
- Design the proposed software. The design phase turns the software specifications into a design plan. Plans are laid out concerning the architecture, hardware, operating systems, programming, communications and security issues.
- Develop the new software. During the development phase, the code is built. Developers must obtain and install new components and programs
- Test the software. The test phase ensures the software works before integration and management. The software should be operating to the original specifications by the end of this stage. The code's structure determines which tests are utilized. For example, the software could be built as a set of microservices instead of a monolith structure, which means the software would not have to be regression tested with further updates or iterations. Software testing is a large step in the SDLC, so many organizations may make testing separate from the develop stage, as done here.
- Put the software into use. Deployment can be accomplished in various ways. Some new software is phased in, according to application or location, to gradually replace an old product. In other cases, the old system is shut down, and users cut over to the new system all at once.
- Monitor the software. The new software should be exhaustively evaluated for performance and stability. Organizations use logs, as well as APM and other metrics-gathering tools, for monitoring. Any concerns should be reported to the development team for remediation in patches or ongoing software maintenance efforts.
Other organizations may include steps for deconstructing, retiring and replacing software as well.
There are a myriad of various SDLC models to choose from when developing software, and the right one depends on the requirements of any given project. Several models can be combined into a hybrid methodology. Documentation is crucial, regardless of the type of SDLC model for a given application, and is usually done in parallel with the development process.
For example, the waterfall model is a linear, sequential approach to the software development life cycle (SDLC) that emphasizes a logical progression of steps. Similar to the way water creates a waterfall by flowing down a creek and over a cliff, once development work in a waterfall model has been completed, it cannot be revisited. The term is often associated with large, monolithic software products developed before the turn of the century. Most developers do not develop code with waterfall now since it is considered unrealistic to finish a piece of code, and not revisit it.
In contrast, the Agile model for SDLC is a more modular and flexible approach. Agile approaches software development in incremental cycles, called sprints. Each sprint is iterative and code is designed to be modular.
Other popular SDLC models include:
- Rapid application development (RAD)- Which was made in response to the downfalls of the waterfall model and focuses on being more adaptive while working on software.
- Joint Application Development (JAD)- Which includes the end-user in the design and development steps through workshops.
- Prototype model- Which requires a working prototype to be made before the development of software is carried out.
- Spiral model- Which combines the waterfall and prototype models.
- Synchronize-and-stabilize model- In which teams work on individual software models. Teams then bring their code together and debug the code.
- V-model- which maps out a flowchart in the form of a V. Business requirements are held in the downward sloping part, the base of the V is the software development, and tests are carried out in the upward slope of the V.
Benefits and challenges of the SDLC
Benefits that come with a well-defined SDLC include:
- Aids in anticipating in possible mistakes.
- Measures progress easily.
- The shorter each software iteration is, the easier testing can become.
- Utilizing sprints in an SDLC model can aid in development speed.
However, if used less optimally, SDLC can come with hindrances such as:
- Some models require more resources than others.
- Not all models are optimal for specific environments.
- If a mistake is made in a planning stage, then it could mean delays in the software development stage.
- Not all models are easily adaptable.
Many advantages are specific to the specific model chosen. To better represent advantages and disadvantages in this way, we can use both waterfall and agile models to compare. Waterfall and agile are often compared SDLC models, as they were the most widely used at different points in time. Waterfall methods have the advantage of being easy to understand, well defined and easy to verify each phase. The waterfall model can also be used in small development teams. However, the waterfall model does not allow for the start of the next phase until the previous one is finished, is not suitable for long term projects and can get expensive if any changes are needed.
Meanwhile, agile enables flexibility, while each iteration is separated by sprints and is well suited for both long and short term projects. However, agile is high in development cost, needs skilled teams, and can be exhausting for teams to work on sprints.