Software Development Lifecycle
The Software Development Life Cycle (SDLC) refers to a methodology with clearly defined processes for creating high-quality software. The SDLC aims to produce high-quality software that meets or exceeds customer expectations, reaches completion within times and cost estimates. Such a process produces software with the highest quality and lowest cost in the shortest time possible.
It’s important to know that there is a strong focus on the testing phase. As the SDLC is a repetitive methodology, you have to ensure code quality at every cycle. Many organizations tend to spend few efforts on testing while a stronger focus on testing can save them a lot of rework, time, and money.
Let us now look at individual stages of Software Development Life Cycle
Stage 1: Planning and Requirement Analysis
Before we start elaborating on the topic, let us look at what happens if this step is improperly carried out.
The problem is that everybody from executive level to developer level, everybody has their own version of perfect. It is important to involve stakeholders and senior members of the team with inputs from the customer, the sales department, market surveys, and domain experts in the industry. This information is then used to plan the basic project approach and to conduct product feasibility studies in the economical, operational, and technical areas when all requirements are collected.
How to gather requirements?
- Establish Project Goals and Objectives Early
This step can feel redundant: of course, we know why we’re doing this project…don’t we? Even if you think you know, write it down, and get your stakeholders to sign off on it. Without clearly stated goals and objectives, you are lacking a framework to guide future decision-making.
- Document Every Requirement
It sounds obvious, but making sure that you are taking detailed notes during your stakeholder interviews is a powerful step in successful requirements gathering. And it’s not enough to just write everything down, as you’ll see in the point below.
- Be Transparent with Requirements Documentation
Sure, you understand the requirements. And your stakeholders understand the requirements. But do your stakeholders understand your understanding of the requirements? After every meeting, go through your notes and clean them up – then share them with the project team, including the stakeholders. This transparency not only helps make sure everyone’s on the same page, but it also fosters a sense of project buy-in all the way through your project, beginning with the business requirements. And it circumvents the issue of someone saying “hey, you agreed to X but it’s not here!” 6 weeks into the project. If it’s not in the notes, it didn’t happen.
- Talk To The Right Stakeholders and Users
A project can often have “hidden” stakeholders. Ask probing questions in your kickoff and initial meetings to try and get to who the real users are. Often those people are not going to be the main decision-makers, but their buy-in is essential to a successful project. However, you also need to be clear that you do not get mixed up from different voices and too many opinions.
- Don’t Make Assumptions About Requirements
Don’t assume that you understand everything, even if it seems obvious. A seemingly simple requirement such as “we want a blog” can mask all sorts of underlying assumptions, requirements, etc. What are the fields for a blog post? How are authors managed? Categories? How are the posts displayed? Are they aggregated into an archive? Is there an RSS feed? Don’t rely on assumptions.
- Practice Active Listening
Making someone feel heard is one of the greatest things you can do for them. But it goes beyond just listening to what they say – you also need to listen to what they don’t say, and how they say things, and read their body language, etc. Stop planning on what to say next and actually listen. This is called active listening and it’s a key component of successful requirements gathering. Don’t assume that you’re always getting the whole story – listen for little cues that reveal pain points, desires, unstated goals, and assumptions.
Stage 2: Defining Requirements
“What do we want?” In this stage of the SDLC, the team determines the cost and resources required for implementing the analyzed requirements. It also details the risks involved and provides sub-plans for softening those risks.
In other words, the team should determine the feasibility of the project and how they can implement the project successfully with the lowest risk in mind.
Once the requirement analysis phase is completed the next step is to define and document software needs. This process is conducted with the help of the 'Software Requirement Specification' document also known as the 'SRS' document. It includes everything which should be designed and developed during the project life cycle.
There are mainly five types of feasibilities checks:
- Economic: Can we complete the project within the budget or not?
- Legal: Can we handle this project as cyber law and another regulatory framework/compliances?
- Operation feasibility: Can we create operations that are expected by the client?
- Technical: Need to check whether the current computer system can support the software
- Schedule: Decide that the project can be completed within the given schedule or not.
How to write a Software Requirement Specification (SRS) document?
A typical SRS includes:
- A purpose
- An overall description
- Specific requirements
If you’re creating this yourself, here’s what your outline might look like:
1.2 Intended Audience
1.3 Intended Use
2. Overall Description
2.1 User Needs
2.2 Assumptions and Dependencies
3. System Features and Requirements
3.1 Functional Requirements
3.2 External Interface Requirements
3.3 System Features
3.4 Nonfunctional Requirements
Stage 3: Designing the Product Architecture
SRS is the reference for product architects to come out with the best architecture for the product to be developed. Based on the requirements specified in SRS, usually, more than one design approach for the product architecture is proposed and documented in a DDS - Design Document Specification.
In this third phase, the system and software design documents are prepared as per the requirement specification document. This helps define the overall system architecture.
This design phase serves as input for the next phase of the model.
There are two kinds of design documents developed in this phase:
High-Level Design (HLD)
- Brief description and name of each module
- An outline about the functionality of every module
- Interface relationship and dependencies between modules
- Database tables identified along with their key elements
- Complete architecture diagrams along with technology details
- Functional logic of the modules
- Database tables, which include type and size
- Complete detail of the interface
- Addresses all types of dependency issues
- Listing of error messages
- Complete input and outputs for every module
Stage 4: Building or Developing the Product
Once the system design phase is over, the next phase is coding. In this phase, developers start to build the entire system by writing code using the chosen programming language. In the coding phase, tasks are divided into units or modules and assigned to the various developers. It is the longest phase of the Software Development Life Cycle process.
In this phase, developers need to follow certain predefined coding guidelines. They also need to use programming tools like compiler, interpreters, debugger to generate and implement the code. Developers must follow the coding guidelines defined by their organization and programming tools like compilers, interpreters, debuggers, etc. are used to generate the code.
Stage 5: Testing the Product
This stage is usually a subset of all the stages as in the modern SDLC models, the testing activities are mostly involved in all the stages of SDLC. However, this stage refers to the testing only stage of the product where product defects are reported, tracked, fixed and retested, until the product reaches the quality standards defined in the SRS.
Once the software is complete, it is deployed in the testing environment. The testing team starts testing the functionality of the entire system. This is done to verify that the entire application works according to the customer's requirement.
During this phase, QA and the testing team may find some bugs/defects which they communicate to developers. The development team fixes the bug and sends it back to QA for a re-test. This process continues until the software is bug-free, stable, and working according to the business needs of that system.
Stage 6: Deployment in the Market and Maintenance
Once the software testing phase is over and no bugs or errors left in the system then the final deployment process starts. Based on the feedback given by the project manager, the final software is released and checked for deployment issues if any.
Once the system is deployed, and customers start using the developed system, the following 3 activities occur:
- Bug fixing - bugs are reported because of some scenarios which are not tested at all
- Upgrade - Upgrading the application to the newer versions of the Software
- Enhancement - Adding some new features into the existing software
The main focus of this SDLC phase is to ensure that needs continue to be met and that the system continues to perform as per the specification mentioned in the first phase.
Based on the feedback, the product may be released as it is or with suggested enhancements in the targeting market segment. After the product is released in the market, its maintenance is done for the existing customer base.
Other SDLC Models
- Waterfall Model
The waterfall is a widely accepted SDLC model. In this approach, the whole process of software development is divided into various phases of SDLC. In this SDLC model, the outcome of one phase acts as the input for the next phase.
This SDLC model is documentation-intensive, with earlier phases documenting what needs to be performed in the subsequent phases.
- Incremental Model
The incremental model is not a separate model. It is essentially a series of waterfall cycles. The requirements are divided into groups at the start of the project. For each group, the SDLC model is followed to develop software. The SDLC process is repeated, with each release adding more functionality until all requirements are met. In this method, every cycle act as the maintenance phase for the previous software release. Modification to the incremental model allows development cycles to overlap. After that subsequent cycle may begin before the previous cycle is complete.
- Spiral Model
The spiral model is a risk-driven process model. This SDLC model helps the team to adopt elements of one or more process models like a waterfall, incremental, waterfall, etc.
This model adopts the best features of the prototyping model and the waterfall model. The spiral methodology is a combination of rapid prototyping and concurrency in design and development activities.
In this type of SDLC model testing and development, the phase is planned in parallel. So, there are verification phases of SDLC on the side and the validation phase on the other side. V-Model joins by Coding phase.
- Big Bang Model
The Big bang model is focusing on all types of resources in software development and coding, with no or very little planning. The requirements are understood and implemented when they come.
This model works best for small projects with smaller size development teams that are working together. It is also useful for academic software development projects. It is an ideal model where requirements are either unknown or the final release date is not given.
All of this information can be a bit overwhelming to start, however, do not forget that we live in an information age where all the information is available in a click of a button. However, if you require professional support and consultancy, Silk Innovation provides you with high-quality services that will help you launch the perfect product in the market meticulously following the Software Development Life Cycle (SDLC).