PadhaikoAll subjects

Agile Approaches

Agile Methodologies (ENCT 465)

Open in the Padhaiko app

3.1 The Umbrella of Agile Approaches: Broad overview

Agile is not a single rigid methodology; it is an umbrella mindset defined by the 4 values and 12 principles of the Agile Manifesto. Underneath that umbrella sits a family of complementary frameworks and engineering methods, each emphasizing a different facet of product delivery.

Definition

The Agile Umbrella

The Agile Umbrella groups iterative, incremental, and flow-based methodologies that share empirical control, customer collaboration, and adaptive planning while differing in cadence, prescribed roles, and engineering rigor. Most mature teams combine practices across multiple approaches—for example, using Scrum for planning cadence, XP for technical practices, and Kanban for workflow visualization.

Major Frameworks Under the Agile Umbrella
ApproachPrimary FocusTypical Cadence / FlowSignature Mechanisms
ScrumEmpirical product management and team accountabilityFixed-length Sprints (1–4 weeks)3 Roles (PO, SM, Developers), 3 Artifacts, 5 Events
KanbanVisualizing flow and matching WIP to capacityContinuous flow (pull-based)Kanban board, explicit WIP limits, Cycle Time & Lead Time
Extreme Programming (XP)Engineering excellence and low defect ratesVery short releases (1–2 weeks) + continuous integrationTDD, Pair Programming, Refactoring, Simple Design, CI
Lean Product DevelopmentMaximizing customer value and eliminating wasteValue-stream flow7 Wastes, Amplify Learning, Defer Commitment, Optimize Whole
Crystal Family (Cockburn)Tailoring ceremony weight to team size and project criticalityIterative (1–4 months max)Osmotic communication, reflective improvement
FDD (Feature-Driven Dev.)Modeling and building tangible client-valued featuresShort feature iterations (2 days–2 weeks)Domain object modeling, feature lists, design/build by feature
DSDMBusiness-driven governance for enterprise projectsTimeboxes with MoSCoW prioritizationMust/Should/Could/Won't scope control, early prototyping

3.2 Lean Product Development: Principles (eliminate waste, amplify learning, fast delivery)

Adapted from the Toyota Production System (TPS) by Mary and Tom Poppendieck in Lean Software Development, Lean Product Development focuses on delivering maximum customer value through a smooth value stream while relentlessly removing anything that adds cost without adding user value.

Definition

The Seven Principles of Lean Software Development

  1. Eliminate Waste: Remove every activity, artifact, or feature that does not directly create value for the customer.
  2. Amplify Learning: Treat software development as continuous discovery using short feedback loops, prototypes, spikes, and user testing.
  3. Decide as Late as Possible (Defer Commitment): Keep design and business options open until the last responsible moment—the point where failing to decide eliminates an important alternative.
  4. Deliver as Fast as Possible: Shrink batch sizes and remove delays so customers receive value rapidly and feedback returns before assumptions go stale.
  5. Empower the Team: Respect the people doing the work; let local technical experts make design decisions rather than centralizing approvals.
  6. Build Integrity In: Ensure both perceived integrity (the product feels cohesive to users) and conceptual integrity (clean, tested, refactored architecture).
  7. Optimize the Whole (See the Whole): Optimize the end-to-end concept-to-cash value stream rather than locally optimizing one department (e.g., rushing coding while creating a huge QA bottleneck).

3.2.1 The Seven Wastes of Software Development

In Lean, any step that consumes time or money without improving the customer's outcome is waste (muda):

The Seven Wastes of Software Development (Poppendieck)
Lean Software WasteConcrete Example in Software ProjectsLean Countermeasure
1. Partially Done WorkUnmerged branches, untested code, or unreviewed specs sitting idle for weeks.Small stories finished end-to-end inside each iteration; Continuous Integration.
2. Extra Features (Gold Plating)Building complex settings or speculative features customers never requested or use.Simplicity (Manifesto Principle 10), MVP validation, strict backlog prioritization.
3. RelearningSolving the same bug twice or rediscovering lost knowledge when staff rotate.Automated regression tests, pair programming, concise living docs.
4. HandoffsPassing specs from BA -> Architect -> Developer -> Tester -> Ops via tickets.Cross-functional product teams collaborating daily without organizational walls.
5. DelaysWaiting days for environment provisioning, manager sign-offs, or code reviews.Self-service CI/CD pipelines, empowered team authority, WIP limits.
6. Task SwitchingAssigning a developer to 3–4 simultaneous projects, causing constant context loss.Dedicated single-team focus and strict WIP limits.
7. DefectsBugs escaping to late QA or production, multiplying fix and support cost.Test-Driven Development (TDD), pair programming, automated build verification.

3.2.2 Deep Dive on Three Core Syllabus Pillars


3.3 Kanban: Managing flow and limiting work in progress (WIP)

Kanban (Japanese for "visual signal" or "signboard") is a pull-based flow management method formalized for software and knowledge work by David J. Anderson. Unlike Scrum, Kanban does not prescribe fixed-length sprints or mandatory roles; instead, it overlays evolutionary flow discipline onto an existing process.

Definition

Core Principles and Practices of Kanban

Kanban focuses on continuous flow governed by six core practices:

  1. Visualize the Workflow: Represent every stage of work as columns on a Kanban board (e.g., Backlog | Ready | In Dev | Code Review | Testing | Done).
  2. Limit Work in Progress (WIP): Cap the maximum number of items allowed inside each active column (e.g., In Dev [Max 3], Testing [Max 2]). New work is pulled only when a slot opens downstream.
  3. Manage Flow: Monitor work movement continuously to eliminate stalls, queues, and bottlenecks.
  4. Make Process Policies Explicit: Post clear, shared rules (such as Definition of Ready and exit criteria for each column).
  5. Implement Feedback Loops: Hold regular stand-ups ("walk the board" right-to-left), service delivery reviews, and replenishment meetings.
  6. Improve Collaboratively, Evolve Experimentally: Use flow metrics to test small Kaizen improvements.

3.3.1 Why Limiting WIP Improves Throughput and Speed

When teams start too many items simultaneously ("push system"), developers context-switch constantly, code reviews pile up, and every item sits waiting in queues. Limiting WIP creates a pull system:

Little's Law for Kanban FlowText
Average Cycle Time (CT) = Average WIP / Average Throughput (TH)
Lead Time               = Time from customer request (commitment) to Done
Cycle Time              = Time from starting active work to Done
Throughput (TH)         = Items completed per unit time (e.g., stories per week)

By Little's Law, if team Throughput stays constant (or rises due to less context switching), cutting WIP in half cuts Cycle Time in half!


3.4 Scrum Framework: Roles (Scrum Master, Product Owner, Dev Team), artifacts, and events

Scrum is a lightweight framework created by Ken Schwaber and Jeff Sutherland that uses empirical process control to help people, teams, and organizations generate value through adaptive solutions for complex problems.

Definition

The Scrum 3-3-5 Structure

Scrum is built around 3 Roles (Accountabilities), 3 Artifacts (each with an explicit commitment), and 5 Events inside a 1–4 week Sprint:

3.4.1 Scrum Roles (Accountabilities)

3.4.2 Scrum Artifacts and Their Commitments

Scrum Artifacts and Commitments
ArtifactOwnerPurposeAssociated Commitment
Product BacklogProduct OwnerEmergent, ordered list of everything needed to improve the product.Product Goal (long-term objective for the product)
Sprint BacklogDevelopersSelected Product Backlog items + actionable plan for delivering the Increment.Sprint Goal (single unifying objective for the current Sprint)
IncrementWhole Scrum TeamConcrete stepping stone toward the Product Goal; additive sum of all completed items.Definition of Done (DoD) (formal quality criteria required for shippable work)

3.4.3 The Five Scrum Events

Scrum Events and Standard Timeboxes (for a 1-Month Sprint)
EventTimebox (1-Month Sprint)Typical (2-Week Sprint)ParticipantsCore Objective (Inspect & Adapt)
1. The Sprint1–4 weeks (fixed)2 weeksWhole Scrum TeamContainer event enclosing all other events to produce a Done Increment.
2. Sprint PlanningMax 8 hours~4 hoursWhole Scrum TeamDefine Why (Sprint Goal), What (selected PBIs), and How (initial work plan).
3. Daily ScrumMax 15 minutes daily15 minutes dailyDevelopers (SM/PO optional)Inspect progress toward the Sprint Goal and adapt the next 24-hour plan.
4. Sprint ReviewMax 4 hours~2 hoursScrum Team + StakeholdersInspect the working Increment, gather feedback, and adapt the Product Backlog.
5. Sprint RetrospectiveMax 3 hours~1.5 hoursWhole Scrum TeamInspect people, interactions, processes, tools, and DoD; plan improvements.

3.5 Extreme Programming (XP): Engineering practices (TDD, refactoring, pair programming)

Created by Kent Beck in the late 1990s, Extreme Programming (XP) takes proven software engineering practices and applies them continuously at an "extreme" level to keep the cost of changing code flat over time. XP is grounded in five values: Communication, Simplicity, Feedback, Courage, and Respect.

Definition

Core XP Engineering Practices

3.5.1 The TDD Red-Green-Refactor Cycle

Test-Driven Development (TDD) CycleText
1. RED      : Write a small automated unit test for one new behavior; run it and watch it FAIL.
2. GREEN    : Write the simplest production code needed to make the test PASS.
3. REFACTOR : Clean up duplication, improve naming/design, and re-run ALL tests to confirm GREEN.
   (Repeat every few minutes!)
Comparison: Scrum, Kanban, and Extreme Programming (XP)
FeatureScrumKanbanExtreme Programming (XP)
CadenceFixed-length Sprints (1–4 weeks)Continuous flow (no required sprints)Very short iterations (1–2 weeks) + daily CI
Prescribed RolesPO, Scrum Master, DevelopersNo mandatory new rolesCustomer, Coach, Programmer, Tracker
Change PolicyAvoid changes mid-sprint that endanger Sprint GoalPull new items anytime a WIP slot opensWelcomes changes even mid-iteration if work hasn't started
WIP ControlImplicit via Sprint capacityExplicit WIP limits per board columnSmall stories + single-piece continuous flow
Engineering PracticesNot prescribed (team chooses)Not prescribedStrictly prescribed (TDD, Pairing, CI, Refactoring)

Example 3.1

3.1

A software team uses Kanban to process user stories. Initially, they have no WIP limit: on average 12 stories sit in active development at once (WIP = 12), and they complete 4.0 stories per week (Throughput = 4.0 stories/week).

  1. Using Little's Law, calculate the team's average Cycle Time (in weeks).
  2. Management introduces a strict column WIP limit capping active work at 6 stories (WIP = 6). Assuming throughput initially stays at 4.0 stories/week, what is the new average Cycle Time?
  3. If reduced context switching boosts throughput by 20% to 4.8 stories/week at WIP = 6, calculate the improved Cycle Time and the overall percentage reduction in Cycle Time compared to the original baseline.

Baseline Cycle Time (Unbounded WIP = 12): By Little's Law, Cycle Time = WIP / Throughput:

  • Cycle Time (baseline) = 12 / 4.0 = 3.00 weeks per story.

Immediate Effect of Capping WIP at 6 (Constant Throughput = 4.0):

  • Cycle Time (WIP = 6, TH = 4.0) = 6 / 4.0 = 1.50 weeks per story (a 50% reduction solely from cutting queue congestion).

Cycle Time with Higher Throughput (WIP = 6, TH = 4.8):

  • Cycle Time (improved) = 6 / 4.8 = 1.25 weeks per story.
  • Percentage reduction from baseline = ((3.00 - 1.25) / 3.00) x 100 = (1.75 / 3.00) x 100 = 58.33%.
Answer:
  1. Baseline Cycle Time: 3.00 weeks
  2. Cycle Time at WIP = 6 (TH = 4.0): 1.50 weeks
  3. Cycle Time at WIP = 6 (TH = 4.8): 1.25 weeks (58.33% faster than baseline)
Example 3.2

3.2

A Scrum team runs 2-week (10-working-day) Sprints, scaling standard 1-month (4-week) Scrum event timeboxes proportionally (except Daily Scrum, which is always 15 minutes/day). Calculate the scaled timebox in hours for:

  1. Sprint Planning
  2. Daily Scrum (total across 10 working days)
  3. Sprint Review
  4. Sprint Retrospective
  5. Total ceremony time per 2-week Sprint.

Scaling Ratio for a 2-Week Sprint vs. 1-Month (4-Week) Sprint: Scale factor = 2 weeks / 4 weeks = 0.5.

  • Sprint Planning: 8 hours x 0.5 = 4.0 hours.
  • Sprint Review: 4 hours x 0.5 = 2.0 hours.
  • Sprint Retrospective: 3 hours x 0.5 = 1.5 hours.

Daily Scrum Total and Overall Ceremony Time: Daily Scrum is fixed at 15 minutes (0.25 hours) per working day regardless of Sprint length:

  • Daily Scrum (10 days): 10 x (15 / 60) = 2.5 hours.
  • Total ceremony time: 4.0 + 2.0 + 1.5 + 2.5 = 10.0 hours across the 2-week Sprint.
Answer:
  • Sprint Planning: 4.0 hours
  • Daily Scrum (10 days): 2.5 hours total (15 minutes/day)
  • Sprint Review: 2.0 hours
  • Sprint Retrospective: 1.5 hours
  • Total Ceremony Time: 10.0 hours per 2-week Sprint
Example 3.3

3.3

Exam-Style Application Question: A 6-person team uses Scrum, holds all five events on time, and delivers features every 2 weeks—yet every third sprint is spent exclusively fixing regression bugs, and developers refuse to edit complex legacy billing modules written by a colleague who left. Identify which Agile approach addresses this gap and recommend three concrete practices from it.

Diagnosing the Gap: Scrum provides the project management cadence (roles, artifacts, events) but does not prescribe technical engineering practices. Regression spikes and fear of touching legacy modules indicate missing Extreme Programming (XP) engineering discipline (and Lean's Build Integrity In principle).

Three Concrete XP Practices to Adopt:

  1. Test-Driven Development (TDD): Build an automated unit and regression test suite so refactoring legacy code no longer risks silent regressions.
  2. Pair Programming & Collective Code Ownership: Pair developers on the billing module so knowledge spreads and no single module remains "untouchable."
  3. Continuous Refactoring & CI: Run automated tests on every commit and refactor duplicated or brittle code incrementally inside every sprint rather than waiting for dedicated "bug-fix sprints."
Answer:

Adopt Extreme Programming (XP) engineering practices alongside Scrum—specifically TDD (automated safety net against regressions), Pair Programming with Collective Code Ownership (eliminating single-person code silos), and Continuous Refactoring + CI (keeping technical debt under control every sprint).


Exercises

Practice Exercises — Agile Approaches

Question 1

Explain why Agile is described as an "umbrella" rather than a single methodology, and summarize when an organization would choose Scrum, Kanban, or Extreme Programming (XP).

Why Agile Is an Umbrella: The Agile Manifesto defines 4 shared values and 12 principles, not a single process recipe. Multiple frameworks implement those values in different ways depending on product stability, team size, and technical needs.

Choosing Between Scrum, Kanban, and XP:

  • Scrum: Best when a cross-functional team builds a complex product in predictable 1–4 week rhythms requiring regular stakeholder Sprint Reviews and clear Product Owner prioritization.
  • Kanban: Best for continuous-flow environments (operations, support, maintenance, DevOps) where priorities arrive unpredictably and controlling WIP/Cycle Time matters more than fixed sprints.
  • Extreme Programming (XP): Best (often layered inside Scrum) when high code change rates demand strict software engineering rigor—TDD, refactoring, pair programming, and continuous integration.
Answer:

Agile is an umbrella of values/principles encompassing diverse practices: Scrum structures empirical sprint cadence and roles, Kanban optimizes continuous pull flow via WIP limits, and XP enforces disciplined coding practices to sustain rapid change.

Question 2

State the seven principles of Lean Software Development and identify five of the seven Lean wastes with one software-engineering countermeasure for each.

Seven Lean Software Development Principles:

  1. Eliminate Waste, 2. Amplify Learning, 3. Decide as Late as Possible, 4. Deliver as Fast as Possible, 5. Empower the Team, 6. Build Integrity In, 7. Optimize the Whole.

Five Lean Wastes and Countermeasures:

  1. Partially done work -> Complete small vertical stories end-to-end every sprint with CI.
  2. Extra features (gold plating) -> Prioritize strictly by customer value (MVP/Simplicity).
  3. Handoffs -> Form cross-functional teams containing dev, test, and UX together.
  4. Task switching -> Dedicate developers to one team and cap active WIP.
  5. Defects -> Apply TDD, pair programming, and automated regression suites.
Answer:

Lean rests on Eliminate Waste, Amplify Learning, Decide as Late as Possible, Deliver Fast, Empower the Team, Build Integrity In, and Optimize the Whole. Key wastes—partially done work, extra features, handoffs, task switching, and defects—are eliminated via small batches, cross-functional teams, WIP limits, and TDD/CI.

Question 3

Describe the Scrum 3-3-5 framework (3 roles, 3 artifacts with their commitments, and 5 events), and explain how empirical process control operates inside each event.

3 Roles and 3 Artifacts (+ Commitments):

  • Roles: Product Owner (value maximization), Scrum Master (Scrum coaching and impediment removal), Developers (cross-functional increment delivery).
  • Artifacts & Commitments: Product Backlog (Product Goal), Sprint Backlog (Sprint Goal), Increment (Definition of Done).

5 Events and Empiricism:

  1. The Sprint: Timeboxed container (1–4 weeks) ensuring regular inspection/adaptation loops.
  2. Sprint Planning: Inspects Product Backlog and capacity to adapt a Sprint Goal and plan.
  3. Daily Scrum: 15-minute developer inspection of Sprint Goal progress to adapt daily work.
  4. Sprint Review: Inspects the Done Increment with stakeholders to adapt the Product Backlog.
  5. Sprint Retrospective: Inspects team interactions, tools, and DoD to adapt team practices.
Answer:

Scrum comprises 3 roles (Product Owner, Scrum Master, Developers), 3 artifacts with commitments (Product Backlog/Product Goal, Sprint Backlog/Sprint Goal, Increment/Definition of Done), and 5 timeboxed events (Sprint, Sprint Planning, Daily Scrum, Sprint Review, Sprint Retrospective) that enforce transparency, inspection, and adaptation.

Question 4

Explain Test-Driven Development (TDD), Refactoring, and Pair Programming in Extreme Programming (XP), and describe how these three practices reinforce one another.

Individual Definitions:

  • TDD: Write a failing unit test first (Red), write minimal passing code (Green), then clean up structure (Refactor).
  • Refactoring: Improving internal code readability and modularity without altering external behavior.
  • Pair Programming: Two programmers share one workstation as Driver (typing) and Navigator (continuous design/edge-case review).

Mutual Reinforcement: TDD creates an automated regression safety net that makes Refactoring safe and fearless. Pair Programming catches design flaws early during TDD, spreads codebase familiarity, and ensures refactoring standards are upheld consistently.

Answer:

TDD follows Red-Green-Refactor, Refactoring cleans internal design without altering behavior, and Pair Programming combines a tactical Driver with a strategic Navigator. Together, TDD makes refactoring safe while pairing boosts test and design quality.

Question 5

A DevOps Kanban team currently has an average of 15 tickets in progress (WIP = 15) and a steady throughput of 3.0 tickets per day (TH = 3.0 tickets/day).

  1. What is the team's current average Cycle Time in days?
  2. If the team enforces explicit column limits that bring average WIP down to 6 tickets while maintaining throughput at 3.0 tickets/day, what is the new Cycle Time and the percentage improvement?

Current Average Cycle Time: Using Little's Law (Cycle Time = WIP / Throughput):

  • Cycle Time (before) = 15 / 3.0 = 5.0 days per ticket.

New Cycle Time and Percentage Improvement:

  • Cycle Time (after WIP limit) = 6 / 3.0 = 2.0 days per ticket.
  • Reduction = 5.0 - 2.0 = 3.0 days.
  • Percentage improvement = (3.0 / 5.0) x 100 = 60.0%.
Answer:
  1. Current Cycle Time: 5.0 days
  2. New Cycle Time at WIP = 6: 2.0 days (60.0% faster delivery)
← Agile manifesto and principlesAgile Roles, Behaviors, and Team Dynamics →