Log In
Or create an account -> 
Imperial Library
  • Home
  • About
  • News
  • Upload
  • Forum
  • Help
  • Login/SignUp

Index
The Art of Agile Development
SPECIAL OFFER: Upgrade this ebook with O’Reilly Preface
For the Pragmatists Who Should Read This Book About the Études About Pronouns Using Code Examples Safari® Enabled How to Contact Us Acknowledgments
James Shore Shane Warden
I. Getting Started
1. Why Agile?
Understanding Success Beyond Deadlines The Importance of Organizational Success Enter Agility
Organizational Success Technical Success Personal Success
2. How to Be Agile
Agile Methods Don’t Make Your Own Method The Road to Mastery Find a Mentor
3. Understanding XP
The XP Lifecycle
How It Works
Planning Analysis Design and coding Testing Deployment
Our Story Continues
The XP Team
The Whole Team On-Site Customers
The product manager (aka product owner) Domain experts (aka subject matter experts) Interaction designers Business analysts
Programmers
Designers and architects Technical specialists
Testers Coaches
The programmer-coach The project manager
Other Team Members The Project Community
Stakeholders The executive sponsor
Filling Roles Team Size Full-Time Team Members
XP Concepts
Refactoring Technical Debt Timeboxing The Last Responsible Moment Stories Iterations Velocity Theory of Constraints Mindfulness
4. Adopting XP
Is XP Right for Us?
Prerequisite #1: Management Support
If management isn’t supportive...
Prerequisite #2: Team Agreement
If people resist...
Prerequisite #3: A Colocated Team
If your team isn’t colocated...
Prerequisite #4: On-Site Customers
If your product manager is too busy to be on-site... If your product manager is inexperienced... If you can’t get a product manager at all... If you can’t get other on-site customers...
Prerequisite #5: The Right Team Size
If you don’t have even pairs... If your team is larger than seven programmers... If your team is smaller than four programmers... If you have many developers working solo...
Prerequisite #6: Use All the Practices
If practices don’t fit...
Recommendation #1: A Brand-New Codebase
If you have preexisting code...
Recommendation #2: Strong Design Skills
If no one has strong design skills...
Recommendation #3: A Language That’s Easy to Refactor
If your language is hard to refactor...
Recommendation #4: An Experienced Programmer-Coach
If you have no obvious coach... If your leaders are inexperienced... If you’re assigned a poor coach...
Recommendation #5: A Friendly and Cohesive Team
If your team doesn’t get along...
Go!
The Challenge of Change Final Preparation Applying XP to a Brand-New Project (Recommended) Applying XP to an Existing Project
The big decision Bring order to chaos Pay down technical debt Organize your backlog Fix important bugs Move testers forward Emerge from the darkness
Applying XP in a Phase-Based Organization
Mandatory planning phase Mandatory analysis phase Mandatory design phase Mandatory coding phase Mandatory testing phase Mandatory deployment phase
Extremities: Applying Bits and Pieces of XP
Iterations Retrospectives Ten-minute build Continuous integration Test-driven development Other practices
Assess Your Agility
Self-Assessment Quiz
II. Practicing XP
5. Thinking
Pair Programming
Why Pair? How to Pair Driving and Navigating Pairing Stations Challenges
Comfort Mismatched skills Communication style Tools and keybindings
Questions Results Contraindications Alternatives Further Reading
Energized Work
How to Be Energized Supporting Energized Work Taking Breaks Questions Results Contraindications Alternatives Further Reading
Informative Workspace
Subtle Cues Big Visible Charts Hand-Drawn Charts Process Improvement Charts Gaming Questions Results Contraindications Alternatives Further Reading
Root-Cause Analysis
How to Find the Root Cause How to Fix the Root Cause When Not to Fix the Root Cause Questions Results Contraindications Alternatives
Retrospectives
Types of Retrospectives How to Conduct an Iteration Retrospective Step 1: The Prime Directive Step 2: Brainstorming Step 3: Mute Mapping Step 4: Retrospective Objective After the Retrospective Questions Results Contraindications Alternatives Further Reading
6. Collaborating
Trust
Team Strategy #1: Customer-Programmer Empathy Team Strategy #2: Programmer-Tester Empathy Team Strategy #3: Eat Together Team Strategy #4: Team Continuity Impressions Organizational Strategy #1: Show Some Hustle Organizational Strategy #2: Deliver on Commitments Organizational Strategy #3: Manage Problems Organizational Strategy #4: Respect Customer Goals Organizational Strategy #5: Promote the Team Organizational Strategy #6: Be Honest Questions Results Contraindications Alternatives Further Reading
Sit Together
Accommodating Poor Communication A Better Way Exploiting Great Communication Secrets of Sitting Together Making Room Designing Your Workspace Sample Workspaces
A small workspace
Adopting an Open Workspace Questions Results Contraindications Alternatives Further Reading
Real Customer Involvement
Personal Development In-House Custom Development Outsourced Custom Development Vertical-Market Software Horizontal-Market Software Questions Results Contraindications Alternatives
Ubiquitous Language
The Domain Expertise Conundrum Two Languages How to Speak the Same Language Ubiquitous Language in Code Refining the Ubiquitous Language Questions Results Contraindications Alternatives Further Reading
Stand-Up Meetings
How to Hold a Daily Stand-Up Meeting Be Brief Questions Results Contraindications Alternatives Further Reading
Coding Standards
Beyond Formatting How to Create a Coding Standard Dealing with Disagreement Adhering to the Standard Questions Results Contraindications Alternatives
Iteration Demo
How to Conduct an Iteration Demo Two Key Questions Weekly Deployment Is Essential Questions Results Contraindications Alternatives
Reporting
Types of Reports Progress Reports to Provide
Vision statement Weekly demo Release and iteration plans Burn-up chart
Progress Reports to Consider
Roadmap Status email
Management Reports to Consider
Productivity Throughput Defects Time usage
Reports to Avoid
Source lines of code (SLOC) and function points Number of stories Velocity Code quality
Questions Results Contraindications Alternatives Further Reading
7. Releasing
“Done Done”
Production-Ready Software How to Be “Done Done” Making Time Questions Results Contraindications Alternatives
No Bugs
How Is This Possible? How to Achieve Nearly Zero Bugs Ingredient #1: Write Fewer Bugs Ingredient #2: Eliminate Bug Breeding Grounds Ingredient #3: Fix Bugs Now Ingredient #4: Test Your Process Ingredient #5: Fix Your Process Invert Your Expectations Questions Results Contraindications Alternatives Further Reading
Version Control
Concurrent Editing Time Travel Whole Project Customers and Version Control Keep It Clean Single Codebase Appropriate Uses of Branches Questions Results Contraindications Alternatives Further Reading
Ten-Minute Build
Automate Your Build How to Automate When to Automate Automating Legacy Projects Ten Minutes or Less Questions Results Contraindications Alternatives
Continuous Integration
Why It Works How to Practice Continuous Integration Never Break the Build The Continuous Integration Script
To update from the repository To integrate
Introducing Continuous Integration Dealing with Slow Builds Multistage Integration Builds Questions Results Contraindications Alternatives
Collective Code Ownership
Making Collective Ownership Work Working with Unfamiliar Code Hidden Benefits Questions Results Contraindications Alternatives
Documentation
Work-In-Progress Documentation Product Documentation Handoff Documentation Questions Results Contraindications Alternatives
8. Planning
Vision
Product Vision Where Visions Come From Identifying the Vision Documenting the Vision How to Create a Vision Statement Promoting the Vision Questions Results Contraindications Alternatives Further Reading
Release Planning
One Project at a Time Release Early, Release Often How to Release Frequently An Example Adapt Your Plans Keep Your Options Open How to Create a Release Plan Planning at the Last Responsible Moment Adaptive Planning and Organizational Culture Questions Results Contraindications Alternatives Further Reading
The Planning Game
How to Play
Overcoming disagreements
How to Win Questions Results Contraindications Alternatives
Risk Management
A Generic Risk-Management Plan Project-Specific Risks How to Make a Release Commitment Success over Schedule When Your Commitment Isn’t Good Enough Questions Results Contraindications Alternatives Further Reading
Iteration Planning
The Iteration Timebox The Iteration Schedule How to Plan an Iteration The Commitment Ceremony After the Planning Session Dealing with Long Planning Sessions Tracking the Iteration When Things Go Wrong Partially Done Work Emergency Requests The Batman Questions Results Contraindications Alternatives
Iteration length
Further Reading
Slack
How Much Slack? How to Introduce Slack Research Time When Your Iteration Commitment Is at Risk
Use refactoring as a shock absorber Incur a little voluntary overtime Cancel research time
Don’t Cross the Line Reducing the Need for Slack Questions Results Contraindications Alternatives
Reading groups Silver stories
Further Reading
Stories
Story Cards Customer-Centricity Splitting and Combining Stories Special Stories
Documentation stories “Nonfunctional” stories Bug stories Spike stories Estimating Meetings Architecture, design, refactoring, and technical infrastructure
Questions Results Contraindications Alternatives Further Reading
Estimating
What Works (and Doesn’t) in Estimating Velocity Velocity and the Iteration Timebox How to Make Consistent Estimates How to Estimate Stories How to Estimate Iteration Tasks When Estimating Is Difficult Explaining Estimates How to Improve Your Velocity
Pay down technical debt Improve customer involvement Support energized work Offload programmer duties Provide needed resources Add programmers (carefully)
Questions Results Contraindications Alternatives Further Reading
9. Developing
Incremental Requirements
The Living Requirements Document Work Incrementally
Vision, features, and stories Rough expectations Mock-ups, customer tests, and completion criteria Customer review
Questions Results Contraindications Alternatives Further Reading
Customer Tests
Describe Demonstrate Develop Focus on Business Rules Ask Customers to Lead Automating the Examples Questions Results Contraindications Alternatives Further Reading
Test-Driven Development
Why TDD Works How to Use TDD
Step 1: Think Step 2: Red bar Step 3: Green bar Step 4: Refactor Step 5: Repeat
A TDD Example
The task One name/value pair An empty string testNull() valueFor() Multiple name/value pairs Multiple count() Your turn
Testing Tools Speed Matters Unit Tests Focused Integration Tests End-to-End Tests TDD and Legacy Code Questions Results Contraindications Alternatives Further Reading
Refactoring
Reflective Design
Divergent Change and Shotgun Surgery Primitive Obsession and Data Clumps Data Class and Wannabee Static Class Coddling Nulls Time Dependencies and Half-Baked Objects
Analyzing Existing Code How to Refactor Refactoring in Action Questions Results Contraindications Alternatives Further Reading
Simple Design
You Aren’t Gonna Need It (YAGNI) Once and Only Once Self-Documenting Code Isolate Third-Party Components Limit Published Interfaces Fail Fast Questions Results Contraindications Alternatives Further Reading
Incremental Design and Architecture
How It Works Continuous Design Incrementally Designing Methods Incrementally Designing Classes Incrementally Designing Architecture Risk-Driven Architecture It’s Not Just Coding Questions Results Contraindications Alternatives Further Reading
Spike Solutions
About Spikes Performing the Experiment Scheduling Spikes Questions Results Contraindications Alternatives
Performance Optimization
How to Optimize When to Optimize How to Write a Performance Story Questions Results Contraindications Alternatives Further Reading
Exploratory Testing
About Exploratory Testing Tool #1: Charters Tool #2: Observation Tool #3: Notetaking Tool #4: Heuristics
None, Some, All Goldilocks: too big, too small, just right Position: beginning, middle, end Count: zero, one, many CRUD: create, read, update, delete Command Injection Data Type Attacks
An Example When You Find Bugs Questions Results Contraindications Alternatives Further Reading
III. Mastering Agility
10. Values and Principles
Commonalities About Values, Principles, and Practices Further Reading
11. Improve the Process
Understand Your Project
In Practice Beyond Practices
Tune and Adapt
In Practice Beyond Practices
Break the Rules
In Practice Beyond Practices
12. Rely on People
Build Effective Relationships
In Practice Beyond Practices
Let the Right People Do the Right Things
In Practice Beyond Practices
Build the Process for the People
In Practice Beyond Practices
13. Eliminate Waste
Work in Small, Reversible Steps
In Practice Beyond Practices
Fail Fast
In Practice Beyond Practices
Maximize Work Not Done
In Practice Beyond Practices
Pursue Throughput
In Practice Beyond Practices
14. Deliver Value
Exploit Your Agility
In Practice Beyond Practices
Only Releasable Code Has Value
In Practice Beyond Practices
Deliver Business Results
In Practice Beyond Practices
Deliver Frequently
In Practice Beyond Practices
15. Seek Technical Excellence
Software Doesn’t Exist Design Is for Understanding Design Trade-offs Quality with a Name Great Design Universal Design Principles
The Source Code Is the (Final) Design Don’t Repeat Yourself (DRY) Be Cohesive Decouple Clarify, Simplify, and Refine Fail Fast Optimize from Measurements Eliminate Technical Debt
Principles in Practice Pursue Mastery
References Index About the Authors Colophon SPECIAL OFFER: Upgrade this ebook with O’Reilly
  • ← Prev
  • Back
  • Next →
  • ← Prev
  • Back
  • Next →

Chief Librarian: Las Zenow <zenow@riseup.net>
Fork the source code from gitlab.

This is a mirror of the Tor onion service:
http://kx5thpx2olielkihfyo4jgjqfb7zx7wxr3sd4xzt26ochei4m6f7tayd.onion