SOFTWARE ENGINEERING

AS PER NEW NEP SYLLABUS - BCA 4TH SEMESTER.

- Asst.Prof, Niveditha P
(CICMS)
Four Core Agile Values
Agile and Cost of Change
 Different Types of Agile Methodologies

1. Scrum
2. XP (Extreme Programming)
3. Kanban
4. FDD (Feature Driven Development)
5. Lean Software Development
6. DSDM (Dynamic System Development Method)
7. AM (Agile Modelling)
8. AUP (Agile Unified Process)
 XP – Extreme Programming
Extreme Programming is well-suited for projects where requirements are likely
to change frequently, and rapid delivery of working software is crucial. By
focusing on customer satisfaction, collaboration, and technical excellence, XP
enables teams to respond quickly to changes and deliver value continuously
throughout the project.
Extreme Programming emphasizes close collaboration between developers and
stakeholders, continuous feedback, and a set of practices that promote
simplicity, flexibility, and high-quality code. By integrating planning, design,
coding, and testing activities into short, iterative cycles, XP enables teams to
deliver working software that meets the customer's needs effectively and
efficiently.
Key Principles of XP
 Key Practices of XP
The Planning Game: Refactoring:
• The Planning Game is a collaborative activity where the development team • Refactoring involves improving the design of the code without
and stakeholders prioritize and estimate user stories. changing its external behavior.
• It involves selecting user stories from the product backlog for • Developers refactor the code continuously to keep it clean,
implementation in each iteration, based on their priority and estimated
effort. maintainable, and adaptable to changing requirements.

Small Releases: Simple Design:

• XP advocates for frequent releases of working software, even if the features • XP promotes simplicity in design, focusing on delivering the simplest
delivered in each release are minimal. solution that meets the current requirements.
• Small, frequent releases allow for quick validation of the product and • The goal is to avoid unnecessary complexity and to keep the codebase
reduce the risk of building the wrong thing. easy to understand and modify.
Test-Driven Development (TDD): Collective Code Ownership:
• Test-Driven Development is a core practice in XP, where developers write • All team members are responsible for the codebase.
automated tests before writing the code itself.
• Red-Green-Refactor cycle: Write a failing test (Red), write the minimum • This promotes collaboration, knowledge sharing, and a sense of
code to pass the test (Green), and then refactor the code to improve its ownership among team members.
design without changing its behavior.
Continuous Feedback:
Pair Programming: • XP emphasizes continuous feedback from customers and stakeholders
• Pair Programming involves two developers working together at one throughout the project.
computer.
• Feedback is used to refine the product backlog, adjust the project
• One developer writes the code while the other reviews it in real-time, direction, and ensure that the delivered software meets the customer's
leading to better code quality, fewer defects, and knowledge sharing. needs.
Continuous Integration:
Sustainable Pace:
• Continuous Integration is the practice of integrating changes into the main
codebase frequently. • XP advocates for maintaining a sustainable pace of work.
• Automated builds and tests are run with each integration to catch and fix • Team members should work at a pace that allows them to maintain
issues early, ensuring that the codebase remains in a working state at all high-quality work over the long term, avoiding burnout.
times.
XP (Extreme Programming)
Planning:
• Planning Game: XP's planning process is driven by
the "planning game," where developers and
stakeholders collaborate to prioritize and estimate
user stories.
• Release Planning: XP projects start with high-level
release planning, where the team and
stakeholders identify the overall goals and
priorities for the project.
• Iteration Planning: At the beginning of each
iteration, the team selects user stories from the
product backlog to work on during that iteration.
• Estimation: The team estimates the effort
required to implement each user story, often using
techniques like planning poker or relative sizing.
Design:
• Simple Design: XP promotes simplicity in design,
focusing on delivering the simplest solution that
meets the current requirements.
• Refactoring: Developers refactor the code
continuously to improve its design without
changing its external behavior. This ensures that
the code remains clean, maintainable, and
adaptable to future changes.
• Pair Programming: Pair programming facilitates
design discussions and knowledge sharing among
team members, leading to better design
decisions.
Coding:
• Test-Driven Development (TDD): TDD is a core
practice in XP, where developers write
automated tests before writing the code itself.
• Incremental Development: XP encourages
incremental development, where features are
implemented and delivered in small,
manageable increments.
• Collective Code Ownership: All team members
are responsible for the codebase, promoting
collaboration and shared responsibility for code
quality.
• Continuous Integration: Changes are integrated
into the main codebase frequently, with
automated builds and tests run after each
integration to catch and fix issues early.
Testing:
• Unit Testing: Developers write automated
unit tests for each piece of code they write,
ensuring that individual components behave
as expected.
• Acceptance Testing: Acceptance tests are
written based on user stories to verify that
the system meets the customer's
requirements.
• Integration Testing: Integration tests ensure
that different components of the system
work together correctly.
• Customer Testing: Customers are actively
involved in testing the software throughout
the project, providing feedback on each
iteration and guiding the development
process.
 Scrum
Scrum is a lightweight, iterative and incremental agile software development framework that focuses
on collaboration, flexibility, and delivering high-quality working software.
The framework is as follows:
1. Three primary roles – Product Owner, Scrum Master, Development Team.
2. Five Key Elements – Sprint Planning, Daily Stand-Up, Sprint Review, Sprint Retrospective, and
Sprint itself.
3. Three Artifacts – Product Backlog, Sprint Backlog, and Increment.
 Scrum
1. Three primary roles – Product Owner, Scrum Master, Development Team.

Scrum Team

Development
Product Owner Scrum Master
Team
 Scrum
2. Five Key Elements – Sprint Planning, Daily Stand-Up, Sprint Review, Sprint Retrospective, and
Sprint itself.

Sprint Planning
Daily Scrum
Sprint Review Sprint Events
Sprint Retrospective
Sprint
 Scrum
3. Three Artifacts – Product Backlog, Sprint Backlog, and Increment.

Scrum Artifacts

Product Backlog Sprint Backlog Increment