SOFTWARE ENGINEERING

SYLLABUS

Contents

OVERVIEW: Introduction; Software engineering ethics; Software process

models; Process activities; Coping with change; Agile software development:
Agile methods; Plan- driven and agile development.

REQUIREMENTS ENGINEERING: Functional and non-functional

requirements; Software requirements document; Requirement’s specification;
Requirements engineering processes; Requirement’s elicitation and analysis;
Requirement’s validation; Requirements management.

SYSTEM MODELING: Context models; Interaction models- Use case

modeling, Sequence diagrams; Structural models- Class diagrams,
Generalization, Aggregation; Behavioral models- Data-driven modeling,
Event-driven modeling; Model-driven engineering.
ARCHITECTURAL DESIGN: Architectural design decisions; Architectural
views; Architectural patterns- Layered architecture, Repository architecture,
Client–server architecture Pipe and filter architecture.
DESIGN AND IMPLEMENTATION: Object-oriented design using the
UML- System context and interactions, Architectural design, Object class
identification, Design models, Interface specification; Design patterns;
Implementation issues.

SOFTWARE TESTING: Development testing- Unit testing, Choosing

unit test cases, Component testing, System testing. Test-driven
development; Release testing; User testing- Alpha, Beta, Acceptance
testing.

1
 SOFTWARE ENGINEERING

UNIT 1

OVERVIEW OF SOFTWARE ENGINEERING

SOFTWARE ENGINEERING CONCEPTS

Software: software is the collection of computer programs, procedure rules and associated
documentation and data.
There are two main classifications of software are:
1. System software: It is the type of software that is the interface between application
software and the system. Low-level languages are used to write the system software.
System Software maintains the system resources and gives the path for application
software to run. An important thing is that without system software, the system cannot
run. It is general-purpose software.
Example: Operating system, File Magnitude, Compilers, Utilities, Assemblers, Debuggers
2. Application software: It is the type of software that runs as per user request. It
runs on the platform which is provided by system software. High-level languages
are used to write the application software. It’s specific purpose software. The main
difference between System Software and Application Software is that without
system software, the system cannot run on the other hand without application
software, the Low-level maintenance system always runs.
Example: Image processors, Databases, Games, Communication software, Spreadsheets
, Word processors

Characteristic of Software:
(1) Maintainability: Software should be written in such a way that it may evolve
to meet the changing needs of customers.
(2) Dependability: Software dependability has a range of characteristics,
including reliability, security and safety.
(3) Efficiency: Efficiency includes responsiveness, processing time, memory utilization etc.
(4) Usability: Software must be usable.
(5) Software is developed or engineered. It is not manufactured.
(6) Software does not wear-out.
(7) Software is intangible: The software product cannot be touched.

Software engineering is an engineering branch associated with development of software

product using well-defined scientific principles, methods and procedures. The outcome
of software engineering is an efficient and reliable software product.

Definition: Software Engineering (IEEE - Institute of Electrical and

Electronics Engineering):
The application of a systematic, disciplined, quantifiable approach to the
development, operation, maintenance of software, that is the application of
engineering to software.

2
 SOFTWARE ENGINEERING

Goals of Software Engineering:

(a) Quality: The primary goal of software engineering is to deliver high-quality software that
meets or exceeds the stakeholders' expectations.
(b) Customer Satisfaction: Software engineering aims to create software that satisfies the needs
and requirements of the end-users and customers.
(c) Efficiency: Software engineering focuses on developing software systems that operate
efficiently and effectively. This includes optimizing performance, minimizing resource
utilization and improving the software's speed and responsiveness.
(d) Timeliness: Meeting project deadlines and delivering software within the specified time is
an important goal of software engineering. This involves effective project management,
planning, and coordination to ensure that software projects are completed on time and within
budget.
(e) Maintainability: Software engineering aims to create software systems that are easy to
maintain and modify. This includes future enhancements, bug fixes and updates.
(f) Scalability: To develop software systems that can scale and adapt to changing needs and
requirements.
(g) Collaboration and Communication: Effective collaboration and communication among team
members and stakeholders are important goals of software engineering. This includes clear
and timely communication, promoting teamwork and stakeholders are engaged throughout
the software development process.
(h) Risk Management: Software engineering aims to identify, assess, and manage risks
associated with software development and deployment.
(i) Cost-effectiveness: Software engineering aims to deliver software solutions that provide
value for money. This involves optimizing resource utilization, minimizing development
costs.

Challenges in Software Engineering

(a) Complexity: Software systems are becoming increasingly complex, managing this
complexity poses challenges in terms of understanding requirements, designing and
ensuring effective integration and testing.

(b) Changing Requirements: Requirements can change throughout the software development
lifecycle, often due to evolving business needs, market dynamics, or user feedback.

(c) Project Management: Software engineering projects require effective project management
to ensure successful outcomes. Challenges can arise in areas such as resource allocation,
task scheduling, budgeting, risk management, and stakeholder coordination.

(d) Time and Cost Constraints: Meeting project deadlines and budgets can be challenging.

3
 SOFTWARE ENGINEERING

(e) Quality Assurance: Ensuring software quality is a continuous challenge. Identifying and
fixing defects, conducting testing, and maintaining high reliability, security, performance
, quality assurance.
(f) Team Collaboration: Effective collaboration and communication within team members,
coordinating tasks.

Software Product:
Software products are software systems that are delivered to a customer with a documentation
which describes how to install and use the system.
There are two types of software products:
1. Generic Product:
Generic products are developed for anonymous customers.
The organization which develops the software product, controls the software specification. The
target is generally the entire world and many copies are expected to be sold.
Examples: operating systems, compilers, analyzers, word processors, CASE tools etc.
2. Customized (Bespoke)Product:
The customized products are developed for specific customers.
The specification is usually developed and controlled by the organizations who are buying the
software.
The specific product is designed and developed as per customer requirements.
Examples: Payroll System, Inventory System etc.

Need of Software Engineering

The need of software engineering arises because of higher rate of change in user requirements
and environment on which the software is working.
1. Large software - It is easier to build a wall than to a house or building, likewise, as the
size of software become large engineering has to step to give it a scientific process.
2. Scalability- If the software process were not based on scientific and engineering
concepts, it would be easier to re-create new software than to scale an existing one.
3. Cost- As hardware industry has shown its skills and huge manufacturing has lower
down, the price of computer and electronic hardware. But the cost of software remains
high if proper process is not adapted.
4. Dynamic Nature- The always growing and adapting nature of software hugely depends
upon the environment in which user works. If the nature of software is always changing,
new enhancements need to be done in the existing one. This is where software
engineering plays a good role.
5. Quality Management- Better process of software development provides better and
quality software product.

4
 SOFTWARE ENGINEERING

Software engineering ethics refers to the moral principles and professional standards that
guide the behavior of software engineers in the development and maintenance of software
systems. It addresses the responsibilities of engineers toward users, clients, colleagues, and
society. The goal is to ensure that software is developed in ways that are ethically sound,
socially responsible, and legally compliant.
1. Public Interest: Ensure that software benefits society and does not cause harm.
2. Integrity: Be honest and transparent about the software’s limitations and risks.
3. Professional Responsibility: Follow best practices and continuously improve your skills.
4. Confidentiality: Protect users' and clients' private information.
5. Respect Intellectual Property: Avoid copying or using unlicensed software.
6. Fair Workplace: Promote inclusivity, respect, and fairness in the workplace.
7. Environmental & Social Impact: Consider the broader effects of your software on society
and the environment.
8. Accountability: Take responsibility for software errors and fix them promptly.

PROFESSIONAL AND ETHICAL RESPONSIBILITIES:

1. Confidentiality: Engineers should normally respect the confidentiality of their employers
or clients.
2. Competence: Engineers should not misrepresent their level of competence. They should not
knowingly accept work which is outside their competence.
3. Intellectual property rights: Engineers should be aware of local laws governing the use of
intellectual property such as patents, copyright, etc.
4. Computer misuse: Software engineers should not use their technical skills to misuse other
people’s computers. Computer misuse ranges from relatively trivial (game playing on an
employer's machine, say) to extremely serious (dissemination of viruses).

SOFTWARE DEVELOPMENT LIFE CYCLE (SDLC):

Software development life cycle composed of several phases. Each phase has a well-defined
starting and ending points with clearly identifiable deliverables to the next phase.
These include defining requirements, validation, training, and emphasizing ownership of the
system.

SDLC Phases are:

(1) Feasibility Study (2) Requirement Analysis (3) System Design

(4) Development (5) Testing (6) Implementation and
(7) Maintenance

5
 SOFTWARE ENGINEERING

(1) Study: In this phase, we assist whether or not a project should be undertaken.
This stage involves defining the problem and fixing up its boundaries. At the end of
this stage, the design and development team become clear with the project
objectives and their work.
(2) Requirement Analysis: In this stage, the requirements are studied and
analyzed. The technical development team works with customers and system
end users to identify the application domain, functions, services performance
capabilities, hardware constraints related to the system to be developed.
(3) System Design: In this phase, a new system is designed according to the needs
of the user. It is the phase which find a solution for the given problem.
(4) Development: This is the phase where the system is actually developed. The
design phase is built and implemented in this phase.
(5) Testing: This is most important phase where the system is judged for all its worth.
The system is tested under all kinds situations and environment to test its
performance, reliability and robustness and entire project functionality is tested with
all of its units, integrated and whole system is tested with test data. The developed
system should be able to satisfy all user’s needs and its functionality.
(6) Implementation: This is the process in which the developed system is handed
over to the client and users are trained to manage and maintain the new system.
(7) Software Maintenance: In this phase the development team maintains the system
for the client. It includes adding enhancements, improvements, updates to the newer
versions and not just correction of errors and emergency fixes of a system break
down.

6
 SOFTWARE ENGINEERING

Software process models Or SDLC Models: It is the structured frameworks used to

plan, manage, and control the process of developing software. They outline the steps
and stages involved in building a software product. Different models are suited for
different types of projects based on factors like project size, complexity, and customer
requirements.

The different Software Process Models are

1. Waterfall Model
2. Iterative Waterfall model
3. V Model
4. Spiral Model
5. Evolutionary Model
6. Prototype Model

WATERFALL MODEL (Linear Sequential Model or Classical Life Cycle

Model): Waterfall model was developed by W.W. Royce in 1970. This model
suggests a systematic, sequential approach to software development that begins at
system level and progresses through analysis, design, development, coding, testing
and maintenance.

The principal phases of water fall model are:

(1) Requirement Definition (2) Software and System Design
(3) Implementation and Unit Testing (4) Integration and System Testing
(5) Operation and Maintenance

(1) Requirement Definition: The system's services, constraints and goals are
established by consultation with system users.
(2) System and Software Design: System design process partitions the
requirements to either hardware or software system. It establishes an overall
system architecture. Software design involves representing the software system
functions in a form of one or more executable programs.

7
 SOFTWARE ENGINEERING

(3) Implementation and Unit Testing: On receiving system design

documents, the work is divided in modules/units and actual coding is started.
The system is first developed in small programs called units, which are
integrated in the next phase. Each unit is developed and tested for its
functionality; this is referred as unit testing.
Unit testing mainly verifies if the modules/units meet their specifications.
(4) Integration and System Testing: As specified above, the system is first
divided into units which are developed and tested for their functions. The units
are integrated into a complete system during integration phase and tested to
check if all modules/units coordinate with each other, and the whole system
behaves as per the specifications. After successfully testing the software, it is
delivered to the customer.

(5) Operations and Maintenance: This is the longest life cycle phase. The
system is put into practical use. Maintenance involves correcting errors which were
not discovered in earlier stages of the life cycle, improving the implementation of
system units and enhancing the system's services as new requirements are
discovered.

Advantages of the Waterfall Model:

-Easy to understand and implement.
-Widely used and known
- Identifies deliverables and milestones.
-Its major strength is well planned and well managed
- it allows for communication between customer and developer and specifies
when the product is delivered and what is the cost.

Disadvantages of the Waterfall Model:

There are three main (weakness) drawbacks of this model:
1)Linear 2) Rigid and 3) provides very little interaction from the user.
1)It is linear model, software proceeds from analysis to coding, to
implementation linearly.2) This model is rigid because a phase is fully
complete before another one phase commences. (In reality two or more phases
may proceed in parallel.)
3)The waterfall model requires the user to define system requirements early in the
project, 4) Interaction with the user takes place right in the beginning while firming up
requirements and then at the time of implementation.

V – model
The major drawback of waterfall model is we move to the next stage only when the
previous one is finished and there was no chance to go back if something is found
wrong in later stages. V-Model provides means of testing of software at each stage
in reverse manner.

8
 SOFTWARE ENGINEERING

At every stage, test plans and test cases are created to verify and validate the product according
to the requirement of that stage. For example, in requirement gathering stage the test team
prepares all the test cases in correspondence to the requirements. Later, when the product is
developed and is ready for testing, test cases of this stage verify the software against its validity
towards requirements at this stage.
This makes both verification and validation go in parallel. This model is also known as
verification and validation model.

SPIRAL MODEL:
The Spiral Model is an iterative software development model which is generally
implemented in high-risk projects. It was first proposed by Boehm in 1988. The spiral model
is similar to the incremental model, with more emphasis placed on risk analysis.
In this system development method, it combines the best features of both,
waterfall model and prototype model.
Each loop in the spiral represents a phase of the software process.
The innermost loop might be concerned with system feasibility, the next loop with
requirements definition, the next loop with system design and so on.

9
 SOFTWARE ENGINEERING

Each loop in the spiral is split into four sectors:

1. Objective Setting: Specific objective for the project is defined. Constraints on
the process and the product are identified and a detailed management plan is drawn
up. Project risks are identified. Alternative strategies, depending on these risks, may
be planned.
2. Risk Assessment and risk reduction: For each of the identified project
risks, a detailed analysis is carried out. Steps are taken to reduce the risk.
3. Development and validation: After risk evaluation, a development
model for the system is chosen.
4. Planning: The project is reviewed and a decision made whether to continue
with a further loop of the spiral. If it is decided to continue, plans are drawn up for
the next phase of the project.

Advantages of Spiral Model:

➢ High amount of risk analysis and Good for large and critical projects.
➢ it is one of the most flexible SDLC models in place. Development
phases can be determined by the project manager, according to the
complexity of the project.
➢ Project monitoring is very easy and effective. Each phase, as well as each loop.
➢ Risk management is one of the in-built features of the model, which
makes it extra attractive compared to other models.

10
 SOFTWARE ENGINEERING

➢ Changes can be introduced later in the life cycle as well. And coping
with these changes isn’t a very difficult for the project manager.

➢ Project estimates in terms of schedule, cost etc. are more realistic as

the project moves forward and loops in spiral get completed.
➢ It is suitable for high-risk projects. where business needs may be
unstable. A highly customized product can be developed using this.
Disadvantages of Spiral Model:
▸Cost involved in this model is usually high.
▸Risk analysis requires highly specific expertise.
▸Project's success is highly dependent on the risk analysis phase.
•Doesn't work well for smaller projects.
▸Skills required, evaluating and reviewing project from time to time, need expertise.
• It is not suitable for low-risk projects.

EVOLUTIONARY DEVELOPMENT MODEL:

Evolutionary development is based on the idea of developing an initial
implementation, exposing this to user comment and evolving it through several
versions until an adequate system has been developed.
Specification, development, and validation activities are interleaved rather than
separate, with rapid feedback across activities.
By developing the software incrementally, it is cheaper and easier to make changes in
the software as it is being developed. Each version or increment of the system
incorporates some of the functionality that is needed by the customer. Generally, the
early increments of the system include the most important or most urgently required
functionality.
This means that the customer can evaluate the system at a relatively early stage in the
development to see if it delivers what is required. If not, then only the current increment
has to be changed and, possibly, new functionality defined for later increments.

11
 SOFTWARE ENGINEERING

Advantages of Evolutionary Development Model:

•The cost of changing customer requirements is reduced.

▸The amount of analysis and documentation that has to be redone is much less
than is required with the waterfall model.
▸It is easier to get customer feedback on the development work that has been done.
▸Customers can comment on demonstrations of the software and see how much has been
implemented.
▸More rapid delivery and deployment of useful software to the customer is possible.
•Customers can use the early increments as prototypes and gain experience of
their requirements for later system increments.
▸Customers do not have to wait until the entire system is delivered before they can
gain value from it. The first version satisfies their most critical requirements so they
can use the software immediately.
▸Customers are able to use and gain value from the software early in the development
◗ As the highest-priority services are delivered first and increments then
integrated, the most important system services receive the most testing.

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.

12
 SOFTWARE ENGINEERING

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 is 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.

Software Processes
The term software specifies to the set of computer programs, procedures and
associated documents (Flowcharts, manuals, etc.) that describe the program and
how they are to be used. A software process is the set of activities and associated
outcome that produce a software product. Software engineers mostly carry out
these activities. These are four key process activities, which are common to all
software processes. These activities are:

1. Software specifications: The functionality of the software and constraints

on its operation must be defined.
2. Software development: The software to meet the requirement must be produced.
3. Software validation: The software must be validated to ensure that it does
what the customer wants.

13
 SOFTWARE ENGINEERING

4. Software e v o l u t i o n : The s o f t w a r e m us t e v o l v e t o m e e t c h a n g i n g
client needs.

Coping with change

• Change is inevitable in all large software projects.

– Business changes lead to new and changed system requirements
– New technologies open up new possibilities for improving implementations
– Changing platforms require application changes
• Change leads to rework so the costs of change include both rework (e.g. re-
analyzing requirements) as well as the costs of implementing new functionality

Reducing the costs of rework

• Change avoidance, where the software process includes activities that can
anticipate possible changes before significant rework is required.
– For example, a prototype system may be developed to show some key
features of the system to customers.
• Change tolerance, where the process is designed so that changes can be
accommodated at relatively low cost.
– This normally involves some form of incremental development. Proposed
changes may be implemented in increments that have not yet been
developed. If this is impossible, then only a single increment (a small part
of the system) may have to be altered to incorporate the change.

Agile Methodology

Agile Software Development is a software development methodology that values

flexibility, collaboration, and customer satisfaction. It is based on the Agile Manifesto,
a set of principles for software development that prioritize individuals and interactions,
working software, customer collaboration, and responding to change.

Agile Software Development is an iterative and incremental approach to software

development that emphasizes the importance of delivering a working product quickly
and frequently. It involves close collaboration between the development team and the
customer to ensure that the product meets their needs and expectations.

14
 SOFTWARE ENGINEERING

Core Values of Agile Software Development:

The Agile Software Development Methodology Manifesto describe four core

values of Agile in software development.

1. Individuals and Interactions over Processes and Tools

2. Working Software over Comprehensive Documentation
3. Customer Collaboration over Contract Negotiation
4. Responding to Change over Following a Plan

Principles of Agile Software Development

1. Ensuring customer satisfaction through the early delivery of software.

2. Being open to changing requirements in the stages of the development.
3. Frequently delivering working software with a main focus on
preference for timeframes.
4. Promoting collaboration between business stakeholders and developers
as an element.
5. Structuring the projects around individuals. Providing them with the
necessary environment and support.
6. Prioritizing face to face communication whenever needed.

15
 SOFTWARE ENGINEERING

7. Considering working software as the measure of the progress.

8. Fostering development by allowing teams to maintain a pace indefinitely.
9. Placing attention on excellence and good design practices.
10. Recognizing the simplicity as crucial factor aiming to maximize
productivity by minimizing the work.
11. Encouraging self-organizing teams as the approach to design and build
systems.
12. Regularly reflecting on how to enhance effectiveness and to make
adjustments accordingly.

The Agile Software Development Process

1. Requirements Gathering: The customer’s requirements for the

software are gathered and prioritized.
2. Planning: The development team creates a plan for delivering the
software, including the features that will be delivered in each iteration.
3. Development: The development team works to build the software, using
frequent and rapid iterations.
4. Testing: The software is thoroughly tested to ensure that it meets the
customer’s requirements and is of high quality.
5. Deployment: The software is deployed and put into use.
6. Maintenance: The software is maintained to ensure that it continues to
meet the customer’s needs and expectations.
7. Agile Software Development is widely used by software development
teams and is considered to be a flexible and adaptable approach to
software development that is well-suited to changing requirements and
the fast pace of software development.
8. Agile is a time-bound, iterative approach to software delivery that builds
software incrementally from the start of the project, instead of trying to
deliver all at once.

16
 SOFTWARE ENGINEERING

Agile Process Models

Agile process models provide different frameworks and practices for

implementing Agile principles. Each model has its own strengths and may be
more suitable for specific project types or team dynamics. It is
important to understand the unique characteristics of each Agile model and adapt
them to fit into the needs and constraints of project.

1. Scrum

Scrum is an Agile framework for managing and organizing complex projects. It was
developed by Jeff Sutherland and Ken Schwaber. It provides a lightweight, iterative,
and incremental approach to software development, emphasizing collaboration,
adaptability, and continuous improvement.
The Scrum model promotes iterative and incremental development, with each sprint
resulting in a
releasable product increment. It enables teams to respond quickly to changing
requirements, reduces risks, and collaboration between team members and
stakeholders. The framework's simplicity and flexibility make it widely adopted and
suitable for a variety of software development projects.
The Scrum model consists of specific roles, events, artifacts, and rules that guide the
development process. Scrum is a framework that brings regularity to the project
through its various phases or
processes. Any organization can implement a scrum framework without altering its rules
and regulation.

17
 SOFTWARE ENGINEERING

Key Components of the Scrum Model Roles:

a) Product Owner: represents the interests of stakeholders, team leader, team

manager defines and prioritize the product backlog, and ensures that the team
is delivering value to the customer.
b) Scrum Master: facilitates the Scrum process, removes impediments, and
ensures that the team adheres to Scrum principles and practices.
c) Development Team: Self-organizing and cross-functional group
responsible for delivering the product increment.
Events:

a) Sprint: A time-boxed iteration typically lasting 1-4 weeks, during which the
team works on a set of product backlog items.
b) Sprint Planning: Collaborative session where the team defines the sprint goal,
selects backlog items to work on, and creates a sprint backlog.
c) Daily Scrum: Short daily meeting where the team synchronizes activities,
discusses progress, identifies impediments, and plans for the day.
d) Sprint Review: Meeting at the end of the sprint to showcase the
increment, gather feedback, and adapt the product backlog.
e) Sprint Retrospective: Reflection session where the team inspects its work,
identifies areas for improvement, and plans actions for the next sprint.
Artifacts:

a) Product Backlog: A prioritized list of features, requirements, and

enhancements that need to be addressed in the project. It is continuously
refined and updated.
b) Sprint Backlog: The subset of product backlog items selected for the current
sprint, along with a plan for delivering them.
c) Increment: The sum of all the completed and integrated product backlog items
during a sprint. It must be in a potentially shippable state.

2. Kanban:

Kanban is a visual management system that focuses on visualizing the workflow and
optimizing the flow of work. It uses a Kanban board to represent different stages of
work, with work items moving through the workflow based on capacity and work-in-
progress limits.
Kanban emphasizes continuous improvement, limiting work in progress, and optimizing
flow.

18
 SOFTWARE ENGINEERING

1. Sprint Planning: Collaborative session where the team defines the sprint goal,
selects backlog items to work on, and creates a sprint backlog.
2. Daily Scrum: Short daily meeting where the team synchronizes activities,
discusses progress, identifies impediments, and plans for the day.
3. Sprint Review: Meeting at the end of the sprint to showcase the
increment, gather feedback, and adapt the product backlog.
4. Sprint Retrospective: Reflection session where the team inspects
its work, identifies areas for improvement, and plans actions for
the next sprint.

3. Artifacts:

1. Product Backlog: A prioritized list of features, requirements, and

enhancements that need to be addressed in the project. It is
continuously refined and updated.
2. Sprint Backlog: The subset of product backlog items selected for the
current sprint, along with a plan for delivering them.
3. Increment: The sum of all the completed and integrated product backlog items
during a sprint. It must be in a potentially shippable state.

4. Extreme Programming

XP is an Agile methodology that emphasizes close collaboration between developers

and stakeholders. It promotes practices such as Test-Driven Development (TDD),
Continuous Integration, Pair Programming, and Refactoring to ensure high-quality
software. XP focuses on short development cycles, frequent
releases, and adapting to changing requirements.
Extreme Programming (XP) is an Agile software development methodology that
focuses on delivering high-quality software through frequent iterations and close
collaboration between developers and stakeholders. It emphasizes a set of values,
principles, and practices that promote effective teamwork, continuous feedback,
and rapid response to changing requirements. Extreme Programming is particularly
suited for projects with rapidly changing requirements, high customer involvement,
and a focus on delivering high- quality software. It emphasizes the importance of
adaptability, feedback, and collaboration to achieve success in software
development projects.

19
 SOFTWARE ENGINEERING

Key Values of Extreme Programming:

i. Communication: XP emphasizes open and constant communication

among team members, stakeholders, and customers. Face-to-face
communication is encouraged to promote a shared understanding of the
goals and requirements of the project.
ii. Simplicity: XP encourages simplicity in software design and development. It
advocates for the simplest solutions that meet the requirements and promotes
avoiding unnecessary complexity.
iii. Feedback: Continuous feedback is crucial in XP. Frequent
communication with customers and stakeholders helps ensure that the
software meets their expectations
V. Test-Driven Development (TDD): TDD is a development practice where tests are
written before the code. It promotes writing automated tests to define the desired
behavior and then writing code to pass those tests. It ensures that the software remains
reliable and helps detect issues early.
vi. Pair Programming: Pair Programming involves two programmers working
together on a single workstation. One person writes the code while the other
reviews it. This practice enhances code quality, knowledge sharing, and
collaboration.
vii. Continuous Integration: Continuous Integration involves integrating code
changes frequently into a shared repository. It ensures that the changes from
multiple developers are combined and tested together, reducing the likelihood of
integration issues.

20
 SOFTWARE ENGINEERING

viii. Small Releases: XP aids delivering software in small, frequent releases. This
allows for quick feedback and early validation of features, enabling stakeholders
to provide input and make adjustments as needed.
ix. Refactoring: It involves improving the design of existing code without
changing its behavior. It promotes continuous refactoring to maintain code quality,
improve readability and remove duplication.
x. Collective Ownership: It encourages a sense of collective ownership, where any
team member can work on any part of the project. This practice promotes
collaboration, knowledge sharing, and flexibility within the team

Plan-driven and Agile development

Plan Driven Approach

a. A plan-driven approach to software engineering is based around
separate development stages with the outputs to be produced at
each of these stages planned in advance.
b. Not necessarily waterfall model – plan-driven, incremental
development is possible
c. Iteration occurs within activities.

Agile development
Specification, design, implementation and testing are inter-leaved and the
outputs from the development process are decided through a process of negotiation
during the software development process.

21
 SOFTWARE ENGINEERING

Agile Methodology vs Plan Driven Methodology

Agile Development Plan Driven Development

Iterative and incremental approach Linear and sequential approach
Adaptive and Flexible planning Predictive and rigid Planning
Requirements evolve throughout the project Defined in the initial phase
Documentation is minimal Detailed and comprehensive
Frequent feedback and change acceptance Minimal feedback, resistance to changes
Continuous testing is done throughout the Testing phase is after development
project
Cost of change is low Cost of change is high

REVIEW QUESTIONS
1. What is software engineering? Explain the characteristics of the software engineering.
2. Explain in detail Software Engineering Ethics
3. Explain in detail the SDLC Model.
4. Explain in detail Waterfall Model with advantages and disadvantages.
5. Explain in detail Spiral Model with advantages and disadvantages
6. Explain in detail Evolutionary model with advantages and disadvantages
7. Explain in detail Prototype model with advantages and disadvantages
8. Explain in detail the V-Model with advantages and disadvantages
9. Explain Software Process Activities in detail.
10. What is Agile Development? Explain the core values of Agile.
11. Explain in detail Agile Principles.
12. Explain the Stages of Agile Process Model in detail.
13. Explain in detail the different Agile Methods.
14. Differentiate Between Agile Development and Plan Driven Development

22