Kopiering til utklippstavlen mislyktes. Prøv igjen etter å ha justert tillatelsene dine.
Kopiert til utklippstavlen.
How you can use the software development life cycle to build great products
So you've got an idea for a piece of software. Maybe it's a SaaS tool. Maybe it's a mobile app . Whatever your idea, once you start trying to get it built, you're likely to run into the concept of the "software development life cycle."
This isn't just programmer speak. It's actually a framework that can help you build great products. And without this framework, your project could quickly run off course.
So what is the software development life cycle?
The software development life cycle, or SDLC for short, is a framework for dividing different phases of the software development process.
The SDLC is designed to produce the highest quality software in the shortest amount of time at minimum cost. The different stages of the software development life cycle allow developers and managers to have complete transparency over the entire development process across all teams.
Why is the software development life cycle important
The SLDC is important for a couple of reasons. First, it breaks the task of creating a piece of software into a logical order that makes sure everyone working on the project is aligned. Most importantly, it also ensures the software actually works when it gets into the hands of customers.
Second — and this is really important — it reinforces the concept of a life cycle . In other words, it's a framework for building a tool that you can keep improving. Building software isn't a "one and done" task. You don't just build something, hand it to users and hope for the best. After all, you'd probably be pretty irate if you still had to write every document on Word 1.0.
Instead, the cyclical nature of the SLDC means you're constantly improving on your product, and those improvements are happening in a structured and efficient way.
What are the phases of the software development life cycle?
The software development cycle is divided into 7 phases:
Phase 1: Requirements identification
This is when the software idea is born. Once you have an idea, you create a list of requirements to determine what the software does, who it's for, what they need and the scope of building it. You'll also conduct competitor analysis to determine which features need to be further developed, and then add the findings to the list of requirements.
To guide the brainstorming process, make two columns titled "what we want" and "what we don't want". Populate both with as many ideas as possible, and choose the best to compose the final list.
Once you've got this list, you can determine what resources you'll need to complete the project.
Phase 2: Create an SRS document
WIth the final list of requirements complete, the next step is to expand on it in a Software Requirements Specifications Document (SRS document).
Your SRS document should answer the following questions:
What's the purpose of the software? What is the software? What are the requirements of the build? Can the project be completed within the set budget? Can the project be completed within the given timeline?
You can use the outline below to structure your SRS document, or use a template .
1.1 Software purpose
1.2 Target audience
1.3 User needs
1.5 Definitions 2. Product description
2.1 Key constraints
3. Software features and requirements
3.1 Functional requirements
3.2 External interface requirements
3.3 Operational requirements
3.4 Software features
3.5 Nonfunctional requirements
3.6 Database requirements
3.7 Functional hierarchy
4 Project budget
4.1 Project timeline
4.2 List of teams
4.3 Team responsibilities
4.4 Legal concerns
4.5 Legal requirements
4.7 Future upgrades
Phase 3: Design
In this phase, all the software specifications are outlined in a design framework to define the software architecture. In other words, this phase determines the actual structure of your software.
Design details are broken down into two tiers:
High level design (HLD)
Module descriptions Outline of module functions Architecture diagrams Technology and functionality details
Low level design (LLD)
Deeper description of each module Module functionality and key features Input and output details of each module Interface details Integration details List of all error messages and suggested solutions
If you need a hand creating software architecture visualizations, have a look at this video:
High level design details give a concise overview to your team for quick approval. Once these high level details are approved, you can create the low level design details that go into more depth.
It's important for lead developers to be part of these meetings so they can give feedback on design suggestions, and also communicate the finalized details to their teams.
This phase is an opportunity for the team to suggest any design changes. Everyone needs to be aligned on the final design plan before moving onto stage 4.
Phase 4: Software build
In this phase, the final design is developed. If multiple teams are working on the build, each team is assigned their respective coding component.
This is the most time-consuming phase. But if you've put thought and attention into the previous three phases, you should minimize delays. Developer team leads should also instantly communicate any build schedule changes to the team. Effective communication is the key to a highly efficient software development lifecycle.
Phase 5: Testing the software
When the build is complete, the code is deployed in the testing environment to check whether the software operates the way it's meant to. This is the time to find and fix any bugs. Quality assurance teams should test the code rigorously in the testing environment, and only move on to the next phase when the software is completely free of errors.
Phase 6: Deployment
The software is deployed and tested by users outside of the development team. This could include stakeholders or a set of beta test customers. Feedback is collected from users and suggested changes are sent to the development team for further product adjustments.
After every update, the product is re-deployed to users for further feedback.
Phase 7: Maintenance
In the maintenance stage, the software is released to a wider audience and continuously monitored for bugs. New features are still added to the product in response to user feedback. The primary focus of this final stage is to ensure the product continues to meet its intended requirements.
The SDLC framework we've talked about so far it the traditional model, but there are different frameworks used by different developers. Let's have a look at some of the most popular.
The Waterfall Method isn't a whole lot different than the traditional SDLC structure. It's broken into these five stages:
The element that's missing from the Waterfall model is a user feedback loop. This means it doesn't take into account the process of changing the software based on actual user requirements. But there are some more flexible SDLC models that include the user feedback loop.
Agile is a methodology for rapidly completing large projects by breaking them up into smaller stages.
When applied to software development, the Agile methodology results in frequent deployment of software updates rather than just a single delivery when the complete build is finished (the Waterfall model).
At each software deployment stage, the software is released to a set of test users and their feedback is used to direct any design changes.
Because the software doesn't have to be completely developed before being deployed to customers, it's much more accommodating to design changes. It results in an end product that's designed exactly the way the users want it, and also up to date with the latest tech trends.
The downside of the Agile methodology is that user feedback could sway development in an unwanted direction, so the final product may differ entirely from the initial design.
To prevent this from happening, project managers should use user feedback to navigate the project in its intended direction rather than as an excuse to deviate course. The end product may include added features, but overall it shouldn't differ from the initial core design.
You can apply Agile methodology through any of the following models:
The Iterative model is driven by repetitive, rapid developments. New software versions are rapidly developed at low cost, and then tested to identify any necessary improvements. These improvements are then implemented in the next software update, and the cycle continues.
Software is initially deployed at a very basic level (MVP), and additional layers of complexity are added with each successive iteration.
The Iterative process follows these steps:
1. Requirements planning
A list of requirements is created for the proposed software design. If the software hasn't been deployed yet, a set of requirements is produced for the most basic core functionality of the intended software.
2. Design and analysis
A design framework is created to meet the requirements outlined in the preceding step.
Software design specifications are developed. If this is an iterative implementation, the new build update is incorporated into the existing code
The developed software is evaluated for any additional design changes (by end-users and stakeholders) and then passed back up to the requirement planning stage.
This cycle continues until there are no more design change requests.
The iterative model makes it much easier to identify and fix any design flaws as quickly as possible. It's also very cost-effective, since not all of the final software requirements need to be implemented within the first few iterations.
To manage your software development project with the Iterative Model, use this editable template .
The V-Shaped model is a variation of the Waterfall model where each development stage is verified with testing before proceeding to the next stage.
The V-model breaks down the entire design process into 3 different stages (system, architecture and module). At each development stage, a corresponding verification test is preemptively designed. When the software development phases are completed, the workflow moves back upwards to complete all of the testing phases.
The benefit of planning future tests at each development phase is that it forces developers to run self-directed quality assurance tests on their code in real-time to ensure it passes future testing.
1. Unit test
This test is conducted when the software build is complete. The aim of this test is to identify and eliminate any bugs in the code.
2. Integration test
All software modules are integrated and tested for any communication errors.
3. Systems Test
The entire software is tested from end-to-end. The user's workflow is tested to make sure all processes are executed in a flawless and predictable manner. The functionality and integration of all modules is further tested at this stage.
4. User acceptance test (UAT)
The software is deployed to a set of test-users to test whether the software meets all their requirements. After this final phase of testing is completed, the software can be released for mass distribution.
The V-model is good for small projects with simple requirements. Large, complex projects don't work as well with this model due to the lack of design iteration pathways after each testing phase. The model operates on the assumption that only a single test is required for each development phase, which is rarely the case with high-end software projects.
Big Bang Model
There is little to no planning involved with the Big Band Model. All the requirements are identified and implemented as the software is being coded.
This is a very fast-paced and high-risk approach to software development that's best suited for small personal projects.
If you're a lone developer try to decide on a development project, you could start with the Big Bang Model to identify whether it's within your skillset, and then formally plan the final build with any of the other SDLC models.
Of all the SDLCs, the Spiral Model is most accommodating to design changes. There are four phases of the Spiral Model: identification, design, construction and review.
Each stage of the development life cycle passes through each of the 4 phases before progressing.
Unlike the Iterative Model, with the Spiral Model, software doesn't need to complete an entire cycle before being user-tested. User feedback is gathered instantly at each development stage.
The Spiral Model allows user requirements to be identified, deployed and tested more accurately. It's very cost-effective, only features users who are actually interested in the features implemented, and, like the Iterative Model, there's no need to invest in a perfect software build during the initial stages of development.
Since the development life cycle continues to spiral outwards indefinitely with this model, it's great for long-term and complex projects.
Any of the SDLC models we've discussed will help you plan your next software development project. If your project is funded by investors, the Spiral Model is ideal since any stakeholder concerns can be addressed by continuous user-test data that supports your development efforts.