Software Development Life Cycle (SDLC) Models

There are various software development life cycle models defined and designed which are followed during the software development process. These models are also referred as Software Development Process Models". Each process model follows a Series of steps unique to its type to ensure success in the process of software development.

Following are the most important and popular SDLC models followed in the industry:

1. Waterfall Model
2. Prototyping
3. Iterative Model
4. Relational unified process
5. Time boxing model
6. Extreme programming
7. Agile process

1. Waterfall Model:

Waterfall model is an example of a Sequential model. In this model, the software development activity is divided into different phases and each phase consists of series of tasks and has different objectives.

It is divided into phases and output of one phase becomes the input of the next phase. It is mandatory for a phase to be completed before the next phase starts. In short, there is no overlapping in Waterfall model.

In waterfall, development of one phase starts only when the previous phase is Because of this nature, each phase of waterfall model is quite precise well defined. Since the phases fall from higher level to lower level, like a waterfall, It’s named as waterfall model.

Advantage and Disadvantage of Waterfall model: 

Advantages of using Waterfall model :

• Simple and easy to understand and use.
• For smaller projects, waterfall model works well and yield the appropriate
• Since the phases are rigid and precise, one phase is done one at a time, it is easy to
• The entry and exit criteria are well defined, so it easy and systematic to proceed with
• Results are well

Disadvantages of using Waterfall model:

• Cannot adopt the changes in requirements
• It becomes very difficult to move back to the phase. For example, if the application has now moved to the testing stage and there is a change in requirement, It becomes difficult to go back and change
• Delivery of the final product is late as there is no prototype which is demonstrated
• For bigger and complex projects, this model is not good as a risk factor is
• Not suitable for the projects where requirements are changed
• Does not work for long and ongoing
• Since the testing is done at a later stage, it does not allow identifying the challenges and risks in the earlier phase so the risk mitigation strategy is difficult to

In the waterfall model, it is very important to take the sign off of the deliverables of each phase. As of today most of the projects are moving with Agile and Prototype models, Waterfall model still holds good for smaller projects. If requirements are straightforward and testable, Waterfall model will yield the best results.

2. Prototyping Model 

The basic idea in Prototype model is that instead of freezing the requirements before a design or coding can proceed, a throwaway prototype is built to understand the requirements.

This prototype is developed based on the currently known requirements. Prototype model is a software development model. By using this prototype, the client can get an “actual feel” of the system, since the interactions with prototype can enable the client to better understand the requirements of the desired system.

Prototyping is an attractive idea for complicated and large systems for which there is no manual process or existing system to help determining the requirements.

The prototype are usually not complete systems and many of the details are not built in the The goal is to provide a system with overall functionality.

Advantages and Disadvantage of Prototype model

Advantages of Prototype model:

• Users are actively involved in the development
• Since in this methodology a working model of the system is provided, the users get a better understanding of the system being
• Errors can be detected much
• Quicker user feedback is available leading to better
• Missing functionality can be identified easily

Disadvantages of Prototype model:

• Leads to implementing and then repairing way of building
• Practically, this methodology may increase the complexity of the system as scope of the system may expand beyond original plans.

When to use Prototype model:

• Prototype model should be used when the desired system needs to have a lot of interaction with the end users.
• Typically, online systems, web interfaces have a very high amount of interaction with end users, are best suited for Prototype model. It might take a while for a system to be built that allows ease of use and needs minimal training for the end user.
• Prototyping ensures that the end users constantly work with the system and provide a feedback which is incorporated in the prototype to result in a useable system. They are excellent for designing good human computer interface

3. Iterative Model

An iterative life cycle model does not attempt to start with a full specification of requirements. Instead, development begins by specifying and implementing just part of the software, which can then be reviewed in order to identify further requirements. This process is then repeated, producing a new version of the software for each cycle of the model.

In the diagram above when we work iteratively we create rough product or product piece in one iteration, then review it and improve it in next iteration and so on until it’s finished. As shown in the image above, in the first iteration the whole painting is sketched roughly, then in the second iteration colors are filled and in the third iteration finishing is done. Hence, in iterative model the whole product is developed step by step.

Advantages of Iterative model

• In iterative model we can only create a high-level design of the application before we actually begin to build the product and define the design solution for the entire Later on we can design and built a skeleton version of that, and then evolved the design based on what had been built.
• In iterative model we are building and improving the product step by step. Hence we can track the defects at early This avoids the downward flow of the defects.
• In iterative model we can get the reliable user When presenting sketches and blueprints of the product to users for their feedback, we are effectively asking them to imagine how the product will work.
• In iterative model less time is spent on documenting and more time is given for

Disadvantages of Iterative model

• Each phase of an iteration is rigid with no overlaps
• Costly system architecture or design issues may arise because not all requirements are gathered up front for the entire lifecycle

When to use iterative model

• Requirements of the complete system are clearly defined and
• When the project is
• Major requirements must be defined; however, some details can evolve with

4. Relational Unified Process(RUP)

RUP Stands for "Rational Unified Process." RUP is a software development process from Rational, a division of IBM. It divides the development process into four distinct phases that each involve business modeling, analysis and design, implementation, testing, and deployment.

The four phases are:

1. Inception - The idea for the project is stated. The development team determines if the project is worth pursuing and what resources will be needed.
2. Elaboration - The project's architecture and required resources are further Developers consider possible applications of the software and costs associated with the development.
3. Construction - The project is developed and completed. The software is designed, written, and tested.
4. Transition - The software is released to the public. Final adjustments or updates are made based on feedback from end users.

The RUP development methodology provides a structured way for companies to envision create software programs. Since it provides a specific plan for each step of the development process, it helps prevent resources from being wasted and reduces unexpected development costs.

5. Time Boxing Model

In time boxing model, development is done iteratively as in the iterative enhancement However, in time boxing model, each iteration is done in a timebox of fixed duration. The functionality to be developed is adjusted to fit the duration of the timebox. Moreover, each timebox is divided into a sequence of fixed stages where each stage performs a clearly defined task (analysis, implementation, and deploy) that can be done independently. This model also requires that the time duration of each stage is approximately equal so that pipelining concept is employed to have the reduction in development time and product releases.

There is a dedicated team for each stage so that the work can be done in pipelining. Thus, stages should be chosen in such a way that each stage perform some logical unit of work that becomes the input for next.

In addition to the advantages of iterative model, time boxing model has some other advantages too. Various advantages and disadvantages associated with timeboxing model are listed in Table.

Table Advantages and Disadvantages of the Time boxing Model

6. Extreme Programming

What is Extreme Programming?

XP is a lightweight, efficient, low-risk, flexible, predictable, scientific, and fun way to develop a software.

eXtreme Programming (XP) was conceived and developed to address the specific needs of software development by small teams in the face of vague and changing requirements.

Extreme Programming is one of the Agile software development methodologies. It provides values and principles to guide the team behavior. The team is expected to self-organize. Extreme Programming provides specific core practices where −

• Each practice is simple and self-complete.
• Combination of practices produces more complex and emergent

Embrace Change

A key assumption of Extreme Programming is that the cost of changing a program can be held mostly constant over time.

This can be achieved with −

• Emphasis on continuous feedback from the customer
• Short iterations
• Design and redesign
• Coding and testing frequently
• Eliminating defects early, thus reducing costs
• Keeping the customer involved throughout the development
• Delivering working product to the customer

Extreme Programming in a Nutshell

Extreme Programming involves −

• Writing unit tests before programming and keeping all of the tests running at all times. The unit tests are automated and eliminates defects early, thus reducing the
• Starting with a simple design just enough to code the features at hand and redesigning when
• Programming in pairs (called pair programming), with two programmers at one screen, taking turns to use the keyboard. While one of them is at the keyboard, the other constantly reviews and provides inputs.
• Integrating and testing the whole system several times a
• Putting a minimal working system into the production quickly and upgrading it whenever
• Keeping the customer involved all the time and obtaining constant

Iterating facilitates the accommodating changes as the software evolves with the changing requirements.

Why is it called “Extreme?”

Extreme Programming takes the effective principles and practices to extreme levels.

• Code reviews are effective as the code is reviewed all the
• Testing is effective as there is continuous regression and
• Design is effective as everybody needs to do refactoring
• Integration testing is important as integrate and test several times a
• Short iterations are effective as the planning game for release planning and iteration

Success in Industry

The success of projects, which follow Extreme Programming practices, is due to −

• Rapid
• Immediate responsiveness to the customer’s changing
• Focus on low defect
• System returning constant and consistent value to the
• High customer
• Reduced
• Team cohesion and employee

Extreme Programming Advantages

Extreme Programming solves the following problems often faced in the software development projects −

• Slipped schedules − and achievable development cycles ensure timely
• Cancelled projects − Focus on continuous customer involvement ensures transparency with the customer and immediate resolution of any
• Costs incurred in changes − Extensive and ongoing testing makes sure the changes do not break the existing A running working system

always ensures sufficient time for accommodating changes such that the current operations are not affected.

• Production and post-delivery defects: Emphasis is on − the unit tests to detect and fix the defects
• Misunderstanding the business and/or domain − Making the customer a part of the team ensures constant communication and
• Business changes − Changes are considered to be inevitable and are accommodated at any point of
• Staff turnover − Intensive team collaboration ensures enthusiasm and good Cohesion of multi-disciplines fosters the team spirit.

7. Agile process Model

Agile development model is also a type of Incremental model. Software is developed in incremental, rapid cycles. This results in small incremental releases with each release building on previous functionality. Each release is thoroughly tested to ensure software quality is maintained. It is used for time critical applications. Extreme Programming (XP) is currently one of the most well known agile development life cycle model.

Advantages of Agile model:

• Customer satisfaction by rapid, continuous delivery of useful
• People and interactions are emphasized rather than process and Customers, developers and testers constantly interact with each other.
• Working software is delivered frequently (weeks rather than months).
• Face-to-face conversation is the best form of
• Close, daily cooperation between business people and
• Continuous attention to technical excellence and good
• Regular adaptation to changing
• Even late changes in requirements are welcomed

Disadvantages of Agile model:

• In case of some software deliverables, especially the large ones, it is difficult to assess the effort required at the beginning of the software development life cycle.
• There is lack of emphasis on necessary designing and documentation.
• The project can easily get taken off track if the customer representative is not clear what final outcome that they
• Only senior programmers are capable of taking the kind of decisions required during the development process. Hence it has no place for newbie programmers, unless combined with experienced resources.

When to use Agile model:

• When new changes are needed to be implemented. The freedom agile gives to change is very important. New changes can be implemented at very little cost because of the frequency of new increments that are
• To implement a new feature the developers need to lose only the work of a few days, or even only hours, to roll back and implement it.
• Unlike the waterfall model in agile model very limited planning is required to get started with the Agile assumes that the end users’ needs are ever changing in a dynamic business and IT world. Changes can be discussed and features can be newly effected or removed based on feedback. This effectively gives the customer the finished system they want or need.
• Both system developers and stakeholders alike, find they also get more freedom of time and options than if the software was developed in a more rigid sequential way. Having options gives them the ability to leave important decisions until more or better data or even entire hosting programs are available; meaning the project can continue to move forward without fear of reaching a sudden