What Is a Software Development Life Cycle?
You can look at our terms page to see how the SDLC is generally defined:
“The software development life cycle (SDLC) is a framework defining tasks performed at each step in the software development process. “
It's important to understand that as a software development life cycle has various stages or phases and models, it also has changed according to specific philosophies, which we’ll talk about later.
The key idea is that the software development life cycle defines how software is created and released to a production environment.
It's a central premise in the IT world, since software has become integral to so many of the things that we do each day, and to longer-term processes that direct both business and consumer activity. The software development life cycle determines how we receive all of those apps and desktop products and operating systems that we use to text, tweet and direct a myriad of new technologies.
With that said, a better understanding of the SDLC helps us to know what's happening behind the scenes, or as some would say, “how the sausage gets made.”
Behind every app or software product there is code. That code comes from humans. SDLC is a way to ensure that fallible humans create relatively infallible technology.
The software development life cycle can also vary a good deal.
“There are a variety of approaches to the doing the work, or what the specific software development lifecycle looks like, and that depends upon the organization as to the specific steps,” says John Quigley of Value Transformation, describing how the SDLC sets the stage for so many of the consumer conveniences we enjoy. “In modern life, there is software in many more products than you may think. Your alarm clock, most likely has a microcontroller inside that runs software. Your microwave has a microcontroller that receives inputs from the user and performs according to those commands. Your smartphone, your television and your car have software in them. Just as there are many applications, there are many variations in software products.”
One popular example is the modern automobile, which any mechanic will probably tell you has come to look a lot more like a fancy computer in the last decade or so.
“In your car, there are many microcontrollers that are running different software, that must be coordinated with other products on the car that also contain software, for example, the engine and the transmission,” Quigley says. “These things are connected to produce a software system sharing information from each component with the other through some serial communications and each component making an appropriate decision based upon the contents of that data.”
The software development life cycle governs all of this, by creating a deliberate road map for how each of these unique items will be built and delivered to the world. In this tutorial, you will learn more about how a SDLC works practically in a software design environment.
Phases of the Software Development Life Cycle
At its most basic level, the software development life cycle is composed of a number of phases.
The five core phases of SDLC involve requirements analysis, design, development, testing and maintenance. Some experts add a sixth phase called deployment, or even a seventh phase, but the five core phases give a general idea of what's involved.
Each phase has its own requirements and deliverables that need to progress to the next phase.
The first phase is requirement gathering and analysis. This is the phase in which brainstorming happens to determine how a product will be used and what role it needs to play. This is also where teams get buy-in for a project.
The second phase is design – here the teams start putting effort into drawing the broader contours of the software product itself. They look at hardware specifications and how a piece of software will fit into a system architecture.
Implementation or coding is the next phase, which is the practical writing phase, and tends to be the most involved phase of the process, although design and testing are other candidates.
The deployment phase involves getting a software product out to its intended user base.
The last phase, maintenance, addresses the production environment and what happens when the software is out in the world being used by end users. The ongoing professional guidance that the software product receives is the core maintenance that makes up this last phase.
Done right, these phases can optimize how a software project gets done.
“The Software Development Life Cycle (SDLC) is the software development world’s spellcheck,” writes Robert Half. “It can flag errors in software creation before they’re discovered (at a much higher cost) in successive stages. But it’s much more than that, of course: SDLC can also lay out a plan for getting everything right the first time.”
However, the linear stages that software projects go through also benefit from higher-level frameworks or models that direct them. In the next page, we’ll talk about some of these models and how they work.
The core phases of the software development life cycle are managed by a number of models which are considered common in the software industry. As we'll see later, many of these are in flux and changing due to changes in the industry, but they are often taught as traditional SDLC models.
One that is often mentioned first is the “waterfall” method or “cascade” method. This is named like it is because each step “falls” into the step after it. A visual will often show a line or box with an arrow going down into a subsequent line or box at the next level.
In the waterfall model, each phase is clearly delineated and separate. All of the requirements gathering is done before any design takes place, and all of the design is completed before codebase writing, and all of the codebase writing is done before testing, etc. This provides a very concrete structure for the project: Everyone always knows which phase the project is in, and works accordingly. However, the waterfall model also has its down side, where the process is not as versatile due to the solid barriers between phases.
Another mode is the “iterative” model or “incremental” model.
The incremental model is something you might call a “fragmented” or “fractal” model, in contrast to the waterfall model. Here, the individual steps are broken up into micro components – instead of one overarching design phase, there are multiple design phases locked together with other key tasks from other phases like coding, implementation and testing.
One way to understand the incremental approach is to look at different types of testing – for example, there’s unit testing. A unit is the smallest testable part of any software. Testing software with a unit testing approach means that the small modules are treated differently and independently of one another. Unit testing provides that incremental model, as it allows programmers to test each module or part of the codebase individually and with a granular approach
Another common SDLC model, the “V-shaped” model, has a similar structure, but a somewhat different workflow aspect, where the initial phases go down into implementation and testing phases, and where multiple testing phases follow.
Then there's the agile model which emerged in the last decade or so, bringing us into new philosophies of software design. Incremental development plays a role, and the process itself becomes more complex as key tasks get shuffled from one phase to the other.
Traditional Waterfall SDLC: An Example
In the requirements planning phase, company leaders brainstorm about what types of functionality they need, things like bandwidth speed and interfaces to help users understand what these different machines are doing.
After that, the design phase progresses. Teams create specs that describe the theoretical software package down to the last detail. There's accommodation for everything from usability to hardware compatibility to cost.
After that comes the coding phase – coders sit down and write all of the code that will allow the program to work well.
After that, there's implementation or deployment to a production environment. Now the software has gone live. It's out there in the world, and it will be out there until end of life.
This example helps to illustrate how a real-life software project might work with a traditional SDLC model.
More About Agile SDLC
Agile software development is an interesting process to describe. It changes according to the company's goals and preferences. There's a lot of room for customization.
However, at its most basic level, agile is the untethering of those strictly linear individual processes into one kind of “big ball of yarn.”
One key characteristic of agile process is “sprints” – short process time frames in which developer teams decide what goes into each step. That's not preordained for them, like it is with the waterfall method.
Then there are key phases you can use to describe agile:
You'll see that some of the stages sound kind of like the stages in the traditional SDLC process. However, they are different, according to the philosophy of agile design.
For example, calling the fourth stage “release” instead of “testing” is a giveaway that the process involves continual and orchestrated improvement. As mentioned before, there's no strict beta phase – instead, testing takes place around the release. You can also see the changing of the word “maintenance” to “production,” signifying that teams are working on new features, testing software products, and contemplating security issues, all at the same time. That would be right up until the end of life stage, where teams get ready to actively throw a retirement party for a software version.
In addition, there are various strategic models that agile development uses. There's scrum, a sort of decision-making process that applies to many sprints. There's kanban, a concept pioneered by Japanese engineers that has become a mainstay of the information technology field. These frameworks inform and guide the agile process in important ways, since the agile process is not governed by the waterfall or traditional linear project management guidelines.
Agile development has brought innovation and enhanced many projects – but the key is that it does require that iterative master planning – at various stages, as opposed to one individual plan that's fully formed before the actual work starts.
Agile SDLC: An Example
First, company leaders begin planning – they create a broad overview of what the project will need. At the same time, they will be moving ahead with the design process – they may be designing small parts of a program independently of one another. Coders will begin writing the code – they'll create sprints that include specific task sets that will tie together to serve a particular code module.
As the code is being created, the features and modules are being rolled out. They're being tested during the process: this creates a lot of little “streams” or “threads” of movement that team managers have to control.
As the project moves toward completion, parts of the software are released. An interface may be released that's not yet finished, or features may be upgraded after the fact. Coders are still coding, testers are still testing, but the software is being used in a production environment. As new features and updates become available, they are continuously delivered in an automated way.
All of this is really a gross oversimplification, but it's an example of how something might go when you start to implement the agile method over the traditional waterfall.
DevOps and the SDLC
One word has recently redefined the software development life cycle.
Actually it's two words, a portmanteau of the words “development” and “operations.”
The word is “DevOps,” and it's been responsible for vast changes in the ways that people approach the software development life cycle.
For example, in the old days, the traditional method was to fully build a piece of software, and release it to a select number of users in a process known as “beta testing.”
The process was predictable – the build happened, the code happened, and there was a grand opening where the project went to beta – after beta, it went to public users.
The DevOps principal is all about blending and merging those traditional processes to make the software development life cycle more agile, to promote what's called continuous integration and continuous delivery and to automate and expedite and streamline parts of the software development life cycle to the benefit of teams and firms.
So in the case of beta testing, DevOps promotes the idea that testing is done throughout the process. It's not put into a single box in the workflow. It's done continuously, with continuous releases, and everything is merged together to make it meaner, leaner and more efficient.
Artificial Intelligence and the SDLC
In discussing how a modern software development life cycle currently operates, one would be remiss not to talk about one of the most fundamental new technologies changing many fields and industries.
This happens in many different ways, as innovators experiment with ways to optimize, automate and expedite the software development life cycle. However, the general idea is that with more automation, teams are going to be more hands-off.
This piece in SmallBizDaily gives us a hint of this idea:
“It is always vital to reduce time to market of a customer business app. For instance, with the Agile SDLC model chosen, the development team can prepare the MVP as early as possible,” writes Katrine Spirina. “Prompt market entry of a viable product can draw much attention of early adopters to the application. Meanwhile, the development team will be able to proceed with updating and adding functionalities … The software development life cycle also allows business analysts to foresee the market tendencies and embed a bunch of cutting-edge functionalities in a would-be app during the development process.”
A piece by Forbes from this past April also talks about how machine learning “fundamentally changes the software development paradigm” and how artificial intelligence programs will make many kinds of explicit coding obsolete.
“There are many tasks and decisions … that are far too complex to teach to computers in a rigid, rule-based way,” writes Mariya Yao. “Enter AI techniques such as machine learning and deep learning. In these approaches, an engineer does not give the computer rules for how to make decisions and take actions. Instead, she curates and prepares domain-specific data which is fed into learning algorithms which are iteratively trained and continuously improved. A machine learning model can deduce from data what features and patterns are important, without a human explicitly encoding this knowledge. The outputs of ML models can even surprise humans and highlight perspectives or details we haven't thought of ourselves.”
This type of innovation notwithstanding, experts caution against the “black box problem,” where, with excessive automation, it becomes hard to figure out how the AI/ML programs are doing their work – inhibiting troubleshooting.
As formative types of AI assistance in the SDLC, Yao cites rapid prototyping, intelligent programming assistance, automatic analytics and error handling, automatic code refactoring, and strategic decision-making tools.
The piece also ends with the intriguing concept of “Can AI create AI?” which conjures up nightmarish visions of robots building more robots, in order to build more robots.
In conclusion, if you're going to be getting involved in the software development world, look for software development life cycles to be complex and sophisticated. Don't expect to see the old waterfall technique, since many companies consider it to be obsolete and outmoded. Instead, companies are seeking efficiencies and integrating newer technologies into the process of developing software products.
The only thing certain is change, and that's abundantly true in the software development life cycle. Whether to more effectively accommodate teams or to expedite release or to make code cleaner, today's firms are utilizing the strengths of predictive automation tools to redesign the software development life cycle – probably forever.