UNIT I SOFTWARE PROCESS AND AGILE DEVELOPMENT

Introduction to Software Engineering, Software Process, Perspective and Specialized Process Models
–Introduction to Agility-Agile Process-Extreme programming-XP Process-Case Study.

1. Introduction to Software Engineering & Software process

Software engineering paradigm:

• The framework activities will always be applied on every project ... BUT the tasks (and degree
of rigor) for each activity will vary based on:
– the type of project
– characteristics of the project
– common sense judgment; concurrence of the project team
The software process:
• A structured set of activities required to develop a software system
– Specification;
– Design;
– Validation;
– Evolution.
• A software process model is an abstract representation of a process. It presents a description
of a process from some particular perspective.
• Systems Engineering
– Software as part of larger system, determine requirements for all system
elements, allocate requirements to software.
• Software Requirements Analysis
– Develop understanding of problem domain, user needs, function, performance,
interfaces, ...
– Software Design
–Multi-step process to determine architecture, interfaces, data structures,
functional detail. Produces (high-level) form that can be checked for
quality, conformance before coding.
• Coding
– Produce machine readable and executable form, match HW, OS and design needs.

• Testing
 – Confirm that components, subsystems and complete products meet requirements,
specifications and quality, find and fix defects.
• Maintenance
–Incrementally, evolve software to fix defects, add features, adapt to new condition.
Often 80% of effort spent here!

2. Perspective and specialized process models

1. Waterfall model phases:

• Requirements analysis and definition
• System and software design
• Implementation and unit testing
• Integration and system testing
• Operation and maintenance
The main drawback of the waterfall model is the difficulty of accommodating change after the
process is underway. One phase has to be complete before moving onto the next phase. Each phase
terminates only when the documents are complete and approved by the SQA group. Maintenance
begins
when the client reports an error after having accepted the product. It
could also begin due to a change in requirements after the client has accepted the product
Waterfall model: Advantages:
• Disciplined approach
• Careful checking by the Software Quality Assurance Group at the end of each phase.
• Testing in each phase.
• Documentation available at the end of each phase.
Waterfall model problems:
• It is difficult to respond to changing customer requirements.
• Therefore, this model is only appropriate when the requirements are well-understood
and changes will be fairly limited during the design process.
• Few business systems have stable requirements.
• The waterfall model is mostly used for large systems engineering projects where a
system is developed at several sites.
• The customer must have patience. A working version of the program will not be available
until late in the project time-span
• Feedback from one phase to another might be too late and hence expensive.
The Prototyping Models:
Often, a customer defines a set of general objectives for software but does not identify detailed
input, processing, or output requirements. In other cases, the developer may be unsure of the
efficiency of an algorithm, the adaptability of an operating system, or the form that human
machine interaction should take. In this case prototyping paradigm may offer the best approach
• Requirements gathering
• Quick design
• Prototype building
• Prototype evaluation by customers
• Prototype may be refined

Prototype thrown away and software developed using formal process. It is used to define the
requirement} Prototyping
Strengths:
 • Requirements can be set earlier and more reliably
• Customer sees results very quickly.
• Customer is educated in what is possible helping to refine requirements.
• Requirements can be communicated more clearly and completely
• Between developers and clients Requirements and design options
can be investigated quickly and Cheaply
Weaknesses:
–Requires a rapid prototyping tool and expertise in using it–a cost for
the development organisation
– Smoke and mirrors - looks like a working version, but it is not.
3.The RAD Model:
• Rapid Application Development is a linear sequential software development
process model that emphasizes an extremely short development cycle
• Rapid application achieved by using a component based construction approach
• If requirements are well understood and project scope is constrained the RAD
process enables a development team to create a ―fully functional

RAD phases :
• Busin
ess
model
ing
Data
model
ing
Process modeling
Application generation
Testing and turnover
Business modeling:
• What information drives the business process?
• What information is generated?
Data Modeling:
• The information flow defined as part of the business modeling phase is
refined into a set of data objects that are needed to support the business.
• The characteristics ( called attributes) of each object are identified and the
relationships between these objects are defined
Process modeling:
• The data modeling phase are transformed to achieve the information flow
necessary to implement a business function.
• Processing descriptions are created for adding , modifying, deleting, or retrieving
a data object
Application generation:
• RAD assumes the use of 4 generation techniques.
• Rather than creating software using conventional 3 generation programming
languages, the RAD process works to reuse existing program components (when
possible) or created reusable components (when necessary)
Testing and Turnover:
• Since the RAD process emphasizes reuse, many of the program components have
already been testing.
• This reduces over all testing time.
 • However, new components must be tested and all interfaces must be fully exercised

Advantages &Disadvantages of RAD:

Advantages
• Extremely short development time.
• Uses component-based construction and emphasizes reuse and code generation
Disadvantages
• Large human resource requirements (to create all of the teams).
• Requires strong commitment between developers and customers for “rapid-fire”
activities.
• High performance requirements maybe can’t be met

4. The Incremental Model

• Combination of linear + prototype

• Rather than deliver the system as a single delivery, the development and delivery is broken down
into increments with each increment delivering part of the required functionality
• User requirements are prioritised and the highest priority requirements are included in
early increments
• Once the development of an increment is started, the requirements are frozen though
requirements for later increments can continue to evolve
Incremental development advantages:
• The customer is able to do some useful work after release
• Lower risk of overall project failure
• The highest priority system services tend to receive the most testing

5.Spiral model sectors:

• Customer communication
Tasks required to establish effective communication between developer and
customer
• Planning
The tasks required to define recourses, timelines, and project is reviewed and the
next phase of the spiral is planned
• Risk analysis
– Risks are assessed and activities put in place to reduce the key
• Risks engineering
– Tasks required to build one or more representations of the application

• Construction & release

– Tasks required to construct, test, install and provide user support (e.g documentation
and training)
• Customer evaluation
– Customer feedback collected every stage
Spiral Model Advantages:
• Focuses attention on reuse options.
• Focuses attention on early error elimination.
• Puts quality objectives up front.
• Integrates development and maintenance.
• Provides a framework for hardware/software Development.

• Stated in a slightly more formal manner, the world view (WV) is composed of a
set of domains (Di), which can each be a system or system of systems in its
own right. WV = {D1, D2, D3, . . . , Dn}
• Each domain is composed of specific elements (Ej) each of which serves some
role in accomplishing the objective and goals of the domain or
component: Di = {E1, E2, E3, . . . , Em}
• Finally, each element is implemented by specifying the technical components
(Ck) that achieve the necessary function for an element:
Ej = {C1, C2, C3, . . . , Ck}

Computer Based System

Computer-based system as A set or arrangement of elements that are organized
to accomplish some predefined goal by processing information.
• The goal may be to support some business function or to develop a product that
can be sold to generate business revenue.
• To accomplish the goal, a computer-based system makes use of a variety of
system elements: 1. Software. Computer programs, data structures, and related
documentation that serve to
effect the logical method, procedure, or control that is required.
2. Hardware. Electronic devices that provide computing capability, the
interconnectivity devices (e.g., network switches, telecommunications
devices) that enable the flow of data, and electromechanical devices (e.g.,
sensors, motors, pumps) that provide external world function.
3. People. Users and operators of hardware and software.
4. Database. A large, organized collection of information that is accessed via software.
5. Documentation. Descriptive information (e.g., hardcopy manuals, on-line help files,
Web sites) that portrays the use and/or operation of the system.
6. Procedures. The steps that define the specific use of each system element or
the procedural context in which the system resides.
The elements combine in a variety of ways to transform information. For example,
a marketing department transforms raw sales data into a profile of the typical
purchaser of a product; a robot transforms a command file containing specific
instructions into a set of control signals that cause some specific physical action.
Creating an information system to assist the marketing department and control
software to support the robot both require system engineering.

One complicating characteristic of computer-based systems is that the elements

constituting one system may also represent one macro element of a still larger system.
The macro element is a computer-based system that is one part of a larger computer-
based system.
As an example, we consider a "factory automation system" that is essentially a
hierarchy of systems. At the lowest level of the hierarchy we have a numerical control
machine, robots, and data entry devices.
Each is a computer based system in its own right. The elements of the numerical
control machine include electronic and electromechanical hardware (e.g., processor
and memory, motors, sensors), software (for communications, machine control,
interpolation), people (the machine operator), a database (the stored NC program),
documentation, and procedures.
• A similar decomposition could be applied to the robot and data entry device. Each
is a computer-based system.
• At the next level in the hierarchy, a manufacturing cell is defined. The
manufacturing cell is a computer-based system that may have elements of its own
(e.g., computers, mechanical fixtures) and also integrates the macro elements that
we have called
numerical control machine, robot, and data entry device.

Business Process Engineering Overview

• The goal of business process engineering (BPE) is to define architectures that will
enable a business to use information effectively.
• When taking a world view of a company‘s information technology doubt that system
• engineering is required. Not only is the specification of the appropriate
computing architecture required, but the software architecture that populates the
―unique configuration of heterogeneous computing resources
• Business process engineering is one approach for creating an overall plan for
implementing the computing architecture.
• Three different architectures must be analyzed and designed within the context
of business objectives and goals:
•data architecture
•applications architecture
•technology infrastructure
• The data architecture provides a framework for the information needs of a
business or business function. The individual building blocks of the architecture
are the data objects that are used by the business. A data object contains a set of
attributes that define some aspect, quality, characteristic, or descriptor of the data
that are being described.
• The application architecture encompasses those elements of a system that
transform objects within the data architecture for some business purpose. In the
context of this book, we consider the application architecture to be the system of
programs (software) that performs this transformation. However, in a broader
context, the application architecture might incorporate the role of people (who
are information transformers and users) and business procedures that have not
been automated.
• The technology infrastructure provides the foundation for the data and application
architectures. The infrastructure encompasses the hardware and software that
are used to support the application and data. This includes computers, operating
systems, networks, telecommunication links, storage technologies, and the
architecture (e.g., client/server) that has been designed to implement these
technologies.
• The final BPE step—construction and integration focuses on implementation
detail. The architecture and infrastructure are implemented by constructing an
appropriate database and internal data structures, by building applications using
software components, and by selecting appropriate elements of a technology
infrastructure to support the design created during BSD. Each of these system
components must then be integrated to form a complete information system or
application.
• The integration activity also places the new information system into the business
area context, performing all user training and logistics support to achieve a
smooth transition.

Specialised Process Models

Specialized process models take on many of the characteristics of one or more of the traditional
models However, these models tend to be applied when a specialized or narrowly defined software
engineeringapproach is chosen.

There are 3 types of specialized process models:

1. Component Based Development

2. Formal Methods Model
3. Aspect Oriented Software development

1. Component Based Development : Commercial off-the-shelf (COTS) software

components, developed by vendors who offer them as products, provide targeted
functionality with well-defined interfaces that enable the component to be integrated
into the software that is to be built. The component-based development model
incorporates many of the characteristics of the spiral model. It is evolutionary in
nature, demanding an iterative approach to the creation of software. However, the
component-based development model constructs applications from prepackaged
software component. Modeling and construction activities begin with the
identification of candidate components.These components can be designed as either
conventional software modules or object- oriented classes or packages of classes.
Regardless of the technology that is used to create the components, the component-
based development model incorporates the following steps:
1. Available component-based products are researched and evaluated for the
application domain in question.
2. Component integration issues are considered.
3. A software architecture is designed to accommodate the components.
4. Components are integrated into the architecture.
5. Comprehensive testing is conducted to ensure proper functionality

The component-based development model leads to software reuse, and reusability

 providessoftware engineers with a number of measurable benefits. software
engineering team can achieve a reduction in development cycle time as well as a
reduction in project cost if component reuse becomes part of your culture.

2. Formal Methods Model : The formal methods model encompasses a set of

activities that leads to formal mathematical specification of computer software.
Formal methods enable to specify, develop, and verify a computer-based system by
applying a rigorous, mathematical notation. A variation on this approach, called
cleanroom software engineering is currently applied by some software development
organizations. When formal methods are used during development, they provide a
mechanism for eliminating many of the problems that are difficult to overcome using
other software engineering paradigms. Ambiguity, incompleteness, and inconsistency
can be discovered and corrected more easily,through the application of mathematical
analysis. When formal methods are used during design, they serve as a basis for
program verification and therefore enable you to discover and correct errors that
might otherwise go undetected. The formal methods model offers the promise of
defect-free software.There are some of the disadvantages too:
• The development of formal models is currently quite time consuming and
expensive.
• Because few software developers have the necessary background to apply
formalmethods, extensive training is required.
• It is difficult to use the models as a communication mechanism for
technicallyunsophisticated customers
3. Aspect Oriented Software Development: Regardless of the software process that
is chosen, the builders of complex software invariably implement a set of localized
features, functions, and information content. These localized software
characteristics are modeled as components and then constructed within the context
of a system architecture. As modern computer-based systems become more
sophisticated certain concerns span the entire architecture. Some concerns are high-
level properties of a system, Other concerns affect functions, while others are
systemic.
When concerns cut across multiple system functions, features, and information, they
are often referred to as crosscutting concerns. Aspectual requirements define those
crosscutting concerns that have an impact across the software architecture. Aspect-
orientedsoftware development (AOSD), often referred to as aspect-oriented
programming (AOP), is a relatively new software engineering paradigm that provides
a process and methodological approach for defining, specifying, designing, and
constructing aspects.
A distinct aspect-oriented process has not yet matured. However, it is likely that
such a process will adopt characteristics of both evolutionary and concurrent
process models. Theevolutionary model is appropriate as aspects are identified and
then constructed. The parallel nature of concurrent development is essential
because aspects are engineered independently of localized software components
 and yet, aspects have a direct impact on these components. It is essential to
instantiate asynchronous communication between the software process activities
applied to the engineering and construction of aspects and components.

Introduction to Agility and Agile process

The main aim of the Agile model is to facilitate quick project completion. To accomplish this task,
agility is required. Agility is achieved by fitting the process to the project and removing activities
that may not be essential for a specific project. Also, anything that is a waste of time and effort is
avoided.

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 laid down 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.
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

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.

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. Extreme programming is an Agile project
management methodology that targets speed and simplicity with short development cycles and less
documentation. The process structure is determined by five guiding values, five rules, and 12 XP
practices

Extreme programming (XP) is one of the most important software development frameworks of Agile
models. It is used to improve software quality and responsiveness to customer requirements. The
extreme programming model recommends taking the best practices that have worked well in the
past in program development projects to extreme levels.
Good practices need to be practiced in extreme programming: Some of the good practices that
have been recognized in the extreme programming model and suggested to maximize their use are
given below:
• Code Review: Code review detects and corrects errors efficiently. It suggests pair programming
as coding and reviewing of written code carried out by a pair of programmers who switch their
work between them every hour.
• Testing: Testing code helps to remove errors and improves its reliability. XP suggests test-
driven development (TDD) to continually write and execute test cases. In the TDD approach,
test cases are written even before any code is written.
• Incremental development: Incremental development is very good because customer feedback
is gained and based on this development team comes up with new increments every few days
after each iteration.
• Simplicity: Simplicity makes it easier to develop good-quality code as well as to test and debug
it.
• Design: Good quality design is important to develop good quality software. So, everybody
should design daily.
• Integration testing: It helps to identify bugs at the interfaces of different functionalities.
Extreme programming suggests that the developers should achieve continuous integration by
building and performing integration testing several times a day.
Basic principles of Extreme programming: XP is based on the frequent iteration through which
the developers implement User Stories. User stories are simple and informal statements of the
customer about the functionalities needed. A User Story is a conventional description by the user of
a feature of the required system. It does not mention finer details such as the different scenarios that
can occur. Based on User stories, the project team proposes Metaphors. Metaphors are a common
vision of how the system would work. The development team may decide to build a Spike for some
features. A Spike is a very simple program that is constructed to explore the suitability of a solution
being proposed. It can be considered similar to a prototype. Some of the basic activities that are
followed during software development by using the XP model are given below:
• Coding: The concept of coding which is used in the XP model is slightly different from
traditional coding. Here, the coding activity includes drawing diagrams (modeling) that will be
transformed into code, scripting a web-based system, and choosing among several alternative
solutions.
• Testing: The XP model gives high importance to testing and considers it to be the primary
factor in developing fault-free software.
• Listening: The developers need to carefully listen to the customers if they have to develop good
quality software. Sometimes programmers may not have the depth knowledge of the system to
be developed. So, the programmers should understand properly the functionality of the system
and they have to listen to the customers.
• Designing: Without a proper design, a system implementation becomes too complex, and very
difficult to understand the solution, thus making maintenance expensive. A good design results
elimination of complex dependencies within a system. So, effective use of suitable design is
emphasized.
• Feedback: One of the most important aspects of the XP model is to gain feedback to understand
the exact customer needs. Frequent contact with the customer makes the development
effective.
• Simplicity: The main principle of the XP model is to develop a simple system that will work
efficiently in the present time, rather than trying to build something that would take time and
may never be used. It focuses on some specific features that are immediately needed, rather
than engaging time and effort on speculations of future requirements.
• Pair Programming: XP encourages pair programming where two developers work together at
the same workstation. This approach helps in knowledge sharing, reduces errors, and improves
code quality.
• Continuous Integration: In XP, developers integrate their code into a shared repository
several times a day. This helps to detect and resolve integration issues early on in the
development process.
• Refactoring: XP encourages refactoring, which is the process of restructuring existing code to
make it more efficient and maintainable. Refactoring helps to keep the codebase clean,
organized, and easy to understand.
• Collective Code Ownership: In XP, there is no individual ownership of code. Instead, the entire
team is responsible for the codebase. This approach ensures that all team members have a
sense of ownership and responsibility towards the code.
• Planning Game: XP follows a planning game, where the customer and the development team
collaborate to prioritize and plan development tasks. This approach helps to ensure that the
team is working on the most important features and delivers value to the customer.
• On-site Customer: XP requires an on-site customer who works closely with the development
team throughout the project. This approach helps to ensure that the customer’s needs are
understood and met, and also facilitates communication and feedback.
Applications of Extreme Programming (XP): Some of the projects that are suitable to develop
using the XP model are given below:
• Small projects: The XP model is very useful in small projects consisting of small teams as
face-to-face meeting is easier to achieve.
• Projects involving new technology or Research projects: This type of project faces
changing requirements rapidly and technical problems. So XP model is used to complete this
type of project.
• Web development projects: The XP model is well-suited for web development projects as
the development process is iterative and requires frequent testing to ensure the system meets
the requirements.
• Collaborative projects: The XP model is useful for collaborative projects that require close
collaboration between the development team and the customer.
• Projects with tight deadlines: The XP model can be used in projects that have a tight
deadline, as it emphasizes simplicity and iterative development.
• Projects with rapidly changing requirements: The XP model is designed to handle rapidly
changing requirements, making it suitable for projects where requirements may change
frequently.
• Projects where quality is a high priority: The bureaucracy-basedXP model places a strong
emphasis on testing and quality assurance, making it a suitable approach for projects where
quality is a high priority.
Extreme Programming (XP) is an AThe ile software development methodology that focuses on
delivering high-quality software through frequent and continuous feedback, collaboration, and
adaptation. XP emphasizes a close working relationship between the development team, the
customer, and stakeholders, with an emphasis on rapid, iterative development and deployment.
Agile development approaches evolved in the 1990s as a reaction to documentation and
bureaucracy-based processes, particularly the waterfall approach. Agile approaches are based on
some common principles, some of which are:
1. Working software is the key measure of progress in a project.
2. For progress in a project, therefore software should be developed and delivered rapidly in
small increments.
3. Even late changes in the requirements should be entertained.
4. Face-to-face communication is preferred over documentation.
5. Continuous feedback and involvement of customers is necessary for developing good-quality
software.
6. A simple design which involves and improves with time is a better approach than doing an
elaborate design up front for handling all possible scenarios.
7. The delivery dates are decided by empowered teams of talented individuals.
Extreme programming is one of the most popular and well-known approaches in the family of agile
methods. an XP project starts with user stories which are short descriptions of what scenarios the
customers and users would like the system to support. Each story is written on a separate card, so
they can be flexibly grouped.
XP, and other agile methods, are suitable for situations where the volume and space of
requirements change are high and where requirement risks are considerable.
XP includes the following practices:
1. Continuous Integration: Code is integrated and tested frequently, with all changes reviewed
by the development team.
2. Test-Driven Development: Tests are written before code is written, and the code is developed
to pass those tests.
3. Pair Programming: Developers work together in pairs to write code and review each other’s
work.
4. Continuous Feedback: Feedback is obtained from customers and stakeholders through
frequent demonstrations of working software.
5. Simplicity: XP prioritizes simplicity in design and implementation, to reduce complexity and
improve maintainability.
6. Collective Ownership: All team members are responsible for the code, and anyone can make
changes to any part of the codebase.
7. Coding Standards: Coding standards are established and followed to ensure consistency and
maintainability of the code.
8. Sustainable Pace: The pace of work is maintained at a sustainable level, with regular breaks
and opportunities for rest and rejuvenation.
9. XP is well-suited to projects with rapidly changing requirements, as it emphasizes flexibility
and adaptability. It is also well-suited to projects with tight timelines, as it emphasizes rapid
development and deployment.
10. Refactoring: Code is regularly refactored to improve its design and maintainability, without
changing its functionality.
11. Small Releases: Software is released in small increments, allowing for frequent feedback and
adjustments based on that feedback.
12. Customer Involvement: Customers are actively involved in the development process,
providing feedback and clarifying requirements.
13. On-Site Customer: A representative from the customer’s organization is present with the
development team to provide continuous feedback and answer questions.
14. Short Iterations: Work is broken down into short iterations, usually one to two weeks in
length, to allow for rapid development and frequent feedback.
15. Planning Game: The team and customer work together to plan and prioritize the work for
each iteration, to deliver the most valuable features first.
16. Metaphor: A shared metaphor is used to guide the design and implementation of the system.
17. Coding Standards: Coding standards are established and followed to ensure consistency and
maintainability of the code.
Advantages of Extreme Programming (XP):
• Slipped schedules − Timely delivery is ensured through slipping timetables and doable
development cycles.
• Misunderstanding the business and/or domain − Constant contact and explanations are
ensured by including the client on the team.
• Canceled projects − Focusing on ongoing customer engagement guarantees open
communication with the consumer and prompt problem-solving.
• Staff turnover − Teamwork that is focused on cooperation provides excitement and goodwill.
Team spirit is fostered by multidisciplinary cohesion.
• Costs incurred in changes − Extensive and continuing testing ensures that the modifications
do not impair the functioning of the system. A functioning system always guarantees that
there is enough time to accommodate changes without impairing ongoing operations.
• Business changes − Changes are accepted at any moment since they are seen to be
inevitable.
• Production and post-delivery defects: Emphasis is on − the unit tests to find and repair
bugs as soon as possible.

• Small projects: The XP model is very useful in small projects consisting of small teams as
face-to-face meeting is easier to achieve.
• Projects involving new technology or Research projects: This type of project faces
changing requirements rapidly and technical problems. So XP model is used to complete this
type of project.
• Web development projects: The XP model is well-suited for web development projects as
the development process is iterative and requires frequent testing to ensure the system meets
the requirements.
• Collaborative projects: The XP model is useful for collaborative projects that require close
collaboration between the development team and the customer.
• Projects with tight deadlines: The XP model can be used in projects that have a tight
deadline, as it emphasizes simplicity and iterative development.
• Projects with rapidly changing requirements: The XP model is designed to handle rapidly
changing requirements, making it suitable for projects where requirements may change
frequently.
• Projects where quality is a high priority: The bureaucracy-basedXP model places a strong
emphasis on testing and quality assurance, making it a suitable approach for projects where
quality is a high priority.

Extreme Programming (XP) is an Agiile software development methodology that focuses on

delivering high-quality software through frequent and continuous feedback, collaboration, and
adaptation. XP emphasizes a close working relationship between the development team, the
customer, and stakeholders, with an emphasis on rapid, iterative development and deployment.
Agile development approaches evolved in the 1990s as a reaction to documentation and
bureaucracy-based processes, particularly the waterfall approach. Agile approaches are based on
some common principles, some of which are:
1. Working software is the key measure of progress in a project.
2. For progress in a project, therefore software should be developed and delivered rapidly in
small increments.
3. Even late changes in the requirements should be entertained.
4. Face-to-face communication is preferred over documentation.
5. Continuous feedback and involvement of customers is necessary for developing good-quality
software.
6. A simple design which involves and improves with time is a better approach than doing an
elaborate design up front for handling all possible scenarios.
7. The delivery dates are decided by empowered teams of talented individuals.
Extreme programming is one of the most popular and well-known approaches in the family of agile
methods. an XP project starts with user stories which are short descriptions of what scenarios the
customers and users would like the system to support. Each story is written on a separate card, so
they can be flexibly grouped.
XP, and other agile methods, are suitable for situations where the volume and space of
requirements change are high and where requirement risks are considerable.

XP includes the following practices:

1. Continuous Integration: Code is integrated and tested frequently, with all changes reviewed
by the development team.
2. Test-Driven Development: Tests are written before code is written, and the code is developed
to pass those tests.
3. Pair Programming: Developers work together in pairs to write code and review each other’s
work.
4. Continuous Feedback: Feedback is obtained from customers and stakeholders through
frequent demonstrations of working software.
5. Simplicity: XP prioritizes simplicity in design and implementation, to reduce complexity and
improve maintainability.
6. Collective Ownership: All team members are responsible for the code, and anyone can make
changes to any part of the codebase.
7. Coding Standards: Coding standards are established and followed to ensure consistency and
maintainability of the code.
8. Sustainable Pace: The pace of work is maintained at a sustainable level, with regular breaks
and opportunities for rest and rejuvenation.
9. XP is well-suited to projects with rapidly changing requirements, as it emphasizes flexibility
and adaptability. It is also well-suited to projects with tight timelines, as it emphasizes rapid
development and deployment.
10. Refactoring: Code is regularly refactored to improve its design and maintainability, without
changing its functionality.
11. Small Releases: Software is released in small increments, allowing for frequent feedback and
adjustments based on that feedback.
12. Customer Involvement: Customers are actively involved in the development process,
providing feedback and clarifying requirements.
13. On-Site Customer: A representative from the customer’s organization is present with the
development team to provide continuous feedback and answer questions.
14. Short Iterations: Work is broken down into short iterations, usually one to two weeks in
length, to allow for rapid development and frequent feedback.
15. Planning Game: The team and customer work together to plan and prioritize the work for
each iteration, to deliver the most valuable features first.
16. Metaphor: A shared metaphor is used to guide the design and implementation of the system.
17. Coding Standards: Coding standards are established and followed to ensure consistency and
maintainability of the code.

Advantages of Extreme Programming (XP):

• Slipped schedules − Timely delivery is ensured through slipping timetables and doable
development cycles.
• Misunderstanding the business and/or domain − Constant contact and explanations are
ensured by including the client on the team.
• Canceled projects − Focusing on ongoing customer engagement guarantees open
communication with the consumer and prompt problem-solving.
• Staff turnover − Teamwork that is focused on cooperation provides excitement and goodwill.
Team spirit is fostered by multidisciplinary cohesion.
• Costs incurred in changes − Extensive and continuing testing ensures that the modifications
do not impair the functioning of the system. A functioning system always guarantees that
there is enough time to accommodate changes without impairing ongoing operations.
• Business changes − Changes are accepted at any moment since they are seen to be
inevitable.
• Production and post-delivery defects: Emphasis is on − the unit tests to find and repair
bugs as soon as possible.

Extreme programming practices:

The practices of XP are a set of specific rules and methods that distinguishes it from other
methodologies. When used in conjunction, they reinforce each other, help mitigate the risks of the
development process, and lead to the expected high-quality result. XP suggests using 12 practices
while developing software which can be clustered into four groups.

Test-Driven Development
Is it possible to write a clear code quickly? The answer is yes, according to XP practitioners. The
quality of software derives from short development cycles that, in turn, allow for receiving
frequent feedback. And valuable feedback comes from good testing. XP teams practice test-driven
development technique (TDD) that entails writing an automated unit test before the code itself.
According to this approach, every piece of code must pass the test to be released. So, software
engineers thereby focus on writing code that can accomplish the needed function. That's the way
TDD allows programmers to use immediate feedback to produce reliable software. You can learn
more about improving software testing in our dedicated article.

The Planning Game

This is a meeting that occurs at the beginning of an iteration cycle. The development team and the
customer get together to discuss and approve a product's features. At the end of the planning
game, developers plan for the upcoming iteration and release, assigning tasks for each of them.

On-site Customer
As we already mentioned, according to XP, the end customer should fully participate in
development. The customer should be present all the time to answer team questions, set
priorities, and resolve disputes if necessary.

Pair Programming
This practice requires two programmers to work jointly on the same code. While the first
developer focuses on writing, the other one reviews code, suggests improvements, and fixes
mistakes along the way. Such teamwork results in high-quality software and faster knowledge
sharing but takes about 15 percent more time. In this regard, it’s more reasonable trying pair
programming for long-term projects.

Code Refactoring
To deliver business value with well-designed software in every short iteration, XP teams also use
refactoring. The goal of this technique is to continuously improve code. Refactoring is about
removing redundancy, eliminating unnecessary functions, increasing code coherency, and at the
same time decoupling elements. Keep your code clean and simple, so you can easily understand
and modify it when required would be the advice of any XP team member

.
Extreme programming advantages

So, the XP framework can be beneficial and help reduce development time and costs for the
following reasons:

• Continuous testing and refactoring practices help create stable well-performing systems
with minimal debugging;
• Simplicity value implies creating a clear, concise code that is easy to read and change in
the future if needed;
• The minimalistic iterative approach to development ensures that the workable results can
be delivered very soon and only necessary features are built;
• Documentation is reduced as bulky requirements documents are substituted by user
stories;
• No or very little overtime is practiced;
• Constant communication provides a high level of visibility and accountability and allows
all team members to keep up with the project progress;
• Pair programming has proven to result in higher-quality products with fewer bugs; most
research participants also reported enjoying such collaboration more and feeling more
confident about their job;
• Customer engagement ensures their satisfaction as their participation in the development
and testing process can directly influence the result, getting them exactly what they
wanted.
•
Extreme programming disadvantages

On the other hand, XP has a number of disadvantages that have to be considered when deciding
on which framework to choose for your next project:
1. In many instances, the customer has no clear picture of the end result, which
makes it almost unrealistic to accurately estimate scope, cost, and time;
2. Regular meetings with customers often take a great deal of time that could instead
be spent on actual code writing;
3. Documentation can be scarce and lack clear requirements and specifications,
leading to project scope creep;
4. The rapid transition from traditional methods of software development to
extreme programming demands significant cultural and structural changes;
5. Pair programming takes more time and doesn’t always work right due to the
human factor and character incompatibility;
6. XP works best with collocated teams and customers present in person to conduct
face-to-face meetings, limiting its application with distributed teams;
7. Sometimes customers have neither the desire, time, nor expertise to participate in
product development. Considering tight deadlines, it can become a source of stress
as either no valuable feedback is provided, or a non-technical representative
attempts to manage tech specialists with little or no knowledge on the process;
8. Some authors also mention over focusing on code over design, lack of quality
assurance, code duplication, and poor results with inexperienced developers.
9. Any company can apply the XP principles in its projects; however, it’s important to
understand both the good and the bad sides. Read on to find out how XP is
different from other methodologies and when applying its techniques would be
the best choice.