2.

1 Lean Production

Lean methodology aims to eliminate wasteful resources and tasks for improved efficiency and
reduced costs — while never sacrificing quality

/
Advantages of Lean Software Development:

om
​ Efficiency: Streamlines processes to reduce unnecessary work and focus on delivering

.c
value.
​ Waste Reduction: Minimizes non-value-adding activities, enhancing productivity.

ot
​ Customer Value: Emphasizes delivering what customers need, promoting customer

sp
satisfaction.
​ Continuous Improvement: Encourages iterative enhancements to processes and

og
products.

bl
Principles of Lean Software Development:
s.
​ Eliminate Waste: Remove non-value-adding activities, such as unnecessary
nv

documentation or delays.
​ Build Quality In: Emphasize quality in all stages to avoid defects and rework.
ar

​ Create Knowledge: Foster a learning culture by sharing knowledge and empowering

um

teams.
​ Defer Commitment: Delay decisions until the last responsible moment to maximize
flexibility.
yk

​ Deliver Fast: Aim for quicker delivery of value to customers through smaller
ija

iterations.
​ Respect People: Empower and respect team members, fostering collaboration and
//v

innovation.
​ Optimize the Whole: Optimize the entire software development process, not just
s:

individual parts.
tp
ht
 /
om
.c
ot
sp
og
bl
s.
nv
ar
um
yk

Process Steps of Lean Software Development:

ija

The Lean framework in software development emphasizes reducing waste, optimizing processes,
and delivering value to customers. Here's a step-by-step breakdown of the Lean framework with
//v

a use case:
s:

1. Identify Customer Value:

tp

● Objective: Understand what customers perceive as valuable.

ht

● Use Case Example: Developing an e-commerce platform.

● Activity: Conduct customer surveys and interviews to identify key features customers
desire, such as intuitive navigation, secure payments, and personalized recommendations.
2. Map the Value Stream:
● Objective: Analyze the flow of activities and processes in delivering customer value.
● Use Case Example: Streamlining the e-commerce platform development.
● Activity: Map the end-to-end process of feature development, from idea conception to
deployment, identifying bottlenecks, delays, or redundant steps.

3. Create Flow:

/
om
● Objective: Streamline the process to ensure a smooth flow of work.
● Use Case Example: Optimizing feature development.

.c
● Activity: Implement Agile methodologies like Scrum or Kanban to break down work

ot
into smaller tasks, establish clear priorities, and ensure continuous delivery through
sprints or iterations.

sp
og
4. Establish Pull:
● Objective: Enable work to be pulled by customer demand or actual needs.
bl
● Use Case Example: Customer-driven feature development.
s.
● Activity: Prioritize tasks based on customer demand and feedback. Features or
nv

improvements are developed based on actual requirements rather than assumptions.

ar

5. Seek Perfection:
um

● Objective: Continuously improve processes to eliminate waste and enhance efficiency.

● Use Case Example: Iteratively improving the e-commerce platform.
yk

● Activity: Conduct regular retrospectives and gather feedback to identify

inefficiencies or areas for improvement. Implement small, incremental changes to
ija

enhance usability, performance, or customer experience.

//v
s:
tp
ht
 /
om
.c
ot
sp
Refer for more information :

og
bl
s.
nv
ar
um
yk

Real-World Example:
ija

● Scenario: A team is developing an e-commerce platform using Lean principles.

● Activity: The team identifies key features desired by customers (customer value), maps
//v

the development process (value stream mapping), implements Agile practices for
s:

smoother development (creating flow), prioritizes features based on customer demand

(establishing pull), and regularly conducts retrospectives to improve the platform
tp

(seeking perfection).
ht

By following these steps within the Lean framework, the team aims to continuously deliver
value, reduce waste, and optimize their processes to create an efficient and customer-centric
e-commerce platform
​
2.2 SCRUM
Scrum is a framework for developing and sustaining complex products. Ken Schwaber and Jeff
Sutherland developed Scrum.

Scrum roles:

/
1. Scrum Master:

om
● Responsibilities:

.c
● Guides the Scrum team and ensures adherence to Scrum principles and practices.
● Facilitates Scrum events (such as Sprint Planning, Daily Stand-ups, Sprint

ot
Review, and Retrospective).

sp
● Removes impediments or obstacles hindering the team's progress.
● Helps the team understand and embrace the values, principles, and practices of

og
Scrum.
● Analogy: Often compared to a coach or facilitator who ensures the team follows the rules
bl
and helps them achieve their best performance.
s.
2. Product Owner:
nv

● Responsibilities:
ar

● Represents the stakeholders and the voice of the customer.

um

● Defines and prioritizes the product backlog based on customer and business
needs.
● Collaborates with the team to ensure the right features are developed and
yk

delivered.
ija

● Provides clarity on product requirements and acceptance criteria.

● Analogy: Similar to a product manager who is responsible for the product vision,
//v

roadmap, and prioritization.

s:

3. Development Team:
tp

● Responsibilities:
ht

● Self-organizes to accomplish the Sprint goal and deliver increments of a

potentially shippable product.
● Cross-functional and accountable for all tasks related to delivering the product,
including analysis, design, development, testing, and documentation.
● Collaborates closely to achieve the objectives set for each Sprint.
 ● Analogy: The equivalent of a sports team where members collaborate to achieve a
common goal, working together towards successful product increments.

Each role plays a crucial part in ensuring the effectiveness and success of the Scrum framework.
The Scrum Master supports the team in following Scrum practices, the Product Owner prioritizes
work according to business value, and the Development Team collaborates to deliver
high-quality increments within short timeframes.

/
om
.c
ot
sp
og
bl
s.
nv
ar
um
yk
ija
//v

1. Product Backlog Creation:

s:

● Objective: Define and prioritize the list of requirements or features (Product Backlog)
tp

based on customer needs.

ht

● Activity: The Product Owner collaborates with stakeholders to compile a prioritized list
of user stories or features that need to be developed.

2. Sprint Planning:
● Objective: Plan the work to be done during the upcoming Sprint.
 ● Activity: The Scrum Team (Product Owner, Scrum Master, and Development Team)
conducts a Sprint Planning meeting to select items from the Product Backlog for the
Sprint. The team decides on the Sprint Goal and creates a Sprint Backlog.

3. Daily Stand-up (Daily Scrum):

● Objective: Share progress, identify impediments, and plan work for the next 24 hours.
● Activity: The Development Team meets daily for a short (usually 15 minutes) Daily

/
om
Stand-up meeting. Each member shares:
● What they've done since the last meeting.
● What they plan to do until the next meeting.

.c
● Any impediments blocking their progress.

ot
sp
4. Sprint Execution:

og
● Objective: Develop and deliver a potentially releasable product increment.
● Activity: The Development Team works on the tasks identified in the Sprint Backlog,

bl
guided by the Sprint Goal. They collaborate daily to complete work and address any
challenges.
s.
nv

5. Sprint Review:
ar

● Objective: Demonstrate the work completed during the Sprint and gather feedback.
● Activity: The Scrum Team, along with stakeholders, conducts a Sprint Review meeting.
um

The Development Team showcases the completed work, and stakeholders provide
feedback. The Product Backlog may be adjusted based on this feedback.
yk

6. Sprint Retrospective:
ija

● Objective: Reflect on the Sprint and identify opportunities for improvement.

//v

● Activity: The Scrum Team holds a Sprint Retrospective meeting to discuss what went
well, what didn't, and how to improve. Action items for improvement are identified and
s:

added to the next Sprint Backlog.

tp

Iterative Process:
ht

● Repeat: After the Sprint Retrospective, the next Sprint begins, following the same
sequence of events. Each Sprint delivers a potentially shippable product increment, and
the process continues iteratively.
This iterative approach in the Scrum framework allows teams to regularly inspect and adapt,
delivering value incrementally with each Sprint while continuously improving their processes.

2.3 Crystal
The Crystal methodology, developed by Alistair Cockburn, is a family of Agile methodologies
that adapts to various project sizes and contexts. It emphasizes the human aspects of software
development and tailors practices to the specific needs of a project. The Crystal Clear variant is

/
om
one of the iterations within the Crystal family, suitable for small teams working on relatively
straightforward projects.

.c
Crystal Clear Methodology Steps:

ot
sp
​ Project Initiation:
● Objective: Define the project vision, goals, and initial requirements.

og
● Example: Initiating the development of an online portfolio website for a
freelance designer.
​ bl
Iteration Planning:
s.
● Objective: Plan iterations or increments of work.
● Example: Planning the first iteration to include basic website structure,
nv

portfolio layout, and contact form.

ar

​ Regular Delivery Cycles:

● Objective: Deliver working software incrementally at regular intervals.
um

● Example: After each iteration (say, every two weeks), deliver a functional part
of the website to gather feedback.
yk

​ Frequent Reflection and Adjustment:

● Objective: Regularly reflect on progress and adapt plans accordingly.
ija

● Example: Conducting weekly meetings to review progress, discuss challenges,

and adapt plans based on feedback.
//v

​ Close Collaboration:
s:

● Objective: Foster close interaction among team members and stakeholders.

● Example: Frequent communication between the designer, developer, and client
tp

to ensure alignment with expectations.

ht

Seven Properties of Crystal Clear:

​ Frequent Delivery: Regularly deliver working software.

​ Reflective Improvement: Continuously reflect on processes and adapt for
improvement.
 ​ Close Communication: Promote close and frequent communication among team
members.
​ Personal Safety: Create an environment where team members feel safe to contribute
and share ideas.
​ Focus: Maintain focus on high-priority tasks to achieve project goals.
​ Easy Access to Expert Users: Ensure easy access to domain experts or users for
feedback and clarification.

/
om
​ Technical Environment with Automated Tests: Foster a technical environment
where testing is automated, ensuring code quality.

.c
2.4 Feature Driven Development (FDD).

ot
sp
Feature Driven Development (FDD) is an iterative and incremental software development
methodology. Here are the eight practices within FDD, along with an example of its life

og
cycle:

bl
s.
Eight Practices of Feature Driven Development (FDD):
nv

​ Develop an Overall Model:

ar

● Objective: Develop an initial object model of the system.

um

● Example: In building a payroll system, start with an object model representing

employees, salaries, and tax calculations.
yk

​ Build Features Incrementally:

ija

● Objective: Develop features in small, manageable increments.

//v

● Example: Implement payroll features incrementally, starting with basic salary

calculations and gradually adding tax calculations and deductions.
s:

​ Feature List Creation:

tp
ht

● Objective: Create a comprehensive list of features to be implemented.

● Example: Compile a feature list for the payroll system, including basic
functionalities like employee data input, salary calculation, and advanced features
like tax optimization.
​
 ​ Plan by Feature:
● Objective: Plan and organize development tasks based on features.
● Example: Organize sprints or iterations around specific features, allocating
resources and timelines accordingly.
​ Design by Feature:

/
● Objective: Design and develop features collaboratively.

om
● Example: Collaboratively design the user interface and functionality for each

.c
feature in the payroll system.

ot
​ Build by Feature:

sp
● Objective: Develop and implement features according to the design.
● Example: Program and code each feature, ensuring adherence to the design

og
specifications.
​ Regular Builds: bl
s.
● Objective: Ensure regular integration and testing of developed features.
nv

● Example: Conduct continuous integration and testing after the completion of

ar

each feature to detect and resolve issues promptly.

um

​ Inspections:
● Objective: Review and assess the progress of features regularly.
yk

● Example: Conduct peer reviews or inspections to ensure quality and

ija

adherence to standards for each implemented feature.

//v

Feature Driven Development Life Cycle:

s:
tp

​ Domain Walkthrough: Understand the project scope and define the domain model.
ht

​ Develop Overall Model: Create an object model that represents the system's initial state.
​ Feature List Creation: Identify and list features to be implemented.
​ Plan by Feature: Plan development cycles based on features.
​ Design by Feature: Collaboratively design the features.
​ Build by Feature: Develop and implement features.
 ​ Regular Builds and Testing: Integrate and test features regularly.
​ Client Sign-Off: Obtain client approval for completed features.
​ Iterate and Refine: Iterate through the steps for subsequent features.

/
om
.c
ot
sp
og
bl
s.
nv
ar

2.5 Adaptive Software Development (ASD):

um

Adaptive Software Development (ASD) emphasizes adaptability, collaboration, and learning

yk

throughout the software development life cycle. Within ASD, the Speculate-Collaborate-Learn
ija

(SCL) life cycle serves as a guideline for iterative and adaptive development. Here's an
//v

explanation of each phase along with an example:

s:

1. Speculate:
tp

● Objective: Speculate on the essential aspects of the project, understanding initial

ht

requirements and envisioning potential solutions.

● Example: In developing a new mobile app for a food delivery service, the team
speculates on core features, user personas, and potential technical challenges, based on
market research and initial discussions with stakeholders.
2. Collaborate:
● Objective: Collaborate closely with stakeholders, customers, and team members to refine
ideas, gather feedback, and define the project's scope.
● Example: Engage in collaborative workshops or meetings with chefs, delivery personnel,
and customers to gather insights on app usability, menu options, and delivery logistics.
This collaboration helps in refining the project's vision.

/
om
3. Learn:
● Objective: Continuously learn and adapt based on feedback, evolving requirements, and

.c
changing market conditions.

ot
● Example: After releasing the initial version of the app, analyze user behavior, ratings,
and feedback. Use this data to identify areas for improvement, such as refining the user

sp
interface, optimizing delivery routes, or adding new features based on user requests.

og
bl
s.
nv
ar
um
yk
ija
//v
s:
tp
ht

Real-World Application:
● Scenario: A team developing a food delivery app using ASD's SCL cycle.
● Speculate: Initial discussions and market research focus on essential app features, user
personas, and potential technical challenges.
 ● Collaborate: Collaborative workshops with stakeholders refine the app's scope,
incorporating insights from chefs, delivery personnel, and customers into the project plan.
● Learn: After launching the app, continuous analysis of user data and feedback helps in
adapting the app's features, usability, and services to meet evolving customer needs and
preferences.

The Speculate-Collaborate-Learn life cycle within Adaptive Software Development emphasizes

/
adaptability and continuous improvement by embracing change, involving stakeholders in

om
decision-making, and learning from real-world feedback to refine and evolve the software

.c
product iteratively.

ot
sp
Six characteristics :

og
Adaptive Software Development's (ASD) Speculate-Collaborate-Learn (SCL) life cycle is

underpinned by six basic characteristics that guide its iterative and adaptive nature:
bl
s.
1. Collaboration and Communication:
nv

● Objective: Encourage extensive collaboration and open communication among

ar

stakeholders, team members, and customers.

um

● Example: Regular workshops, meetings, and discussions involving diverse stakeholders

yk

to ensure a shared understanding and alignment of project goals and requirements.

ija

2. Learning and Adaptation:

//v

● Objective: Embrace learning from experiences, feedback, and changing circumstances,

s:

allowing for constant adaptation.

tp

● Example: Analyzing user behavior, market trends, and user feedback to continuously
ht

refine and enhance the software throughout its development life cycle.
3. Incremental Development:
● Objective: Develop the software incrementally, delivering small, manageable pieces of

functionality over successive iterations.

● Example: Releasing and improving upon a basic version of the software and gradually

adding new features or enhancements in subsequent iterations.

/
om
4. Flexibility and Adaptability:

.c
● Objective: Maintain flexibility to adapt to evolving requirements, technology

ot
advancements, and changing market conditions.

sp
● Example: Being responsive to changing customer needs or industry trends by adjusting

og
the project scope or feature priorities as required.

bl
5. Collaboration with Customers:
s.
nv

● Objective: Foster active participation and collaboration with customers or end-users

ar

throughout the development process.

um

● Example: Involving customers in design workshops, usability testing, and feedback

sessions to ensure the software aligns with their needs and preferences.
yk

6. Iterative Feedback Loop:

ija
//v

● Objective: Establish a continuous feedback loop to gather insights and refine the

development approach.
s:

● Example: Regularly reviewing and reflecting on project progress, soliciting feedback,

tp

and making adjustments based on lessons learned.

ht

2.6 Extreme Programming :

Extreme Programming (XP) is an Agile software development methodology that prioritizes
adaptability, collaboration, and high-quality code. Here's a detailed breakdown of XP's life cycle,
including its phases, along with examples:
1. Exploration Phase:
● Objective: Gather initial requirements and establish the project's feasibility.
● Activities: Conduct initial meetings with stakeholders to understand project goals and
user needs. For instance, in developing a healthcare app, exploratory discussions focus on
patient data security and user interface requirements.

2. Planning Phase:

/
om
● Objective: Plan the project's scope, features, and iterations.
● Activities: Break down project requirements into user stories, estimate tasks, and create a

.c
release plan. For example, in the healthcare app project, planning involves prioritizing

ot
features like appointment scheduling and medical history tracking for the initial release.

sp
3. Iteration to Release Phase:

og
● Objective: Develop, test, and integrate features in iterative cycles.

bl
● Activities: Teams work on short iterations (e.g., 1-2 weeks), completing coding, testing,
and integrating features. In the healthcare app, each iteration may focus on specific
s.
modules, such as user authentication or database integration.
nv

4. Productionizing Phase:
ar

● Objective: Prepare the software for deployment in a production environment.

um

● Activities: Perform final integration, optimize performance, conduct acceptance tests,

and ensure scalability. For the healthcare app, this phase involves security audits,
yk

performance optimizations, and final user acceptance tests.

ija

5. Maintenance Phase:
//v

● Objective: Provide ongoing support and updates after deployment.

s:

● Activities: Address user feedback, fix bugs, and implement enhancements. In the
healthcare app, this phase includes regular updates to improve features, security patches,
tp

and bug fixes.

ht

6. Death Phase:
● Objective: Decommission or replace the software at the end of its lifecycle.
● Activities: Plan for the retirement of the software, archive data, and migrate users to
newer versions or alternative solutions. In the healthcare app example, this phase occurs
when a more advanced app replaces the older version.
Real-World Example:
● Scenario: Developing a project management tool using Extreme Programming.
● Application: During the Exploration Phase, discussions with project managers identify
critical features. In the Iteration to Release Phase, each iteration adds functionalities like
task assignment and progress tracking. The Productionizing Phase ensures scalability for
a large user base. Maintenance addresses user feedback, and the Death Phase occurs
when a newer, more advanced tool supersedes it.

/
om
XP's life cycle ensures continuous collaboration, adaptability, and high-quality software delivery
by iteratively developing, testing, and refining features while remaining responsive to changing

.c
requirements throughout the software's lifecycle.

ot
sp
og
bl
s.
nv
ar
um
yk
ija
//v

Roles in Extreme Programming:

s:

​ Customer: Represents stakeholders, provides requirements, and defines features.

tp

​ Programmer: Develops the code and implements features as per requirements.

ht

​ Tester: Conducts testing, ensures code quality, and validates user stories.
​ Tracker: Manages project progress, monitors tasks, and updates team boards.
​ Coach: Guides the team on XP principles and practices, facilitates communication, and
resolves issues.
Work Products in Extreme Programming:
​ User Stories: Descriptions of desired functionality from the user's perspective.
​ Code: Developed software components meeting user story requirements.
​ Tests: Automated and manual tests verifying the functionality and quality of code.
​ Release Plan: Plan detailing feature implementation and release schedules.
​ Documentation: Minimal but sufficient documentation for understanding code and
features.

/
om
Practices in Extreme Programming:

.c
​ Pair Programming: Two programmers collaborate on the same task, promoting code

ot
quality and knowledge sharing.

sp
​ Test-Driven Development (TDD): Writing tests before writing code to guide
development and ensure test coverage.

og
​ Continuous Integration (CI): Integrating code changes frequently into a shared
repository and running automated tests.
​
bl
Refactoring: Restructuring and improving code without altering its external behavior.
s.
​ Simple Design: Emphasizing simplicity and avoiding unnecessary complexity in code
architecture.
nv
ar
um
yk
ija
//v
s:
tp
ht