Software engineering is the establishment and use of sound engineering

principles in order to obtain economically software that is reliable and works

efficiently in real machines.

(Figure: Software Engineering Layers)

Software Engineering is a layered technology

A quality Focus:

 Main principle of Software Engineering is Quality Focus.

 An engineering approach must have a focus on quality.
 Total Quality Management (TQM), Six Sigma, ISO 9001, ISO 9000-3,
CAPABILITY MATURITY MODEL (CMM), CMMI & similar
approaches encourages a continuous process improvement culture.

Process:

 It is a foundation of Software Engineering

 It is the glue the holds the technology layers
  It defines a framework with activities for effective delivery of software
engineering technology

Methods:

 It provides technical how-to’s for building software

 It encompasses many tasks including communication, requirement
analysis, design modeling, program construction, testing and support

Tools:

 Software Engineering Tools allows automation of activities which helps

to perform systematic activities. A system for the support of software
development, called computer-aided software engineering (CASE).
Examples: Testing Tools, Bug/Issue Tracking Tools etc…
 Computer-aided software engineering (CASE) is the scientific application
of a set of tools and methods to a software system which is meant to
result in high-quality, defect-free, and maintainable software products
 CASE tools automate many of the activities involved in various life cycle
phases

Software Processes in Software Engineering

Software is the set of instructions in the form of programs to govern the

computer system and to process the hardware components. To produce a
software product the set of activities is used. This set is called a software
process.

Components of Software:

There are three components of the software:

1. Program:
A computer program is a list of instructions that tell a computer what to do.

2. Documentation:
Source information about the product contained in design documents,
detailed code comments, etc.

3. Operating Procedures:
 Set of step-by-step instructions compiled by an organization to help
workers carry out complex routine operations.

There are four basic key process activities:

1. Software Specifications:
In this process, detailed description of a software system to be developed
with its functional and non-functional requirements.
2. Software Development:
In this process, designing, programming, documenting, testing, and bug
fixing is done.
3. Software Validation:
In this process, evaluation software product is done to ensure that the
software meets the business requirements as well as the end users needs.
4. Software Evolution:
It is a process of developing software initially, then timely updating it for
various reasons.
Software Crisis:
1. Size and Cost:
Day to day growing complexity and expectation out of software. Software
are more expensive and more complex.
2. Quality:
Software products must have good quality.
3. Delayed Delivery:
Software takes longer than the estimated time to develop, which in turn
leads to cost shooting up.
Software Process Model:
A software process model is an abstraction of the actual process, which is
being described. It can also be defined as a simplified representation of a
software process. Each model represents a process from a specific perspective.
Basic software process models on which different type of software process
models can be implemented:

1. A workflow Model:
It is the sequential series of tasks and decisions that make up a business
process.
2. The Waterfall Model:
It is a sequential design process in which progress is seen as flowing
steadily downwards. Phases in waterfall model:
 (i) Requirements Specification
 (ii) Software Design
 (iii) Implementation
 (iv) Testing

3. Dataflow Model:
It is diagrammatic representation of the flow and exchange of information
within a system.
4. Evolutionary Development Model:
Following activities are considered in this method:
 (i) Specification
 (ii) Development
 (iii) Validation

5. Role / Action Model:

Roles of the people involved in the software process and the activities.

Classical waterfall model is the basic software development life cycle model.
It is very simple but idealistic. Earlier this model was very popular but
nowadays it is not used. But it is very important because all the other software
development life cycle models are based on the classical waterfall model.
Classical waterfall model divides the life cycle into a set of phases. This model
considers that one phase can be started after completion of the previous phase.
That is the output of one phase will be the input to the next phase. Thus the
development process can be considered as a sequential flow in the waterfall.
Here the phases do not overlap with each other. The different sequential phases
of the classical waterfall model are shown in the below figure:
Let us now learn about each of these phases in brief details:
1. Feasibility Study: The main goal of this phase is to determine whether it
would be financially and technically feasible to develop the software.
The feasibility study involves understanding the problem and then determine
the various possible strategies to solve the problem. These different
identified solutions are analyzed based on their benefits and drawbacks, The
best solution is chosen and all the other phases are carried out as per this
solution strategy.
2. Requirements analysis and specification: The aim of the requirement
analysis and specification phase is to understand the exact requirements of
the customer and document them properly. This phase consists of two
different activities.
 Requirement gathering and analysis: Firstly all the requirements
regarding the software are gathered from the customer and then the
gathered requirements are analyzed. The goal of the analysis part is to
remove incompleteness (an incomplete requirement is one in which some
parts of the actual requirements have been omitted) and inconsistencies
(inconsistent requirement is one in which some part of the requirement
contradicts with some other part).
 Requirement specification: These analyzed requirements are
documented in a software requirement specification (SRS) document.
SRS document serves as a contract between development team and
customers. Any future dispute between the customers and the developers
can be settled by examining the SRS document.
3. Design: The aim of the design phase is to transform the requirements
specified in the SRS document into a structure that is suitable for
implementation in some programming language.
4. Coding and Unit testing: In coding phase software design is translated into
source code using any suitable programming language. Thus each designed
module is coded. The aim of the unit testing phase is to check whether each
module is working properly or not.
5. Integration and System testing: Integration of different modules are
undertaken soon after they have been coded and unit tested. Integration of
various modules is carried out incrementally over a number of steps.
During each integration step, previously planned modules are added to the
partially integrated system and the resultant system is tested. Finally, after
all the modules have been successfully integrated and tested, the full
working system is obtained and system testing is carried out on this.
System testing consists three different kinds of testing activities as
described below :

1.
 Alpha testing: Alpha testing is the system testing performed by the
development team.
 Beta testing: Beta testing is the system testing performed by a friendly
set of customers.
 Acceptance testing: After the software has been delivered, the customer
performed the acceptance testing to determine whether to accept the
delivered software or to reject it.

2. Maintainence: Maintenance is the most important phase of a software life

cycle. The effort spent on maintenance is the 60% of the total effort spent
to develop a full software. There are basically three types of maintenance :
 Corrective Maintenance: This type of maintenance is carried out to
correct errors that were not discovered during the product development
phase.
 Perfective Maintenance: This type of maintenance is carried out to
enhance the functionalities of the system based on the customer’s
request.
 Adaptive Maintenance: Adaptive maintenance is usually required for
porting the software to work in a new environment such as work on a
new computer platform or with a new operating system.
Advantages of Classical Waterfall Model
Classical waterfall model is an idealistic model for software development. It is
very simple, so it can be considered as the basis for other software
development life cycle models. Below are some of the major advantages of
this SDLC model:
 This model is very simple and is easy to understand.
 Phases in this model are processed one at a time.
 Each stage in the model is clearly defined.
 This model has very clear and well undestood milestones.
 Process, actions and results are very well documented.
 Reinforces good habits: define-before- design,
design-before-code.
 This model works well for smaller projects and projects where
requirements are well
understood.
Drawbacks of Classical Waterfall Model
Classical waterfall model suffers from various shortcomings, basically we
can’t use it in real projects, but we use other software development lifecycle
models which are based on the classical waterfall model. Below are some
major drawbacks of this model:
 No feedback path: In classical waterfall model evolution of a software
from one phase to another phase is like a waterfall. It assumes that no error
is ever committed by developers during any phases. Therefore, it does not
incorporate any mechanism for error correction.
 Difficult to accommodate change requests: This model assumes that all
the customer requirements can be completely and correctly defined at the
beginning of the project, but actually customers’ requirements keep on
changing with time. It is difficult to accommodate any change requests
after the requirements specification phase is complete.
 No overlapping of phases: This model recommends that new phase can
start only after the completion of the previous phase. But in real projects,
this can’t be maintained. To increase the efficiency and reduce the cost,
phases may overlap.
Incremental process model

Incremental process model is also know as Successive version model.

First, a simple working system implementing only a few basic features is built
and then that is delivered to the customer. Then thereafter many successive
iterations/ versions are implemented and delivered to the customer until the
desired system is released.

A, B, C are modules of Software Product that are incrementally developed and

delivered.
Life cycle activities –
Requirements of Software are first broken down into several modules that can
be incrementally constructed and delivered. At any time, the plan is made just
for the next increment and not for any kind of long term plans. Therefore, it is
easier to modify the version as per the need of the customer. Development
Team first undertakes to develop core features (these do not need services
from other features) of the system.

Once the core features are fully developed, then these are refined to increase
levels of capabilities by adding new functions in Successive versions. Each
incremental version is usually developed using an iterative waterfall model of
development.
As each successive version of the software is constructed and delivered, now
the feedback of the Customer is to be taken and these were then incorporated
in the next version. Each version of the software have more additional features
over the previous ones.
After Requirements gathering and specification, requirements are then spitted
into several different versions starting with version-1, in each successive
increment, next version is constructed and then deployed at the customer site.
After the last version (version n), it is now deployed at the client site.
Types of Incremental model –
1. Staged Delivery Model – Construction of only one part of the project at a
time.
2. Parallel Development Model – Different subsystems are developed at the
same time. It can decrease the calendar time needed for the development,
i.e. TTM (Time to Market), if enough Resources are available.

When to use this –

1. Funding Schedule, Risk, Program Complexity, or need for early realization
of benefits.
2. When Requirements are known up-front.
3. When Projects having lengthy developments schedules.
4. Projects with new Technology.
Advantages –
 Error Reduction (core modules are used by the customer from the
beginning of the phase and then these are tested thoroughly)
 Uses divide and conquer for breakdown of tasks.
 Lowers initial delivery cost.
 Incremental Resource Deployment.
Disadvantages –
 Requires good planning and design.
 Total cost is not lower.
 Well defined module interfaces are required.
Rapid application development model (RAD)
The Rapid Application Development Model was first proposed by IBM in
1980’s. The critical feature of this model is the use of powerful development
tools and techniques.
A software project can be implemented using this model if the project can be
broken down into small modules wherein each module can be assigned
independently to separate teams. These modules can finally be combined to
form the final product.
Development of each module involves the various basic steps as in waterfall
model i.e analyzing, designing, coding and then testing, etc. as shown in the
figure.
Another striking feature of this model is a short time span i.e the time frame
for delivery(time-box) is generally 60-90 days.

The use of powerful developer tools such as JAVA, C++, Visual BASIC,
XML, etc. is also an integral part of the projects.
This model consists of 4 basic phases:
1. Requirements Planning –
It involves the use of various techniques used in requirements elicitation
like brainstorming, task analysis, form analysis, user scenarios, FAST
(Facilitated Application Development Technique), etc. It also consists of
the entire structured plan describing the critical data, methods to obtain it
and then processing it to form final refined model.
2. User Description –
This phase consists of taking user feedback and building the prototype
 using developer tools. In other words, it includes re-examination and
validation of the data collected in the first phase. The dataset attributes are
also identified and elucidated in this phase.
3. Construction –
In this phase, refinement of the prototype and delivery takes place. It
includes the actual use of powerful automated tools to transform process
and data models into the final working product. All the required
modifications and enhancements are too done in this phase.
4. Cutover –
All the interfaces between the independent modules developed by separate
teams have to be tested properly. The use of powerfully automated tools
and subparts makes testing easier. This is followed by acceptance testing by
the user.
The process involves building a rapid prototype, delivering it to the customer
and the taking feedback. After validation by the customer, SRS document is
developed and the design is finalised.
Advantages –
 Use of reusable components helps to reduce the cycle time of the project.
 Feedback from the customer is available at initial stages.
 Reduced costs as fewer developers are required.
 Use of powerful development tools results in better quality products in
comparatively shorter time spans.
 The progress and development of the project can be measured through the
various stages.
 It is easier to accommodate changing requirements due to the short iteration
time spans.
Disadvantages –
 The use of powerful and efficient tools requires highly skilled
professionals.
 The absence of reusable components can lead to failure of the project.
 The team leader must work closely with the developers and customers to
close the project in time.
 The systems which cannot be modularized suitably cannot use this model.
 Customer involvement is required throughout the life cycle.
 It is not meant for small scale projects as for such cases, the cost of using
automated tools and techniques may exceed the entire budget of the project.
Applications –
1. This model should be used for a system with known requirements and
requiring short development time.
2. It is also suitable for projects where requirements can be modularized and
reusable components are also available for development.
3. The model can also be used when already existing system components can
be used in developing a new system with minimum changes.
4. This model can only be used if the teams consist of domain experts. This is
because relevant knowledge and ability to use powerful techniques is a
necessity.
5. The model should be chosen when the budget permits the use of automated
tools and techniques required.
Spiral Model
Spiral model is one of the most important Software Development Life Cycle
models, which provides support for Risk Handling. In its diagrammatic
representation, it looks like a spiral with many loops. The exact number of
loops of the spiral is unknown and can vary from project to project. Each loop
of the spiral is called a Phase of the software development process. The
exact number of phases needed to develop the product can be varied by the
project manager depending upon the project risks. As the project manager
dynamically determines the number of phases, so the project manager has an
important role to develop a product using the spiral model.
The Radius of the spiral at any point represents the expenses(cost) of the
project so far, and the angular dimension represents the progress made so far
in the current phase.
The below diagram shows the different phases of the Spiral Model: –

Each phase of the Spiral Model is divided into four quadrants as shown in the
above figure. The functions of these four quadrants are discussed below-
1. Objectives determination and identify alternative
solutions: Requirements are gathered from the customers and the
objectives are identified, elaborated, and analyzed at the start of every
phase. Then alternative solutions possible for the phase are proposed in this
quadrant.
2. Identify and resolve Risks: During the second quadrant, all the possible
solutions are evaluated to select the best possible solution. Then the risks
associated with that solution are identified and the risks are resolved using
 the best possible strategy. At the end of this quadrant, the Prototype is built
for the best possible solution.
3. Develop next version of the Product: During the third quadrant, the
identified features are developed and verified through testing. At the end of
the third quadrant, the next version of the software is available.
4. Review and plan for the next Phase: In the fourth quadrant, the
Customers evaluate the so far developed version of the software. In the end,
planning for the next phase is started.
Risk Handling in Spiral Model
A risk is any adverse situation that might affect the successful completion of a
software project. The most important feature of the spiral model is handling
these unknown risks after the project has started. Such risk resolutions are
easier done by developing a prototype. The spiral model supports copying up
with risks by providing the scope to build a prototype at every phase of the
software development.
The Prototyping Model also supports risk handling, but the risks must be
identified completely before the start of the development work of the project.
But in real life project risk may occur after the development work starts, in
that case, we cannot use the Prototyping Model. In each phase of the Spiral
Model, the features of the product dated and analyzed, and the risks at that
point in time are identified and are resolved through prototyping. Thus, this
model is much more flexible compared to other SDLC models.
Why Spiral Model is called Meta Model?
The Spiral model is called a Meta-Model because it subsumes all the other
SDLC models. For example, a single loop spiral actually represents
the Iterative Waterfall Model. The spiral model incorporates the stepwise
approach of the Classical Waterfall Model. The spiral model uses the approach
of the Prototyping Model by building a prototype at the start of each phase as
a risk-handling technique. Also, the spiral model can be considered as
supporting the evolutionary model – the iterations along the spiral can be
considered as evolutionary levels through which the complete system is built.
Advantages of Spiral Model:
Below are some advantages of the Spiral Model.
1. Risk Handling: The projects with many unknown risks that occur as the
development proceeds, in that case, Spiral Model is the best development
model to follow due to the risk analysis and risk handling at every phase.
2. Good for large projects: It is recommended to use the Spiral Model in
large and complex projects.
3. Flexibility in Requirements: Change requests in the Requirements at later
phase can be incorporated accurately by using this model.
4. Customer Satisfaction: Customer can see the development of the product
at the early phase of the software development and thus, they habituated
with the system by using it before completion of the total product.
Disadvantages of Spiral Model:
Below are some main disadvantages of the spiral model.
1. Complex: The Spiral Model is much more complex than other SDLC
models.
2. Expensive: Spiral Model is not suitable for small projects as it is
expensive.
3. Too much dependability on Risk Analysis: The successful completion of
the project is very much dependent on Risk Analysis. Without very highly
experienced experts, it is going to be a failure to develop a project using
this model.
4. Difficulty in time management: As the number of phases is unknown at
the start of the project, so time estimation is very difficult.
What is Concurrent Development model ?
The concurrent process model, sometimes called concurrent engineering.
Concurrent modeling defines a series of events that will trigger transitions from
state to state for each of the software engineering activities, actions, or tasks.
The concurrent model is often more appropriate for system engineering projects
where different engineering teams are involved. it also allows a software team
to represent iterative and concurrent elements of any of the process model.

The above figure provides a schematic representation of one Software

engineering task within the modeling activity for the concurrent process model.
The activity modeling may be in any one of the states noted at any given
time. All activities exist concurrently but reside in different states. For example,
early in the project the communication activity has completed its first iteration
and exists in the awaiting changes state. The modeling activity which existed in
the none state while initial communication was completed now makes a
transition into underdevelopment state. If, however, the customer indicates the
changes in requirements must be made, the modeling activity moves from the
under development state into the awaiting changes state.

The concurrent process model defines a series of events that will trigger
transitions from state to state for each of the Software engineering activities,
actions, or tasks.
Advantages of Concurrent process model :
1. This model is applicable to all types of software development
processes.
2. It is easy for understanding and use.
3. It gives immediate feedback from testing.
4. It provides an accurate picture of the current state of a project.
Disadvantages of Concurrent process model :
1. It needs better communication between the team members. This
may not be achieved all the time.
2. It requires to remember the status of the different activities.
Prototype Model
The prototype model requires that before carrying out the development of actual
software, a working prototype of the system should be built. A prototype is a toy
implementation of the system. A prototype usually turns out to be a very crude
version of the actual system, possible exhibiting limited functional capabilities, low
reliability, and inefficient performance as compared to actual software. In many
instances, the client only has a general view of what is expected from the software
product. In such a scenario where there is an absence of detailed information
regarding the input to the system, the processing needs, and the output requirement,
the prototyping model may be employed.

Steps of Prototype Model

1. Requirement Gathering and Analyst
 2. Quick Decision
3. Build a Prototype
4. Assessment or User Evaluation
5. Prototype Refinement
6. Engineer Product

Advantage of Prototype Model

1. Reduce the risk of incorrect user requirement
2. Good where requirement are changing/uncommitted
3. Regular visible process aids management
4. Support early product marketing
5. Reduce Maintenance cost.
6. Errors can be detected much earlier as the system is made side by side.

Disadvantage of Prototype Model

1. An unstable/badly implemented prototype often becomes the final product.
2. Require extensive customer collaboration
o Costs customer money
o Needs committed customer
o Difficult to finish if customer withdraw
o May be too customer specific, no broad market
3. Difficult to know how long the project will last.
4. Easy to fall back into the code and fix without proper requirement analysis, design,
customer evaluation, and feedback.
5. Prototyping tools are expensive.
6. Special tools & techniques are required to build a prototype.
7. It is a time-consuming process.

Evolutionary Process Model

Evolutionary process model resembles the iterative enhancement model. The same
phases are defined for the waterfall model occurs here in a cyclical fashion. This
model differs from the iterative enhancement model in the sense that this does not
require a useful product at the end of each cycle. In evolutionary development,
requirements are implemented by category rather than by priority.
For example, in a simple database application, one cycle might implement the
graphical user Interface (GUI), another file manipulation, another queries and
another updates. All four cycles must complete before there is a working product
available. GUI allows the users to interact with the system, file manipulation allow the
data to be saved and retrieved, queries allow user to get out of the system, and
updates allows users to put data into the system.

https://www.youtube.com/watch?v=ASrMUd0p9fE- difference between

different
Agile Model
The meaning of Agile is swift or versatile.

"Agile process model" refers to a software development approach based on

iterative development.

Agile methods break tasks into smaller iterations, or parts do not directly involve
long term planning.

The project scope and requirements are made at the beginning of the development
process.

Plans regarding the number of iterations, the duration and the scope of each
iteration are clearly defined in advance.

Each iteration is considered as a short time "frame" in the Agile process model,
which typically lasts from one to four weeks.

The division of the entire project into smaller parts helps to minimize the project
risk and to reduce the overall project delivery time requirements.

Each iteration involves a team working through a full software development life
cycle including :

planning,
requirements analysis,
design,
coding, and
testing before a working product is demonstrated to the client.

Principles of Agile model:

 To establish close contact with the customer during development and to gain
a clear understanding of various requirements, each Agile project usually
includes a customer representative on the team. At the end of each iteration
stakeholders and the customer representative review, the progress made and
re-evaluate the requirements.
 Agile model relies on working software deployment rather than
comprehensive documentation.
 Frequent delivery of incremental versions of the software to the customer
representative in intervals of few weeks.
  Requirement change requests from the customer are encouraged and
efficiently incorporated.
 It emphasizes on having efficient team members and enhancing
communications among them is given more importance. It is realized that
enhanced communication among the development team members can be
achieved through face-to-face communication rather than through the
exchange of formal documents.
 It is recommended that the development team size should be kept small (5 to
9 people) to help the team members meaningfully engage in face-to-face
communication and have collaborative work environment.

Phases of Agile Model:

Following are the phases in the Agile model are as follows:

1. Requirements gathering
2. Design the requirements
3. Construction/ iteration
4. Testing/ Quality assurance
5. Deployment
6. Feedback
1. Requirements gathering: In this phase, you must define the requirements. You
should explain business opportunities and plan the time and effort needed to build
the project. Based on this information, you can evaluate technical and economic
feasibility.

2. Design the requirements: When you have identified the project, work with
stakeholders to define requirements. You can use the user flow diagram or the high-
level UML diagram to show the work of new features and show how it will apply to
your existing system.

3. Construction/ iteration: When the team defines the requirements, the work
begins. Designers and developers start working on their project, which aims to
deploy a working product. The product will undergo various stages of improvement,
so it includes simple, minimal functionality.

4. Testing: In this phase, the Quality Assurance team examines the product's
performance and looks for the bug.

5. Deployment: In this phase, the team issues a product for the user's work
environment.

6. Feedback: After releasing the product, the last step is feedback. In this, the team
receives feedback about the product and works through the feedback.

When to use the Agile Model?

o When frequent changes are required.
o When a highly qualified and experienced team is available.
o When a customer is ready to have a meeting with a software team all the time.
o When project size is small.

Advantage(Pros) of Agile Method:

1. Frequent Delivery
2. Face-to-Face Communication with clients.
3. Efficient design and fulfils the business requirement.
4. Anytime changes are acceptable.
5. It reduces total development time.
6. Customer representatives get the idea of updated software products after each
iteration. So, it is easy for him to change any requirement if needed.

Disadvantages (Cons) of Agile Model:

1. Due to the shortage of formal documents, it creates confusion and crucial decisions
taken throughout various phases can be misinterpreted at any time by different team
members.
2.

Due to the lack of proper documentation, once the project completes and the developers
allotted to another project, maintenance of the finished project can become a difficulty

Example: Let’s go through an example to understand clearly about how agile

actually works.
A Software company named ABC wants to make a new web browser for the latest
release of its operating system. The deadline for the task is 10 months. The
company’s head assigned two teams named Team A and Team B for this task.

The Development plan of the Team A is as follows: Waterfall model

Requirement analysis and Gathering – 1.5 Months

Design of System – 2 Months
Coding phase – 4 Months
System Integration and Testing – 2 Months
User Acceptance Testing – 5 Weeks

The Development plan for the Team B is as follows: Agile as their development
model.

Since this was an Agile, the project was broken up into several iterations.
The iterations are all of the same time duration.
At the end of each iteration, a working product with a new feature has to be
delivered.
Instead of Spending 1.5 months on requirements gathering, They will decide the
core features that are required in the product and decide which of these features
can be developed in the first iteration.
Any remaining features that cannot be delivered in the first iteration will be
delivered in the next subsequent iteration, based in the priority
At the end of the first iterations, the team will deliver a working software with the
core basic features.

Both the team have put their best efforts to get the product to a complete stage.
But then out of blue due to the rapidly changing environment, the company’s head
 come up with an entirely new set of features and want to be implemented as
quickly as possible and wanted to push out a working model in 2 days. Team A was
now in a fix, they were still in their design phase and did not yet started coding and
they had no working model to display. And moreover, it was practically impossible
for them to implement new features since waterfall model there is not reverting
back to the old phase once you proceed to the next stage, that means they would
have to start from the square one again. That would incur them heavy cost and a
lot of overtime. Team B was ahead of Team A in a lot of aspects, all thanks to Agile
Development. They also had the working product with most of the core
requirement since the first increment. And it was a piece of cake for them to add
the new requirements. All they had to do is schedule these requirements for the
next increment and then implement them.

Agile Testing Methods:

o Scrum
o Crystal
o Dynamic Software Development Method(DSDM)
o Feature Driven Development(FDD)
o Lean Software Development
o eXtreme Programming(XP)

Scrum
Scrum is a framework that uses an iterative and incremental
structure for project management used in Agile software
development.
In other words; it delivers large projects in small chunks.
Scrum is the most popular and widely used Agile methodology.
It is a lightweight framework that helps teams and organizations
address complex problems and adapt to changing requirements.
It allows teams to adapt the processes to suit their project and
organization needs.
SCRUM is an agile development process focused primarily on ways to manage
tasks in team-based development conditions.

There are three roles in it, and their responsibilities are:

o Scrum Master: The scrum can set up the master team, arrange the meeting and
remove obstacles for the process
o Product owner: The product owner makes the product backlog, prioritizes the delay
and is responsible for the distribution of functionality on each repetition.
o Scrum Team: The team manages its work and organizes the work to complete the
sprint or cycle.

eXtreme Programming(XP)
This type of methodology is used when customers are constantly changing demands
or requirements, or when they are not sure about the system's performance.

Crystal:
There are three concepts of this method-

1. Chartering: Multi activities are involved in this phase such as making a development
team, performing feasibility analysis, developing plans, etc.
2. Cyclic delivery: under this, two more cycles consist, these are:
 o Team updates the release plan.
o Integrated product delivers to the users.
2. Wrap up: According to the user environment, this phase performs deployment, post-
deployment.

Dynamic Software Development Method(DSDM):

DSDM is a rapid application development strategy for software development and gives an
agile project distribution structure. The essential features of DSDM are that users must be
actively connected, and teams have been given the right to make decisions. The techniques
used in DSDM are:

1. Time Boxing
2. MoSCoW Rules
3. Prototyping
The DSDM project contains seven stages:

1. Pre-project
2. Feasibility Study
3. Business Study
4. Functional Model Iteration
5. Design and build Iteration
6. Implementation
7. Post-project

Feature Driven Development(FDD):

This method focuses on "Designing and Building" features. In contrast to other smart
methods, FDD describes the small steps of the work that should be obtained separately per
function.

1. Eliminating Waste
2. Amplifying learning
3. Defer commitment (deciding as late as possible)
4. Early delivery
5. Empowering the team
6. Building Integrity
7. Optimize the whol