AGILE SOFTWARE PROCESS

(Professional Elective –I) B. Tech IT III Year – I Semester

UNIT-II
Syllabus: The Agile Methodologies: Common Themes, Methodology Descriptions,
Extreme Programming, Scrum, Feature Driven Development, The Crystal
Methodologies, Adaptive Software Development, Dynamic Systems Development
Method, Lean Software Development, Starting Monday: Investigate Further Selecting
an Approach that Fits: Choosing between an Agile or Traditional Approach, Selecting
the Right Agile Approach

1. The Agile Methodologies: Common Themes

Agile methodologies are a set of iterative and collaborative approaches to software
development and project management. They prioritize flexibility, customer collaboration, and
rapid adaptation to change. While there are several specific Agile methodologies, such as
Scrum, Kanban, and Extreme Programming (XP), they all share common themes that
underpin their principles and practices. Here are the common themes of Agile methodologies:
1. Iterative and Incremental Development: Agile methodologies emphasize breaking
down projects into smaller, manageable iterations or increments. This allows for
regular feedback and the ability to adjust the project's direction based on changing
requirements or priorities.
2. Customer Collaboration: Agile places a strong emphasis on involving customers and
stakeholders throughout the development process. Regular interactions and
collaboration with customers help ensure that the product meets their needs and
expectations.
3. Embracing Change: Agile methodologies recognize that change is inevitable in
software development. They are designed to accommodate changes in requirements,
technology, and market conditions throughout the project's lifecycle.
4. Cross-Functional Teams: Agile teams are typically composed of individuals with
diverse skills, including developers, testers, designers, and business analysts. This
cross-functional makeup enables teams to independently tackle different aspects of
the project.
5. Empowered Teams: Agile teams are given the autonomy to make decisions and self-
organize. This empowerment encourages greater ownership, accountability, and
creativity among team members.
6. Frequent Deliveries: Agile methodologies emphasize delivering working increments
of the product at regular intervals. This allows stakeholders to see tangible progress
and provide feedback early and often.
7. Continuous Feedback: Agile projects rely on continuous feedback loops to ensure that
the project is on track and meeting customer expectations. Feedback helps identify
and address issues early, reducing the likelihood of costly rework.
8. Focus on Value: Agile methodologies prioritize delivering features and functionalities
that provide the most value to customers and the business. This focus helps prevent
unnecessary work and ensures that resources are allocated efficiently.
9. Adaptive Planning: Agile projects utilize adaptive planning, which means that the
project plan is not set in stone but is adjusted as new information and feedback
emerge. This flexibility allows the team to respond to changing circumstances.
 10. Face-to-Face Communication: Agile methodologies emphasize direct and open
communication among team members and stakeholders. Face-to-face interactions are
preferred because they are more effective at conveying information and building
rapport.
11. Minimal Documentation: While documentation is important, Agile methodologies
prioritize working software over excessive documentation. Only essential
documentation that adds value to the project is created.
12. Sustainable Pace: Agile methodologies advocate for maintaining a sustainable pace of
work to prevent burnout and ensure the long-term productivity and well-being of the
team members.
13. Quality Focus: Agile practices, such as continuous integration and automated testing,
promote the delivery of high-quality software. Quality assurance is integrated into the
development process, reducing the likelihood of defects.
14. Visualization and Transparency: Agile teams often use visual tools like task boards,
burndown charts, and Kanban boards to make the project's progress and status
transparent to all team members.
These common themes collectively contribute to Agile methodologies' effectiveness in
delivering valuable software in a dynamic and ever-changing environment. While the
specifics of implementation may vary across different Agile approaches, these foundational
principles remain consistent.

2. Methodology Descriptions
1. Scrum: Scrum is a widely used Agile framework that divides projects into fixed-
length iterations called sprints (usually 2-4 weeks). It features a set of roles (Product
Owner, Scrum Master, and Development Team), events (Daily Standup, Sprint
Planning, Sprint Review, and Sprint Retrospective), and artifacts (Product Backlog,
Sprint Backlog, and Increment) to manage and deliver work incrementally.
2. Kanban: Kanban is an Agile methodology focused on visualizing and managing work
through a continuous flow process. Work items are represented on a Kanban board,
moving from one column to another as they progress. This method provides flexibility
and responsiveness to changes in priorities and demand.
3. Extreme Programming (XP): Extreme Programming is an Agile approach that
emphasizes technical excellence and close collaboration between developers and
customers. It includes practices such as Test-Driven Development (TDD), Continuous
Integration, Pair Programming, and frequent releases to ensure high-quality software.
4. Lean Software Development: Inspired by Lean manufacturing principles, this Agile
methodology aims to eliminate waste and maximize customer value. It emphasizes
principles like delivering as fast as possible, optimizing the whole process,
empowering teams, and focusing on continuous improvement.
5. Dynamic Systems Development Method (DSDM): DSDM is an Agile methodology
that provides a framework for project management and delivery. It focuses on
delivering results quickly while maintaining a strong emphasis on quality and
maintaining a controlled development process.
6. Crystal: Crystal is a family of Agile methodologies that adapts to the unique
characteristics of each project. It provides a set of principles, roles, practices, and
ceremonies that can be tailored to the specific needs of the team and project.
 7. Feature-Driven Development (FDD): FDD is an Agile approach that centers around
designing and building features incrementally. It involves creating a high-level
domain model, creating a feature list, planning and designing each feature, and
building and verifying them.
8. Adaptive Software Development (ASD): ASD is an Agile methodology that focuses
on adapting to changing requirements and delivering high-quality software
incrementally. It includes three phases: Speculation, Collaboration, and Learning,
each emphasizing different aspects of development.
9. Agile Unified Process (AUP): AUP is an iterative and incremental Agile methodology
that combines principles from Agile methods and the Unified Process. It provides a
flexible framework for project management and software development, emphasizing
simplicity and continuous feedback.
10. Feature-Driven Agile (FDD Agile): FDD Agile is a blend of Feature-Driven
Development (FDD) and Agile principles. It emphasizes feature-based development,
regular delivery, and customer collaboration, while maintaining the core FDD
practices.
These are just a few examples of Agile methodologies, and there are many more variations
and hybrids that teams can adapt based on their specific needs and preferences. The choice of
methodology often depends on the nature of the project, team dynamics, organizational
culture, and other factors.
What Are the Different Types of Agile Frameworks?
Agile refers to the methods and best practices for organizing projects based on the
values and principles documented in the Agile Manifesto. However, there’s no one right way
to implement Agile, and many different types of frameworks from which to choose.
In this article, we will cover the basics of Agile methodology and explore the different
frameworks.

 Kanban
Kanban methodology is about day-to-day workflows and processes. It is a simple,
visual means of managing projects that enables teams to see the progress so far and what’s
coming up next. Kanban projects are primarily managed through a Kanban board, which
segments tasks into three columns: “To Do,” “Doing,” and “Done.”
Many project management software solutions have Kanban board integration, which
teams can use to plot out a task’s progress from start to finish.
The main benefit of this methodology is the increased transparency, allowing team
leaders to clearly see which tasks are assigned to which team members and what is yet to be
completed to make meaningful progress.

 Scrum
Scrum is one of the most popular Agile methodologies, as it can bring teams together
with a sharp focus and an efficient, collaborative approach to task execution.
It is similar to Kanban in many ways. Scrum typically uses a Scrum board, similar to
a Kanban board, and groups tasks into columns based on progress. Unlike Kanban, Scrum
focuses on breaking a project down into sprints and only planning and managing one sprint at
a time.
 Under this methodology, you would assign a Scrum leader and product owner, who
have a direct influence over the rest of the team. This assigned leadership can help teams to
spearhead projects and complete them over a short space of time through a series of sprints.
Sprints are the Scrum way of breaking projects down into iterations that can last
anywhere between one and four weeks each. Bringing team members together from different
departments, these sprints help you channel a collective focus to your projects.
Scrum also features a robust set of principles and activities that dictate how you work. These
include:
 Sprint planning: Planning sessions to identify the purpose behind your sprints
 Roles: Key roles in the Scrum project management process
 Product backlog: A list of tasks arranged according to priority level

 Extreme Programming (XP)

Extreme Programming (XP) was designed for Agile software development projects. It
focuses on continuous development and customer delivery and uses intervals or sprints,
similar to a Scrum methodology. However, XP also has 12 supporting processes specific to
the world of software development:
 Planning game
 Small releases
 Customer acceptance tests
 Simple design
 Pair programming
 Test-driven development
 Refactoring
 Continuous integration
 Collective code ownership
 Coding standards
 Metaphor
 Sustainable pace
Extreme Programming puts the customer at the center of everything the team does. In XP,
teams can involve the end users in a meaningful way and use the feedback they get to deliver
the best possible product.

 Feature-driven development (FDD)

Feature-driven development is another software-specific Agile framework. This
methodology involves creating software models every two weeks and requires a development
and design plan for every model feature. It has more rigorous documentation requirements
than XP, so it’s better for teams with advanced design and planning abilities. FDD breaks
projects down into five basic activities:
 Develop an overall model
 Build a feature list
 Plan by feature
 Design by feature
 Build by feature
 Dynamic Systems Development Method (DSDM)
The Dynamic Systems Development Method (DSDM) was born of the need for a
common industry framework for rapid software delivery. Rework is to be expected, and any
development changes that occur must be reversible. Like Scrum, XP, and FDD, DSDM uses
sprints. This framework is based on eight fundamental principles:
 Focus on the business need
 Deliver on time
 Collaborate
 Never compromise quality
 Build incrementally from firm foundations
 Develop iteratively
 Communicate continuously and clearly
 Demonstrate control

 Crystal
Crystal is a family of Agile methodologies that includes Crystal Clear, Crystal Yellow,
Crystal Orange, Crystal Red, etc. Each has a unique framework. Your choice depends on
several project factors, such as your team size, priorities, and project criticality.

 Lean
Lean development is often grouped with Agile, but it’s an entirely different methodology
that happens to share many of the same values. The main principles of the Lean
methodology include:
 Eliminating waste
 Build quality in
 Create knowledge
 Defer commitment
 Deliver fast
 Respect people
 Optimize the whole

 Adaptive Project Framework

Adaptive Project Framework, or APF, is an Agile methodology that keeps teams on
their feet, ready to adapt to changing circumstances and project scope.
By breaking each project down into iterative cycles, or phases, teams can frequently check in
and evaluate what’s necessary to complete each small project. Through regular assessment,
teams can react quickly to changes and ensure they stay on track with timelines.
3. Extreme Programming
Extreme Programming (XP) is an Agile software development methodology that emphasizes
collaboration, customer satisfaction, and high-quality code. It was introduced in the late
1990s by Kent Beck and has since gained popularity for its focus on technical excellence and
rapid iterative development. XP is designed to address the challenges of delivering software
in a changing and unpredictable environment. Here are some key principles and practices of
Extreme Programming:
Key Principles:
1. Communication: Encourages close collaboration between developers, customers, and
stakeholders throughout the project. Regular communication helps ensure that
everyone is aligned on project goals and requirements.
2. Simplicity: Promotes simplicity in both design and implementation. Complex
solutions are avoided in favor of the simplest approach that meets the requirements.
3. Feedback: Emphasizes rapid feedback loops through practices like Continuous
Integration and Test-Driven Development (TDD). Frequent feedback helps identify
issues early in the development process.
4. Courage: Encourages team members to be honest about challenges and risks. This
openness enables the team to address problems promptly and adapt to changing
circumstances.
5. Respect: Values the contributions of all team members and fosters a culture of mutual
respect and collaboration.
Key Practices:
1. Test-Driven Development (TDD): In TDD, developers write tests before writing the
actual code. This practice helps ensure that the code meets the intended requirements
and that any changes don't introduce new bugs.
2. Continuous Integration (CI): Developers integrate their code frequently into a shared
repository, and automated tests are run to detect integration issues as early as possible.
3. Pair Programming: Developers work in pairs, with one writing code while the other
reviews and provides immediate feedback. This practice helps improve code quality,
knowledge sharing, and collaboration.
4. Refactoring: Regularly improving the code's structure and design to keep it
maintainable and adaptable over time.
5. Collective Code Ownership: All team members are responsible for the entire
codebase, encouraging collaboration and knowledge sharing.
6. Sustainable Pace: Team members work at a pace that ensures their well-being and
prevents burnout. Long working hours and overtime are discouraged.
7. Small Releases: Frequent and small releases allow for continuous feedback and
reduce the risk associated with large releases.
 8. Customer Involvement: The customer or product owner is actively involved in the
development process, providing feedback and clarifying requirements.
9. Coding Standards: A set of coding standards and practices are followed to ensure
consistency and maintainability.
10. User Stories: Requirements are captured as user stories, short descriptions of features
or functionalities from the user's perspective.

Extreme Programming is particularly suited for projects with rapidly changing requirements,
where the emphasis on feedback, collaboration, and technical excellence helps the team adapt
and deliver high-quality software. While some practices, such as pair programming, may
seem unconventional, they contribute to XP's effectiveness in achieving its goals. However,
the adoption of XP practices should be tailored to the specific needs and context of the
development team and project.
4. Scrum
Scrum is an Agile framework for software development that provides a structured approach
to managing and delivering projects. It focuses on iterative and incremental development,
allowing teams to respond to changing requirements and deliver valuable software quickly.
Scrum was introduced by Jeff Sutherland and Ken Schwaber in the early 1990s and has since
become one of the most popular Agile methodologies. Here's an overview of how Scrum
works:

Roles in Scrum:
1. Product Owner: Represents the customer or stakeholders and is responsible for
defining and prioritizing the product backlog, which is a list of features,
enhancements, and fixes. The product owner ensures that the team works on the most
valuable items first.
2. Scrum Master: Facilitates the Scrum process, supports the team, and removes any
obstacles that might hinder progress. The Scrum Master ensures that Scrum practices
and principles are followed and helps the team improve its processes over time.
3. Development Team: The cross-functional group of individuals responsible for
delivering the product increment. Development teams organize themselves and
collaborate to design, develop, test, and deliver working increments of the product in
each sprint.
Key Concepts and Practices:
1. Sprints: Sprints are time-boxed iterations in which development work takes place.
Each sprint typically lasts 2-4 weeks, during which the team works on a set of
prioritized items from the product backlog.
2. Product Backlog: The product backlog is a dynamic and prioritized list of all the
features, user stories, and tasks that need to be addressed in the project. It's managed
by the product owner and can change based on feedback and evolving requirements.
 3. Sprint Planning: At the beginning of each sprint, the team holds a sprint planning
meeting. During this meeting, the product owner presents the highest-priority items
from the product backlog, and the development team collaboratively decides which
items to include in the sprint backlog.
4. Sprint Backlog: The sprint backlog is a subset of the product backlog items that the
team commits to completing within the sprint. It's a detailed plan that the team uses to
guide their work during the sprint.
5. Daily Scrum (Daily Standup): A daily 15-minute meeting where the team gathers to
discuss progress, challenges, and plans. Each team member answers three questions:
What did I do yesterday? What will I do today? Are there any obstacles?
6. Sprint Review: At the end of each sprint, the team holds a sprint review meeting to
showcase the completed work to stakeholders and gather feedback. This helps ensure
that the product is meeting the intended goals and requirements.
7. Sprint Retrospective: Also held at the end of each sprint, the retrospective is a
meeting where the team reflects on their processes, collaboration, and performance.
They identify what went well, what could be improved, and implement changes to
enhance their effectiveness.
8. Increment: At the end of each sprint, the team produces a potentially shippable
product increment. This is a working version of the product that includes all
completed and tested features from that sprint.
Scrum provides a framework that promotes transparency, inspection, and adaptation. It
enables teams to deliver value in a predictable and flexible manner while continuously
improving their processes. While Scrum provides clear roles, events, and artifacts, it also
allows teams to tailor its practices to their specific context, making it adaptable to various
projects and organizations.
5. Feature-Driven Development (FDD)
Feature-Driven Development (FDD) is an Agile software development methodology that
focuses on designing, building, and delivering software incrementally through a feature-
centric approach. It was created by Jeff De Luca and Peter Coad in the mid-1990s as a
response to the challenges of managing large software projects. FDD emphasizes clear, well-
defined processes for creating features, promoting collaboration among team members, and
delivering value to customers. Here's an overview of how Feature-Driven Development
works:

Key Concepts and Practices:

1. Domain Object Modeling: FDD begins with creating a domain object model, which
is a visual representation of the major classes and relationships within the application.
This helps the team understand the structure of the software and the key business
concepts.
2. Feature List: The project is broken down into a list of features. Each feature is a
small, self-contained piece of functionality that provides value to the end-users or
stakeholders.
3. Feature Owner: Each feature is assigned a feature owner, who is responsible for the
design, development, and delivery of that feature. The feature owner collaborates with
the development team to ensure the feature's successful implementation.
4. Feature Design: For each feature, a design session takes place to define the details of
how the feature will be implemented. This includes designing the class structure,
methods, and other necessary components.
5. Development by Feature: The development process is organized around building
one feature at a time. Development teams work on the features in parallel, with each
feature owner coordinating the work within their area of responsibility.
 6. Regular Builds: The project is continuously integrated, and regular builds are
performed to ensure that features are integrated and tested together. This helps
identify and address integration issues early.
7. Inspections: Regular inspections and walkthroughs are conducted to review the code
and design. This helps ensure code quality and adherence to coding standards.
8. Component/Class Ownership: Developers take ownership of specific classes or
components, which encourages accountability and expertise in specific areas of the
application.
9. Frequent Releases: FDD emphasizes delivering working software frequently.
Features are developed, tested, and integrated, allowing for incremental releases that
provide value to users.
10. Overall Model Inspection: Periodically, the entire development team participates in
an "overall model inspection," where the entire domain object model is reviewed and
updated based on new insights or changes.
11. Status Reporting: Project progress and status are tracked using various metrics, such
as the percentage of completed features and their associated quality metrics.
FDD's structured approach and emphasis on clear design and feature ownership make it well-
suited for complex projects with large teams. It helps manage complexity by breaking down
the development process into manageable chunks, ensuring that the software is delivered in
increments, and enabling continuous feedback. While FDD provides a defined process, it is
also flexible and adaptable, allowing teams to tailor its practices to their specific needs and
project requirements.
6. The Crystal Methodologies
 The crystal method is an agile framework that is considered a lightweight or agile
methodology that focuses on individuals and their interactions. The methods are
color-coded to significant risk to human life. It is mainly for short-term projects by a
team of developers working out of a single workspace. Among a few Agile Software
Development Life Cycle (SDLC) models crystal is considered as one of the Agile
SDLC models. Two core beliefs of the Crystal method:
 Find your own way and methods to optimize workflow.
 Make use of unique methods to make the project unique and dynamic.

How does Crystal function?

Till now, we got to know that crystal is a family of various developmental approaches,
and it is not a group of prescribed developmental tools and methods. In the beginning, the
approach is set by considering the business requirements and the needs of the project. Various
methodologies in the Crystal family also known as weights of the Crystal approach are
represented by different colors of the spectrum.

Crystal family consists of many variants like Crystal Clear, Crystal Yellow, Crystal Red,
Crystal Sapphire, Crystal Red, Crystal Orange Web, and Crystal Diamond.
1. Crystal Clear- The team consists of only 1-6 members that is suitable for short-term
projects where members work out in a single workspace.
2. Crystal Yellow- It has a small team size of 7-20 members, where feedback is taken
from Real Users. This variant involves automated testing which resolves bugs faster
and reduces the use of too much documentation.
3. Crystal Orange- It has a team size of 21-40 members, where the team is split
according to their functional skills. Here the project generally lasts for 1-2 years and
the release is required every 3 to 4 months.
4. Crystal Orange Web- It has also a team size of 21-40 members were the projects that
have a continually evolving code base that is being used by the public. It is also
similar to Crystal Orange but here they do not deal with a single project but a series of
initiatives that required programming.
5. Crystal Red- The software development is led by 40-80 members where the teams
can be formed and divided according to requirements.
6. Crystal Maroon- It involves large-sized projects where the team size is 80-200
members and where methods are different and as per the requirement of the software.
7. Crystal Diamond & Sapphire- This variant is used in large projects where there is a
potential risk to human life.
7. Adaptive Software Development
Adaptive Software Development is a method to build complex software and system. ASD
focuses on human collaboration and self-organization. ASD “life cycle” incorporates three
phases namely:
1. Speculation
2. Collaboration
3. Learning

1. Speculation: During this phase project is initiated and planning is conducted. The
project plan uses project initiation information like project requirements, user needs,
customer mission statement, etc, to define set of release cycles that the project wants.
2. Collaboration: It is the difficult part of ASD as it needs the workers to be motivated. It
collaborates communication and teamwork but emphasizes individualism as individual
creativity plays a major role in creative thinking. People working together must trust each
others to
 Criticize without animosity,
 Assist without resentment,
 Work as hard as possible,
 Possession of skill set,
 Communicate problems to find effective solution.
3. Learning: The workers may have a overestimate of their own understanding of the
technology which may not lead to the desired result. Learning helps the workers to increase
their level of understanding over the project. Learning process is of 3 ways:
 Focus groups
 Technical reviews
 Project postmortem
ASD’s overall emphasis on the dynamics of self-organizing teams, interpersonal
collaboration, and individual and team learning yield software project teams that have a much
higher likelihood of success.
8. Dynamic Systems Development Method
The Dynamic Systems Development technique (DSDM) is an associate degree agile
code development approach that provides a framework for building and maintaining systems.
The DSDM philosophy is borrowed from a modified version of the sociologist principle—80
% of An application is often delivered in twenty percent of the time it’d desire deliver the
entire (100 percent) application.
DSDM is An iterative code method within which every iteration follows the 80% rule
that simply enough work is needed for every increment to facilitate movement to the
following increment. The remaining detail is often completed later once a lot of business
necessities are noted or changes are requested and accommodated.
The DSDM tool (www.dsdm.org) could be a worldwide cluster of member companies
that put together tackle the role of “keeper” of the strategy. The pool has outlined AN Agile
Development Model, known as the DSDM life cycle that defines 3 different unvarying
cycles, preceded by 2 further life cycle activities:
1. Feasibility Study:
It establishes the essential business necessities and constraints related to the applying
to be designed then assesses whether or not the application could be a viable
candidate for the DSDM method.
2. Business Study:
It establishes the use and knowledge necessities that may permit the applying to
supply business value; additionally, it is the essential application design and identifies
the maintainability necessities for the applying.
3. Functional Model Iteration:
It produces a collection of progressive prototypes that demonstrate practicality for the
client.
(Note: All DSDM prototypes are supposed to evolve into the deliverable application.)
The intent throughout this unvarying cycle is to collect further necessities by eliciting
feedback from users as they exercise the paradigm.
4. Design and Build Iteration:
It revisits prototypes designed throughout useful model iteration to make sure that
everyone has been designed during a manner that may alter it to supply operational
business price for finish users. In some cases, useful model iteration and style and
build iteration occur at the same time.
5. Implementation:
It places the newest code increment (an “operationalized” prototype) into the
operational surroundings. It ought to be noted that:
(a) the increment might not 100% complete or,
(b) changes are also requested because the increment is placed into place. In either
case, DSDM development work continues by returning to the useful model iteration
activity.
 DSDM is often combined with XP to supply a mixed approach that defines a solid
method model (the DSDM life cycle) with the barmy and bolt practices (XP) that are needed
to create code increments. additionally, the ASD ideas of collaboration and self-organizing
groups are often tailored to a combined method model.
9. Lean Software Development
Lean Software Development (LSD) is an agile framework that is used to streamline &
optimize the software development process. It may also be referred to as Minimum Viable
Product (MVP) strategy as these ways of thinking are very much alike since both intend to
speed up development by focusing on new deliverables.
Toyota has been credited to inspire the lean development approach which is meant for
optimizing production and minimize waste. Seeing Toyota’s lean approach many other
manufacturing teams started to follow the same strategy. And it was first adopted in software
development in 2003.
Advantages of LSD:
LSD has proved to improve software development in the following ways :
1. LSD removes the unnecessary process stages when designing software so that it acts
as a time saver as simplifies the development process.
2. LSD simplifies the development process and saves time by removing unnecessary
stages.
3. It prioritizes essential functions and removes the risk of spending time on valueless
builds.
4. It increases the involvement of team members, optimizing the workflow and reducing
losses.
5. LSD encourages collaboration and communication among team members and
stakeholders.
6. It fosters innovation through experimentation and creativity.
7. It reduces waste by minimizing unnecessary features.
8. LSD increases customer satisfaction through customer involvement and feedback.
9. It improves flexibility by allowing for adaptability to changing requirements and
circumstances.
Key Principles of Lean Software Development:
There are 7 established lean principles that come with a set of tactics, practices, and processes
that builds more efficient software products:
 Eliminating the Waste: To identify and eliminate wastes e.g. unnecessary code,
delay in processes, inefficient communication, the issue with quality, data duplication,
more tasks in the log than completed, etc. regular meetings are held by Project
Managers. Which allows team members to point out faults and suggest changes in the
next turn.
 Fast Delivery: Previously long time planning used to be the key success in business,
but in the passage of time it is found that engineers spend too much time on building
complex systems with unwanted features. So they came up with an MVP strategy
which resulted in the building products quickly that included a little functionality and
launch the product to market and see the reaction. Such an approach allows them to
enhance the product on the basis of customer feedback.
 Amplify Learning: Learning is improved through ample code reviewing, meeting
that is cross-team applicable. It is also ensured that particular knowledge isn’t
accumulated by one engineer who’s writing a particular piece of code so paired
programming is used.
 Builds Quality: LSD is all about prevent waste, keeping an eye on not sacrificing
quality. Developers often apply test-driven programming to examine the code before
it is written. The quality can also be gained to get constant feedback from team
members and project managers.
 Respect Teamwork: LSD focuses on empowering team members, rather than
controlling them. Setting up a collaborative atmosphere, keep perfect balance when
there are short deadlines and immense workload. This method becomes very much
important when new members join a well-established team.
 Delay the Commitment: In traditional project management it often happens when
you make your application and it turns out to be completely unfit for the market. LSD
method recognizes this threat and makes room for improvement by postponing
irreversible decisions until all experiment is done. This methodology always
constructs software as flexible, so the new knowledge is available and engineers can
make improvements.
 Optimizing the whole system: lean’s principle allows managers to break an issue
into small constituent parts to optimize the team’s workflow, create unity among
members, and inspire a sense of shared responsibility which results in enhancing the
team performance.
10. Starting Monday: Investigate Further Selecting an Approach that Fits: Choosing
between an Agile or Traditional Approach
Traditional project management is an established methodology where projects are run
in a sequential cycle: initiation, planning, execution, monitoring, and closure. The traditional
project management approach emphasizes linear processes, documentation, upfront planning,
and prioritization. As per the conventional method, time and budget are variable, and
requirements are fixed, due to which it often faces budget and timeline issues.
On the other hand, Agile methodology is a management process that empowers you
and your team to respond to the ever-changing nature of business. It uses iterative work
sequences, which are also known as sprints. At the heart of any Agile project management is
the work. Maintaining focus on the project allows teams to reflect on immediate needs
regularly and adjust course as necessary.
Agile follows an iterative process where projects are divided into sprints of a shorter
span. Unlike the traditional approach, less time is spent on upfront planning and prioritization
as agile is more flexible in changes and specifications developments.
Both methodologies have their advantages and disadvantages. Here are some of them:
 Pros of Traditional Approach
o Clear documentation
o More accountability
o Clearly defined objectives
o Ultimate control
 Cons of Traditional Approach
o Slow process
o Lack of flexibility
o High cost
o Limited Customer Involvement
o Limited Innovation
 Pros of Agile Approach
o Flexible prioritization
o Early and predictable delivery
o Predictable costs and schedules
o Improves quality
o More transparency
 Cons of Agile Approach
o Constant feedback from the client or stakeholder can be overwhelming for
some teams.
o Shared responsibility can help teams get more done in less time but may lead
to confusion if not managed properly.
o Issues can be addressed and resolved during daily meetings but may lead to
burnout if not managed properly.
11. Selecting the Right Agile Approach
Selecting the right Agile approach is essential to ensure project success and alignment with
your team's capabilities and project requirements. Here's a concise guide to help you choose
the most suitable Agile approach:
1. Understand Your Project: Clarify the project's size, complexity, and scope. Identify
whether it's a small, focused project or a larger initiative involving multiple teams or
stakeholders.
2. Team Dynamics: Assess your team's skills, experience, and familiarity with Agile
practices. Consider whether your team members are comfortable with specific
methodologies or practices.
3. Customer Involvement: Determine the level of customer involvement required. If
close collaboration and frequent feedback are crucial, consider methodologies like
Scrum or Extreme Programming.
4. Change Frequency: Evaluate how often requirements are likely to change during the
project. For projects with evolving requirements, Agile methods like Scrum, Kanban,
or Adaptive Software Development are suitable.
5. Predictability vs. Flexibility: Balance the need for predictability with flexibility. If
your project benefits from a more structured approach, Scrum might be appropriate.
For a more adaptive approach, consider Adaptive Software Development or Crystal
methodologies.
6. Project Scale: Match the scale of the project to the methodology's capabilities. For
small teams and projects, Crystal Clear or Feature-Driven Development can be
effective. Larger projects might benefit from Scrum with multiple teams or LeSS
(Large Scale Scrum).
7. Documentation and Process: Consider the balance between documentation and
agility. If your project requires more documentation, Lean Software Development or
Disciplined Agile Delivery might be suitable.
8. Continuous Improvement: Prioritize methodologies that encourage continuous
improvement and feedback, as these can help your team evolve and enhance their
practices.
9. Project Environment: Assess your organizational culture and its readiness for Agile
adoption. Some methodologies might align better with your organization's values and
practices.
10. Resource Availability: Consider the availability of resources like time, budget, and
team members. Choose a methodology that optimizes resource utilization and aligns
with constraints.
11. Experimentation and Learning: If the project involves new technologies or
uncharted territory, methodologies like Scrum, XP, or Adaptive Software
Development can facilitate experimentation and learning.
12. Customization: Opt for methodologies that allow customization. Crystal
methodologies, for example, can be tailored to match your project's unique needs.
Remember that there's no one-size-fits-all answer. The ideal Agile approach depends on your
project's specifics, team dynamics, and organizational context. It's also important to remain
open to adjustments and iterations as you gather feedback and learn from your chosen
methodology's application.