Introduction to Information System

Dr. Shimaa Ismail

Information System Department
Faculty of Computers and Artificial Intelligence
Software Development Methodologies

2
Software Development Model
• A software development model is a series of processes that are carried out
by software development companies to develop software applications.
• Software development models thus serve as a blueprint for managing the end-to-
end software development pipeline.
• Each methodology works against the constraints of cost and resources, where
cost refers to time and money, while resources reflect human and infrastructural
resources.
Software Development Life Cycle
• The Software Development Life Cycle (SDLC) is a model that lays out the steps involved
in software development at each level.
• The complete process of software development models including all processes involved
in designing, developing, testing, and deploying a software product is described in the
Software Development Life Cycle.

• There are different software development models available currently. But none of them
are flawless, and each has its own set of benefits and drawbacks for a particular software
development project or team.
• Software development no longer followed a fixed approach. Faster deployments, rapid
releases, and improved coordination and collaboration became the criteria for choosing
the right software development methodology.
Stages of Software Development Life Cycle
Each of these stages adds value to the
software development process, thereby
aiding in building the application from
concept to program to usable application.

Requirements gathering and analysis: Identifying

the problem, defining the scope, and building the
execution plan.
Design: Creating a design framework using
requirements.
Implementation: Developing code/programs
considering the specifications.
Testing: Subjecting programs to quality
assurance processes to validate their
performance.
Maintenance: Ensure performance consistency
and improve the application to suit the changing
environment.
Types of SDLC
The types in the lower quadrants of the
chart take the sequential flow. They are
easy to implement, use and manage.
As you move higher, the process becomes
less rigid and offers more flexibility when
it comes to changes in the requirements
for future software.

The models on the left side of the chart

suggest less customer involvement;
As you move to the right, the models get
more 'cooperative,' incorporating
customers more deeply into various stages
of the software development life cycle.
WATERFALL MODEL
Through all development stages (analysis,
design, coding, testing, deployment), the
process moves in a cascade mode. Each
stage has concrete deliverables and is
strictly documented. The next stage cannot
start before the previous one is fully
completed.

There is also no ability to see and try

software until the last development stage is
finished, which results in high project risks
and unpredictable project results. Testing is
often rushed, and errors are costly to fix.
WATERFALL MODEL
ADVANTAGES
• Easier to stick within a predefined budget or timeline.
• Relatively straightforward to manage.
• Simple to measure and monitor progress with deliverables at every stage.
• Very organized and transparent. Heavy documentation and initial planning adds clarity and
reduces the risk of miscommunication.
• Possible to identify and eliminate potential errors when planning. This can save time during
implementation.
• New developers can join the project at any time because technical documentation is thorough.

DISADVANTAGES
• A very rigid structure can be restrictive — each stage is dependent on the previous one.
• Not possible to revisit requirements after the first stage of the development cycle.
• The bigger the project, the more difficult it is to predict all project requirements in the first stage.
• Testing and deployment don’t take place until the final stages. The risk of encountering
unanticipated errors is, therefore, quite high.
• Mistakes are expensive to resolve and can negatively impact the predicted timeline.
WATERFALL MODEL
Use cases:

• Simple small or mid-sized projects with clearly defined and unchanging

requirements (small company website development).
• Projects with the need for stricter control, predictable budget and timelines (e.g.,
governmental projects).
• Projects that must adhere to multiple rules and regulations (healthcare projects).
• Projects where a well-known technology stack and tools are used.
V-Model (Validation and Verification Model)
V-Model
• The V-model is another linear model with each stage having a corresponding testing
activity. Such workflow organization implies exceptional quality control, but at the
same time, it makes the V-model one of the most expensive and time-consuming
models.
• Moreover, even though mistakes in requirements specifications, code and
architecture errors can be detected early, changes during development are still
expensive and difficult to implement. As in the Waterfall case, all requirements are
gathered at the start and cannot be changed.

Use cases:
• Projects where failures and downtimes are unacceptable (e.g., medical software, aviation fleet
management software).
Incremental and Iterative Model
• The development process based on the
Incremental model is split into several
iterations (“Lego-style” modular software
design is required!).
• New software modules are added in each
iteration with no or little change in earlier
added modules.
• The development process can go either
sequentially or in parallel. Parallel
development adds to the speed of
delivery, while many repeated cycles of
sequential development can make the
project long and costly.
Incremental and Iterative Model
• With Iterative development software
changes on each iteration, evolves and
grows. As each iteration builds on the
previous one, software design remains
consistent.
• As software is delivered in parts, there is no
need for a full specification from the
project’s start and small changes to
requirements are possible in the course of
the development process. However, the
requirements can’t change radically – major
ones must be defined in the beginning.

Use cases:
• Large, mission-critical enterprise applications
that preferably consist of loosely coupled
parts, such as microservices or web services.
Spiral model
• The Spiral model puts focus on thorough risk
assessment. Thus, to reap the benefits of the
model to the fullest, you’ll need to engage
people with a strong background in risk
evaluation.
• A typical Spiral iteration lasts around 6
months and starts with 4 important activities
- thorough planning, risk analysis, prototypes
creation, and evaluation of the previously
delivered part. Repeated spiral cycles
seriously extend project timeframes.
Spiral model
This is the model where intensive customer
involvement appears. They can be involved in
the exploration and review stages of each cycle.
At the development stage, the customer’s
amendments are not acceptable.

Use cases:

• Projects with unclear business needs or too

ambitious/innovative requirements.
• Projects that are large and complicated.
• Research and development (R&D) activity or
the introduction of a new service or a product.
 The Rational Unified Process (RUP)
The Rational Unified Process (RUP) is
also a combination of linear and
iterative frameworks.

The model divides the software

development process into 4 phases –
inception, elaboration, construction, and
transition. Each phase but Inception is
usually done in several iterations.

All basic activities (requirements, design,

etc.) of the development process are
done in parallel across these 4 RUP
phases, though with different intensity.
 The Rational Unified Process (RUP)
RUP comprises four phases, which are:
• Inception: Initiates the project with a rationale, defines the scope, and provides a conceptual prototype.
• Elaboration: Drives deeper analysis, goes into details of requirements, and builds an architectural baseline.
• Construction: Drives iterative analysis, designing, building, and testing of the product features.
• Transition: Packages the product after performance tuning and trains new users and seeks feedback.

• RUP helps to build stable and, at the same time, flexible solutions, but still, this model is not as quick and
adaptable as the pure Agile group (Scrum, Kanban, XP, etc.). The degree of customer involvement,
documentation intensity, and iteration length may vary depending on the project needs.

Use cases:

• Large and high-risk projects, especially, use-case based development and fast development of high-quality
software.