Agile vs V-Shaped

Two of the most popular life cycle models are agile and V-shaped. Today, we’ll examine their relative strengths and the types of problems they solve.

When discussing a new project with a client, one of the most common questions I hear is, “When will it be finished?” In the most literal sense, the answer is “never.” Software development is a never-ending process.

Fortunately, the majority of the time, this question can be translated as “When can we have a working version of the product?” The distinction here is subtle but significant. Going to production and having a working product is not the same as “completing the product once and for all.”

Software projects are never truly completed. Yes, theoretically, you could go to production, close your IDE, and never write another line of code again. Even so, the process isn’t over. Our software begins to age as time passes and technology changes.

A perfectly serviceable product can fail for a variety of reasons, including changes in hardware architecture, API modifications, and the introduction of new disruptive technologies. Even a simple undiscovered bug in a programming language can act as a catalyst for change.

This is one of those instances where deterministic machine models fail to grasp the market’s complexities. You can’t just build software algorithmically that will last forever. In reality, software projects are analogous to organic processes. They, like living organisms, grow, change, and survive by adapting to their surroundings. And it is for this reason that we discuss the Software Development Life Cycle.

Today, we’ll look at two of the most well-known SDLC models: agile and V-shaped. We’ll go over the process in general, compare their strengths and weaknesses, and recommend which types of projects are best suited to each style.

What is Software Development Life Cycle

The Software Development Life Cycle (SDLC) is a subjective classification of software development stages (or steps). It is used to comprehend, manage, measure, and improve the development process. It is one of the most widely accepted business models in the industry.

It’s a cycle because it’s an iterative process: once you’ve completed all of the stages, you go back to the beginning and make changes based on the feedback from the previous cycle. In formal terms, it is known as a cybernetic loop.

It’s biased because it’s based on a paradigm. While both Waterfall and Agile refer to SDLC, the implementations are quite different, with each focusing on their respective strengths.

SDLC is a powerful communication tool for both the development team and the client, in addition to being a model. It’s very simple to explain where a project is at by referring to its stage. It establishes clear objectives and assists you in maximizing efficiency at each stage.

A good SDLC is essential for businesses that want to cut costs, deliver better software faster, and adapt to market trends and scale. The SDLC assists in achieving these goals by identifying inefficiencies and correcting them to make the operation run more smoothly.

What Are the Different Software Development Life Cycle Models

There are dozens of models to choose from, ranging from the structured and traditional waterfall model to Agile models like Scrum or Kaban, which take a more laissez faire approach. To go over each and every one of them would take much more than a single article.

Instead, we should spend our time discussing why they are different. No two projects are alike, and no two teams are alike, so it stands to reason that different teams will approach the problems and goals of each project in different ways.

I like to think of SDLC models as a continuum, with the low-user-engagement, heavily structured, and linear Waterfall approach on one end and highly involved, loosely structured Agile approaches on the other.

Today, we’ll look at two models, each representing one of the continuum’s extremes.

Examples of Software Development Life Cycle Models

The V-Shaped Model

The V-model is a type of SDLC in which the process is carried out in a V-shape. The Verification (Static reviews without running code) and Validation (Dynamic review based on code execution) models are commonly used. The life cycle is divided into two stages: verification (on the left side of the model) and validation (on the right side), with both sides meeting at the coding stage at the bottom.

Each testing phase must be completed in order. The distance between verification (on the left side of the model) and validation (on the right side) shrinks as the product takes shape, eventually collapsing into a common node in the final stage known as “Coding.” This gives the model the shape of the letter V.

Validation phases:

• Requirement analysis: Detailed communication with the customer to understand features and requirements.
• System design: Designing the system and setting up hardware and communication configurations.
• Architectural Design: The system is broken down into modules for different functionalities.
• Module design: Each module is further defined and broken down into sub-modules.

Testing phases:

• Unit testing: Test plans designed during the module design phase are executed to eliminate bugs at the code or unit level.
• Integration testing: After completing the unit tests, testers check for integration, i.e., if all the modules fit together and communicate without bugs. This is done in the Architecture design phase.
• System testing: The complete application is tested with all its functionalities. This is done during the system design phase.
• User acceptance testing: UAT is performed in a user environment that resembles production. UAT verifies that the product meets the user’s expectations and it’s ready to use.

Advantages: 

• Very easy to manage and track thanks to its hierarchical structure.
• Problems are detected at an early stage.
• Disciplined model where stages are completed one at a time.
• Great for small projects where requirements are clear.
• Simple and easy to understand and use.
• Focuses on verification and validation activities early in the life cycle, which helps to prevent bugs down the line. 

Disadvantages:  

• Rigid nature turns it into a poor match for complex and object-oriented projects.
• Struggles when requirements aren’t clear or constantly changing.
• Very difficult to handle concurrent projects or events. 

The Agile Software Model

In stark contrast to the V-shaped model’s fixed nature, Agile embraces the chaos and flexibility of software development. While there are numerous Agile models, such as Scrum and Kanban, they all share enough similarities to be referred to as a single SDLC.

The Agile software development life cycle typically consists of six stages:

The Concept phase comes first. The project’s scope will be determined by the product owner. When several projects are running at the same time, the owner prioritizes the most important one. During this stage, key requirements are established in collaboration with the client, and project documentation is prepared for the team.

Because Agile is iterative, it is best to start with few requirements and scale up as the project is built.

Then, with an outline in hand, the product owner builds the development team by consulting with colleagues and/or hiring new developers as needed. The goal here is to match the team’s skills to the needs of the current project.

At this point, the team will create a mockup of the interface as well as an initial approach to the architecture. In some cases, the product owner will show this to the client in order to solicit feedback and make changes as needed.

The next step is iteration. It is the longest phase because it contains the majority of the work. UX designer notes, customer feedback, and product requirements are all combined at this stage to turn the design into code.

The process is inherently iterative, transitioning from short work bursts (similar to sprints) to testing and feedback, building the software while also fixing bugs on each iteration. This is the foundation of Agile.

The following stage is Release. The team moves to production after QA completes the necessary tests. Bugs are to be expected during the launch period, and the team is prepared to address them as soon as possible. During this phase, user training takes place.

Maintenance is the final stage. After the software is fully deployed, the team focuses on providing ongoing support to ensure that the system runs smoothly and that any unexpected bugs are squashed. Additional training is available upon request. New iterations can occur over time to update the product.

Finally, there is Retirement, which occurs only when the software is about to be phased out. During this stage, the team prepares to shut down the system, easing the transition to the new system as needed.

Advantages:  

•  Dynamic development that adapts to changing circumstances
•  Problems are detected quickly and processed during development. 
•  Great for big project with many moving parts
•  Users and clients are pivotal to the process.
•  New features can be added at any stage

Disadvantages: 

• Requires discipline and expertise, since the lack of direction can quickly devolve into feature creep.
• Extremely susceptible to miscommunication.
• Not a great fit for business with extremely tight deadlines or strict regulations that require timetables.

Conclusion

Both models are perfectly viable approaches to software development, which should come as no surprise. The choice then comes down to the nature of the project as well as the development team’s expertise. Regardless of the size of the project, having a team that knows and understands the V-shaped model is preferable to forcing them to work with Agile.