Unit I

• The software is a collection of integrated programs.

• Software subsists of carefully-organized instructions and code written
by developers on any of various particular computer languages.
• Computer programs and related documentation such as
requirements, design models and user manuals.
• Engineering is the application of scientific and practical knowledge
to invent, design, build, maintain, and improve frameworks,
processes, etc.
Need of Software Engineering
• Huge Programming: It is simpler to manufacture a wall than to a house or
building, similarly, as the measure of programming become extensive engineering
has to step to give it a scientific process.
• Adaptability: If the software procedure were not based on scientific and
engineering ideas, it would be simpler to re-create new software than to scale an
existing one.
• Cost: As the hardware industry has demonstrated its skills and huge
manufacturing has let down the cost of computer and electronic hardware. But
the cost of programming remains high if the proper process is not adapted.
• Dynamic Nature: The continually growing and adapting nature of programming
hugely depends upon the environment in which the client works. If the quality of
the software is continually changing, new upgrades need to be done in the
existing one.
• Quality Management: Better procedure of software development provides a
better and quality software product.
Importance of Software Engineering
Evolution of Software Engineering : From an
Art To Engineering Discipline
• Software Engineering is a systematic and cost-effective technique for
Software Development. It is an engineering approach to develop
Software.
• For example: If someone wants to travel from Bangalore to
Hyderabad. There are two approaches one can follow to achieve the
same result:

• The normal approach is just to go out and catch the bus/train that is available.
• A systematic approach is constructed as Firstly check on Google Maps about
distance and after analyzing the timing of trains and buses online and after
that, match user’s preference suppose user have some work till 4:00 PM and
trains slot are: 1:00 PM, 6:00 PM then the user will choose 6:00 PM time slot
and reach Delhi.
• Software engineering has evolved over time from being considered an
art to becoming a recognized engineering discipline.
• In the early days of computing, software development was primarily
done by individuals or small teams who wrote code based on their
own experiences and knowledge.
• This approach was often referred to as “hacking” or “programming by
intuition.”
• As the field of computing grew, it became apparent that this approach
was not sustainable and that a more structured and systematic
approach was needed.
• In the 1960s and 1970s, the field of software engineering began to
take shape.
• Researchers and practitioners began to develop formal methods for
software design and development, such as structured programming
and the use of flowcharts to represent algorithms.
• In 1968, a conference on software engineering was held, and the
term “software engineering” was officially coined.
• In the following decades, software engineering continued to evolve and
mature.
• The introduction of object-oriented programming in the 1980s led to a shift
in how software was designed and developed.
• The 1990s saw the emergence of the Agile software development
methodologies, which emphasized flexibility and responsiveness to change.
• Today, software engineering is a well-established field with its own set of
best practices, methodologies, and tools.
• It is considered as a discipline of engineering and follows the same
principles like any other engineering field.
• In summary, software engineering has evolved from an art to a
discipline with its own set of best practices, methodologies, and tools.
• The field has grown and matured over time, with new technologies
and approaches being developed to improve the design and
development of software.
• Software Engineering principles have evolved over the last sixty years
with the contributions of various researchers and software
professionals.
• From the beginning period Software Engineering acts as an Art after
that with time, it transformed into a craft and finally to Engineering
Discipline.
• Initially, Programmers used an Ad Hoc programming style.
• Ad Hoc programming is an approachable solution in an unplanned or
unorganized manner.
• In this type of Programming Style, no plan is created on how to create
Structure and Steps to complete the programming task but without
having any systematic approach the problem needs to be solved in
the required time.
• This style is now referred to as exploratory, build and fix, and code
and fix styles.
Benefits of Software Engineering
• Improved quality: By following established best practices and
methodologies, software engineers are able to produce higher quality
software that is more reliable and less prone to errors.
• Increased productivity: Formal methods and tools can help software
engineers work more efficiently and effectively, leading to increased
productivity.
• Greater predictability: By following a structured and systematic approach,
software engineers can make more accurate predictions about the time
and resources required to complete a project.
• Better communication: Software engineering practices can help ensure
that all stakeholders, including developers, managers, and clients, have a
clear understanding of the project’s goals and requirements.
Benefits of Software Engineering
• Greater maintainability: Software engineering practices can help
ensure that the software is designed in a way that makes it easy to
maintain and update over time.
• Better cost management: By following established best practices and
methodologies, software engineers can reduce the cost of
development, testing and maintenance of software.
• Better Scalability: Software engineering provides the process and
methodologies to design the software in a way that it is easy to scale
up or down as per the requirement.
Software Life cycle models
• A software life cycle model (also termed process model) is a pictorial
and diagrammatic representation of the software life cycle. A life
cycle model represents all the methods required to make a software
product transit through its life cycle stages. It also captures the
structure in which these methods are to be undertaken.
Waterfall Model
• It is a simple model that is easy to use as
well as understand where the execution
happens in the sequence order, which means
that the outcome of the one-stage is equal to
the input of another stage. That's why it is
also known as the Linear-sequential life cycle
model.
• Each stage of the waterfall model involves
the deliverable of the previous stage, like
requirements, are transferred to the design
phase, design moved to development, and so
on.
• When we have the Life critical (hospital
application) and Machine critical (Military
project), we will widely use the waterfall
model.
When to use?
• When the requirements are constant and not changed regularly.
• A project is short
• The situation is calm
• Where the tools and technology used is consistent and is not
changing
• When resources are well prepared and are available to use.
Advantages of Waterfall model
• This model is simple to implement also the number of resources that
are required for it is minimal.
• The requirements are simple and explicitly declared; they remain
unchanged during the entire project development.
• The start and end points for each phase is fixed, which makes it easy
to cover progress.
• The release date for the complete product, as well as its final cost,
can be determined before development.
• It gives easy to control and clarity for the customer due to a strict
reporting system.
Disadvantages of Waterfall model
• In this model, the risk factor is higher, so this model is not suitable for
more significant and complex projects.
• This model cannot accept the changes in requirements during
development.
• It becomes tough to go back to the phase. For example, if the
application has now shifted to the coding phase, and there is a
change in requirement, It becomes tough to go back and change it.
• Since the testing done at a later stage, it does not allow identifying
the challenges and risks in the earlier phase, so the risk reduction
strategy is difficult to prepare.
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.
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
1. Costs customer money
2. Needs committed customer
3. Difficult to finish if customer withdraw
4. 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.
• 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.
Benefits of Evolutionary Process Model
• EVO can reduce costs by providing a structured, disciplined avenue for
experimentation.
• EVO allows the marketing department access to early deliveries, facilitating
the development of documentation and demonstration.
• Better fit the product to user needs and market requirements.
• Manage project risk with the definition of early cycle content.
• Uncover key issues early and focus attention appropriately.
• Increase the opportunity to hit market windows.
• Accelerate sales cycles with early customer exposure.
• Increase management visibility of project progress.
• Increase product team productivity and motivations.
Spiral Model
• The Spiral Model is a Software
Development Life Cycle (SDLC)
model that provides a
systematic and iterative
approach to software
development. In its
diagrammatic representation,
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.
When to Use?
• When deliverance is required to be frequent.
• When the project is large
• When requirements are unclear and complex
• When changes may require at any time
• Large and high budget projects
Advantages
• High amount of risk analysis
• Useful for large and mission-critical projects.
Disadvantages
• Can be a costly model to use.
• Risk analysis needed highly particular expertise
• Doesn't work well for smaller projects.
Feasible Study
• A feasibility study analyzes the viability of a proposed project or
venture.
• It is used to evaluate a project's potential, including the technical,
financial, and economic aspects, and to determine whether it should
proceed.
• A feasibility study aims to identify and assess a proposed project's
strengths, weaknesses, opportunities, and threats to determine its
potential for success.
Feasibility Study Process
Benefits of Feasibility
• Feasibility studies provide several advantages, including aiding project
directors in understanding the benefits and drawbacks of performing
work before investing significant time and money into it.
• Feasibility studies may also provide critical information to an
organization's management team, preventing them from embarking
on a risky project.
• Such studies help firms decide how they will grow. They will learn
how they will function, what potential roadblocks exist, who their
competitors are, and what the market is like. Feasibility studies can
aid in convincing financial backers and brokers that investing in a
given project or firm is a sensible move.
How to Conduct a Feasible Study
• Conduct a preliminary evaluation, which involves gathering feedback on the new
proposal from appropriate partners.
• To guarantee that the information obtained in the early stages of the study is robust,
break it down and pose questions about it.
• Conduct market research or statistical survey to identify market interest and
opportunities for pursuing the activity or business.
• Create a traditional, functional, or field-tested approach that determines how much
labour is necessary, how much it will cost, and how long it will take.
• Create a predicted pay announcement that includes income, working expenditures, and
benefits.
• Create an accounting report for the first day of the season.
• Recognize barriers and potential vulnerabilities and how to deal with them.
• Make a fundamental "go" or "off limits" decision regarding moving forward with the
arrangement.
Functional and non-functional requirements
Functional Requirements
• Functional requirements define a function that a system or system
element must be qualified to perform and must be documented in
different forms.
• The functional requirements describe the behavior of the system as it
correlates to the system's functionality.
• Functional requirements should be written in a simple language, so
that it is easily understandable.
• The examples of functional requirements are authentication, business
rules, audit tracking, certification requirements, transaction
corrections, etc.
Non-functional requirements
• Non-functional requirements are not related to the software's
functional aspect. They can be the necessities that specify the criteria
that can be used to decide the operation instead of specific behaviors
of the system. Basic non-functional requirements are - usability,
reliability, security, storage, cost, flexibility, configuration,
performance, legal or regulatory requirements, etc.
• They are divided into two main categories:
• Execution qualities like security and usability, which are observable at run
time.
• Evolution qualities like testability, maintainability, extensibility, and scalability
that embodied in the static structure of the software system.
Requirement Gathering
• Brainstorming • Reverse Engineering
• Document Analysis • Survey/Questionnaire
• Focus Group
• Interface analysis
• Interview
• Observation
• Prototyping
• Requirement Workshops
Requirements Analysis
• Requirement analysis is significant and essential activity after elicitation.
• We analyze, refine, and scrutinize the gathered requirements to make
consistent and unambiguous requirements.
• This activity reviews all requirements and may provide a graphical view of
the entire system.
• After the completion of the analysis, it is expected that the
understandability of the project may improve significantly.
• Here, we may also use the interaction with the customer to clarify points of
confusion and to understand which requirements are more important than
others.
Steps of Requirement Analysis
Steps of Requirement Analysis
• Context Diagram

• Development of a Prototype (optional)

• Model the requirements

• Finalize the requirements

Agile Development
• Technology in this current era is progressing faster than ever, forcing global
software companies to work in a fast-paced changing environment.
• The conventional software models such as the Waterfall Model that
depend on completely specifying the requirements, designing, and testing
the system are not geared towards rapid software development.
• As a consequence, a conventional software development model fails to
deliver the required product.
• This is where agile software development comes to the rescue. It was
specially designed to curate the needs of the rapidly changing environment
by embracing the idea of incremental development and developing the
actual final product.
Principles of Agile
1. Our highest priority is to satisfy the customer through early and continuous
delivery of valuable software.
2. Welcome changing requirements, even late in development. Agile processes
harness change for the customer’s competitive advantage.
3. Deliver working software frequently, from a couple of weeks to a couple of
months, with a preference to the shorter timescale.
4. Business people and developers must work together daily throughout the
project.
5. Build projects around motivated individuals. Give them the environment and
support they need, and trust them to get the job done.
Principles of Agile
6. The most efficient and effective method of conveying information to
and
within a development team is face-to-face conversation.
7. Working software is the primary measure of progress.
8. Agile processes promote sustainable development. The sponsors,
developers, and users should be able to maintain a constant pace
indefinitely.
9. Continuous attention to technical excellence and good design
enhances agility.
10. Simplicity—the art of maximizing the amount of work not done—is
essential.
11. The best architectures, requirements, and designs emerge from
self–organizing teams.
12. At regular intervals, the team reflects on how to become more
effective, then tunes and adjusts its behavior accordingly.
The Agile Software Development Process
The Agile Software Development Process
• Requirements Gathering: The customer’s requirements for the software
are gathered and prioritized.
• Planning: The development team creates a plan for delivering the software,
including the features that will be delivered in each iteration.
• Development: The development team works to build the software, using
frequent and rapid iterations.
• Testing: The software is thoroughly tested to ensure that it meets the
customer’s requirements and is of high quality.
• Deployment: The software is deployed and put into use.
• Maintenance: The software is maintained to ensure that it continues to
meet the customer’s needs and expectations.
Agile Software development cycle
• concept • release
• Inception • production
• Iteration/construction • retirement
• Step 1: In the first step, concept, and business opportunities in each
possible project are identified and the amount of time and work needed to
complete the project is estimated. Based on their technical and financial
viability, projects can then be prioritized and determined which ones are
worthwhile pursuing.
• Step 2: In the second phase, known as inception, the customer is consulted
regarding the initial requirements, team members are selected, and
funding is secured. Additionally, a schedule outlining each team’s
responsibilities and the precise time at which each sprint’s work is
expected to be finished should be developed.
• Step 3: Teams begin building functional software in the third step,
iteration/construction, based on requirements and ongoing feedback.
Iterations, also known as single development cycles, are the foundation of
the Agile software development cycle.
Design Process of Agile software
Development
• In Agile development, Design and Implementation are considered to be the
central activities in the software process.
• The design and Implementation phase also incorporates other activities such as
requirements elicitation and testing.
• In an agile approach, iteration occurs across activities. Therefore, the
requirements and the design are developed together, rather than separately.
• The allocation of requirements and the design planning and development as
executed in a series of increments. In contrast with the conventional model,
where requirements gathering needs to be completed to proceed to the design
and development phase, it gives Agile development an extra level of flexibility.
• An agile process focuses more on code development rather than documentation.
Human Factors
• “Agile development focuses on the talents and skills of individuals,
molding the process to specific people and teams.”
• Competence
• Common focus
• Collaboration
• Decision-making ability
• Fuzzy problem-solving ability
• Mutual trust and respect
• Self-organization
Example of Agile Software Development
• 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.
Example of Agile Software Development
• Team A follows the traditional method
• 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
Example of Agile Software Development
• Team B follows agile process
• 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 on the priority.
• At the end of the first iterations, the team will deliver working software with
the core basic features.
Advantages Agile Software Development
• Deployment of software is quicker and thus helps in increasing the trust of
the customer.
• Can better adapt to rapidly changing requirements and respond faster.
• Helps in getting immediate feedback which can be used to improve the
software in the next increment.
• People – Not Process. People and interactions are given a higher priority
than processes and tools.
• Continuous attention to technical excellence and good design.
• Increased collaboration and communication: Agile Software Development
Methodology emphasize collaboration and communication among team
members, stakeholders, and customers. This leads to improved
understanding, better alignment, and increased buy-in from everyone
involved.
Advantages Agile Software Development
• Flexibility and adaptability
• Improved quality and reliability
• Enhanced customer satisfaction
• Increased team morale and motivation
Disadvantages Agile Software Development
• In the case of large software projects, it is difficult to assess the effort
required at the initial stages of the software development life cycle.
• Agile Development is more code-focused and produces less
documentation.
• Agile development is heavily dependent on the inputs of the
customer. If the customer has ambiguity in his vision of the outcome,
it is highly likely that the project to get off track.
• Face-to-face communication is harder in large-scale organizations.
• Only senior programmers are capable of making the kind of decisions
required during the development process.
Disadvantages Agile Software Development
• Lack of predictability
• Limited scope control
• Lack of emphasis on testing
• Risk of team burnout
• Lack of structure and governance
Practices of Agile Software Development
• Scrum: Scrum is a framework for agile software development that involves iterative
cycles called sprints, daily stand-up meetings, and a product backlog that is prioritized by
the customer.
• Kanban: Kanban is a visual system that helps teams manage their work and improve their
processes. It involves using a board with columns to represent different stages of the
development process, and cards or sticky notes to represent work items.
• Continuous Integration: Continuous Integration is the practice of frequently merging
code changes into a shared repository, which helps to identify and resolve conflicts early
in the development process.
• Test-Driven Development: Test-Driven Development (TDD) is a development practice
that involves writing automated tests before writing the code. This helps to ensure that
the code meets the requirements and reduces the likelihood of defects.
• Pair Programming: Pair programming involves two developers working together on the
same code. This helps to improve code quality, share knowledge, and reduce the
likelihood of defects.
Other Agile Methods
• Adaptive Software Development (ASD)
• Scrum
• Dynamic Systems Development Method (DSDM)
• Crystal
• Feature Drive Development (FDD)
• Lean Software Development (LSD)
• Agile Modeling (AM)
• Agile Unified Process (AUP)
Adaptive Software Development (ASD)
• Adaptive Software Joint
Development (ASD) has Application
Development
been proposed by Jim
Highsmith as a technique for
building complex software
and systems.
• The philosophical
underpinnings of ASD focus
on human collaboration and
team self-organization.
Advantages of Agile Software Development over
traditional software development approaches
• Increased customer satisfaction
• Faster time-to-market
• Reduced risk
• Improved team collaboration
• Adaptability to change
• Better quality software
• Increased transparency
• Higher productivity
• Improved project control
Scrum
• Scrum (the name is derived from an activity that occurs during a
rugby match) is an agile software development method that was
conceived by Jeff Sutherland and his development team in the early
1990s.
• In recent years, further development on the Scrum methods has been
performed by Schwaber and Beedle
• Scrum principles are consistent with the agile manifesto and are used
to guide development activities within a process that incorporates the
following framework activities: requirements, analysis, design,
evolution, and delivery.
Scrum
• Backlog—a prioritized list of project requirements or features that
provide business value for the customer
• Sprints—consist of work units that are required to achieve a
requirement defined in the backlog that must be fit into a predefined
time-box (typically 30 days).
• Scrum meetings—are short (typically 15 minutes) meetings held daily
by the Scrum team. Three key questions are asked and answered by
all team members :
• What did you do since the last team meeting?
• What obstacles are you encountering?
• What do you plan to accomplish by the next team meeting?
Scrum
• A team leader, called a Scrum master, leads the meeting and assesses
the responses from each person.
• The Scrum meeting helps the team to uncover potential problems as
early as possible.
• Also, these daily meetings lead to “knowledge socialization” and
thereby promote a self-organizing team structure.
Scrum
• Demos—deliver the software increment to the customer so that
functionality that has been implemented can be demonstrated and
evaluated by the customer.
Dynamic Systems Development Method
(DSDM)
• The Dynamic Systems Development Method (DSDM) is an agile
software development approach that “provides a framework for
building and maintaining systems which meet tight time constraints
through the use of incremental prototyping in a controlled project
environment.
• The DSDM Consortium (www.dsdm.org) is a worldwide group of
member companies that collectively take on the role of “keeper” of
the method. The consortium has defined an agile process model,
called the DSDM life cycle that defines three differentiterative cycles,
preceded by two additional life cycle activities
Dynamic Systems Development Method
(DSDM)
• Feasibility study—establishes the basic business requirements and
constraints associated with the application to be built and then assesses
whether the application is a viable candidate for the DSDM process.
• Business study—establishes the functional and information requirements
that will allow the application to provide business value; also, defines the
basic application architecture and identifies the maintainability
requirements for the application.
• Functional model iteration—produces a set of incremental prototypes that
demonstrate functionality for the customer.
• Design and build iteration—revisits prototypes built during functional
model iteration to ensure that each has been engineered in a manner that
will enable it to provide operational business value for end users.
• Implementation—places the latest software increment
Crystal
• Alistair Cockburn and Jim Highsmith created the Crystal family of agile
methods in order to achieve a software development approach that
puts a premium on “maneuverability” during what Cockburn
characterizes as “a resource limited, cooperative game of invention
and communication, with a primary goal of delivering useful, working
software and a secondary goal of setting up for the next game”
• To achieve maneuverability, Cockburn and Highsmith have defined a
set of methodologies, each with core elements that are common to
all, and roles, process patterns, work products, and practice that are
unique to each.
Feature Driven Development (FDD)
• Feature Driven Development (FDD) was originally conceived by Peter
Coad and his colleagues
• FDD adopts a philosophy that
(1) emphasizes collaboration among people on an FDD team;
(2) manages problem and project complexity using feature-based
decomposition followed by the integration of software increments, and
(3) communication of technical detail using verbal, graphical, and text-based
means.
Lean Software Development (LSD)
• Lean Software Development (LSD) has adapted the principles of lean
manufacturing to the world of software engineering.
• The lean principles that inspire the LSD process can be summarized as
eliminate waste, build quality in, create knowledge, defer
commitment, deliver fast, respect people, and optimize the whole.
Agile Modeling (AM)
• There are many situations in which software engineers must build
large, business critical systems.
• The scope and complexity of such systems must be modeled so that
(1) all constituencies can better understand what needs to be accomplished,
(2) the problem can be partitioned effectively among the people who must
solve it, and
(3) quality can be assessed as the system is being engineered and built.
Agile Modeling (AM)
• Although AM suggests a wide array of “core” and “supplementary”
modeling principles, those that make AM unique are
• Model with a purpose
• Use multiple models
• Travel light
• Content is more important than representation
• Know the models and the tools you use to create them
• Adapt locally
Agile Unified Process (AUP)
• The Agile Unified Process (AUP) adopts a “serial in the large” and
“iterative in the small” philosophy for building computer-based
systems.
• By adopting the classic UP phased activities—inception, elaboration,
construction, and transition—AUP provides a serial overlay (i.e., a
linear sequence of software engineering activities) that enables a
team to visualize the overall process flow for a software project.
Agile Unified Process (AUP)
• Each AUP iteration addresses the following activities
• Modeling
• Implementation
• Testing
• Deployment
• Configuration and project management
• Environment management
Extreme Programming
• 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 in Extreme Programming
• 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.
Good Practices in Extreme Programming
• 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
• 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.
Basic principles of Extreme programming
• 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.
Basic principles of Extreme programming
• 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.
Basic principles of Extreme programming
• 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)
• 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.
Applications of Extreme Programming (XP)
• 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 XP model places a strong
emphasis on testing and quality assurance, making it a suitable approach
for projects where quality is a high priority.
Applications of Extreme Programming (XP)
• 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 XP 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 practices
• Continuous Integration: Code is integrated and tested frequently, with
all changes reviewed by the development team.
• Test-Driven Development: Tests are written before code is written,
and the code is developed to pass those tests.
• Pair Programming: Developers work together in pairs to write code
and review each other’s work.
• Continuous Feedback: Feedback is obtained from customers and
stakeholders through frequent demonstrations of working software.
• Simplicity: XP prioritizes simplicity in design and implementation, to
reduce complexity and improve maintainability.
Extreme Programming practices
• Collective Ownership: All team members are responsible for the code, and
anyone can make changes to any part of the codebase.
• Coding Standards: Coding standards are established and followed to ensure
consistency and maintainability of the code.
• Sustainable Pace: The pace of work is maintained at a sustainable level,
with regular breaks and opportunities for rest and rejuvenation.
• 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.
• Refactoring: Code is regularly refactored to improve its design and
maintainability, without changing its functionality.
Extreme Programming practices
• Small Releases: Software is released in small increments, allowing for frequent feedback
and adjustments based on that feedback.
• Customer Involvement: Customers are actively involved in the development process,
providing feedback and clarifying requirements.
• On-Site Customer: A representative from the customer’s organization is present with the
development team to provide continuous feedback and answer questions.
• Short Iterations: Work is broken down into short iterations, usually one to two weeks in
length, to allow for rapid development and frequent feedback.
• Planning Game: The team and customer work together to plan and prioritize the work
for each iteration, to deliver the most valuable features first.
• Metaphor: A shared metaphor is used to guide the design and implementation of the
system.
• 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: the unit tests to find and repair bugs as soon as
possible.