COURSE 5455 | 3-day SESSION
Hands-On Extreme Programming Workshop

---

Course Outline

Section I: Introduction to eXtreme Programming
A. Discussion on the principles of XP

1. Humanity
   
2. Economics
   
3. Mutual benefit
   
4. Self similarity
   
5. Diversity
   
6. Reflection
   
7. Flow
   
8. Quality
   
9. Baby steps
   
10. Accepted responsibility
    

B. Discussion on the practices of XP

1. Planning
   
2. Small releases
   
3. Metaphor
   
4. Simple designs
   
5. Unit testing
   
6. Refactoring
   
7. Pair programming
   
8. Collective code ownership
   
9. Continuous integration
   
10. Sustainable pace
    
11. On-site customer
    
12. Coding standard
    
13. Acceptance testing
    

C. Predictive vs. adaptive processes

1. Heavyweight processes and the unpredictability in software development
   
2. Listening for and responding to change
   

D. Feedback mechanisms

1. Comprehensive test suite
   
2. Integrated customer
   
3. Whole team interaction
   
4. Continuous improvement in estimation
   

E. Iterative development

1. Focus on delivery
   
2. Short release cycles
   
3. Addressing highest priorities first
   

F. The "four variables" of every software project

1. Time, quality, cost, scope
   
2. Mitigating risks through scope management
   

G. Managing the costs of change
H. Leveling the cost-curve

1. Decision making strategies
   
2. Design and integration strategies
   
3. Communication and quality strategies
   

I. XP life-cycle
J. Team roles and responsibilities

1. Customer, Developer, Manager
   
2. Responsibilities of each role
   
3. Interdependencies between the roles
   

Section II: Planning
A. Organizing the whole team

1. How the roles on an XP team participate in the formulation of a release plan
   

B. Allocation of authority

1. Business decisions
   
2. Technical decisions
   

C. Planning responsibilities among the team

1. Dates, scope, priority
   
2. Estimation, tracking, development
   

D. Business cycles & development cycle
E. The XP project timeline

1. Projects, releases, iterations, and tasks
   

F. Story-driven workflow

1. Customer and developer activities and responsibilities
   
2. Connecting the workflow to plan formulation
   

G. The Planning Game

1. The rules, the players, and the flow
   

H. Story writing

1. The role of user stories
   
2. Characteristics of good user stories
   

I. Estimation at the story and task level

1. Dealing with interdependencies
   
2. Activities to include in the estimate
   
3. Understanding how scope influences estimates
   
4. Using past experience in story estimation
   
5. What to do when no experience exists for a story context
   

J. Release Planning

1. Customer story selection
   
2. Developer story estimation
   
3. Negotiation and compromise
   
4. How far to plan and when to adjust the plan
   
5. Documenting the plan
   

K. Iteration Planning

1. Iterations as milestones
   
2. Planning workflow at the iteration level
   
3. Establishing regular duration
   
4. Selecting stories for the team
   
5. How to run an iteration planning meeting
   

L. Breaking tasks out of stories

1. Decomposing stories into the tasks needed to complete them
   
2. How tasks become developer work products
   
3. Sharing tasks between stories
   

M. Iteration tracking

1. Tracking as a feedback mechanism
   
2. Doing load-balancing to keep the teams commitments viable
   

N. Stand-up meetings

1. Regular daily communication as a feedback mechanism
   
2. Purpose and format
   
3. How to run the daily stand-up meeting
   

O. Measuring the team velocity

1. What "velocity" represents and how to use it in planning
   
2. How to calculate the velocity of the team
   

P. Load-balancing within the team

1. Responding to overload
   

Q. End-of-Iteration Demo (the proof is in the pudding)

1. Demo as a feedback mechanism
   
2. How to run an iteration wrap-up meeting
   

R. Evolving the process with Retrospectives

1. What has worked and what hasn't worked (yet another feedback mechanism)
   
2. Setting the tone for an open and honest retrospective
   
3. Integrating input back into the process
   

Section III: Principles of Automated Testing
A. Test-Driven Development

1. The relationship between testing and design
   
2. "How to": Steps of TDD
   
3. The benefits: repeatability, coverage, simplified code, less debugger use
   

B. When to write and run automated tests
C. Guiding development at different levels

1. Considering the interface at the unit, integration, and user level and applying testing techniques as guides for design
   

D. What to test (and how)

1. Business rules
2. Exceptional conditions
   
3. Bugs
   
4. "Published" interfaces
   
5. Interactions and observable side-effects at the unit/integration/acceptance levels
   

E. Test-writing strategies

1. Using descriptive language to communicate intent
   
2. Dealing with large tests or complex testing targets
   
3. Testing the "contract" vs. the implementation
   

Section IV: Acceptance Testing
A. Overview for application-level testing

1. Expressing business rules in testable form
   
2. Using language from the business domain
   

B. Story Test-Driven development

1. Step-by-step guide for expressing story details as items in a test
   
2. Considering testable requirements
   
3. Automating story tests
   
4. Handling tests that cannot be automated
   

C. Pairing with customers to capture business-rules tests
D. FIT - The Framework for Integrated Test

1. The origin and approach of the FIT framework
   
2. The accessibility of table-based testing
   
3. FIT Fixtures, connecting the framework to your
   

E. Calculation-style testing (Column Fixture)

1. Describing business rules that apply cleanly to and outputs
   
2. The composition and layout of the table
   
3. A fixture to support table expectations
   

F. Observing groups of values (Row Fixture)
G. Conversational interaction testing (Action Fixture)

1. The system "device" metaphor
   
2. Keywords that describe the interaction with the demonstrate and observe business rule enforcement
   
3. The layout of the table and the fixture to support
   

H. Testing flow-like sequences

1. The FitLibrary extension to FIT
   
2. Using DoFixture as an alternative to ActionFixture
   
3. Focusing on readability in the expression of flow-
   
4. Setting up a testing context, expressing expectations observing outcome
   

Section V: Unit Testing
A. What is a unit?
B. Considering responsibilities at the unit-level
C. Step-by-step unit testing
D. How test-driven development promotes open design

1. The use of interfaces and other "mockable" structures dependencies between concrete types
   

E. Testing in isolation

1. Mocks, stubs and the difference between the
2. Interaction-based vs. state-based testing
   

F. Unit testing tools (JUnit)

1. Assertions and test runners
   

Section VI: Refactoring
A. Definition and motivation for refactoring
B. How refactoring complements design
C. When to refactor
D. The automated test safety-net
E. Eliminating code "smells" with refactoring

1. Duplicated code
   
2. Long methods
   
3. Large classes or classes with too much responsibility
   
4. Switch statements
   
5. Over-dependence on primitive types
   
6. Feature envy
   

F. Refactoring patterns

1. Extract method
   
2. Form template method
   
3. Change bidirectional association to unidirectional
   
4. Extract class
   
5. Replace data value with object
   
6. Replace conditional with polymorphism
   
7. Replace parameter with explicit methods