Course Outline
Section I: Introduction to eXtreme Programming
A. Discussion on the principles of XP
- Humanity
- Economics
- Mutual benefit
- Self similarity
- Diversity
- Reflection
- Flow
- Quality
- Baby steps
- Accepted responsibility
B. Discussion on the practices of XP
- Planning
- Small releases
- Metaphor
- Simple designs
- Unit testing
- Refactoring
- Pair programming
- Collective code ownership
- Continuous integration
- Sustainable pace
- On-site customer
- Coding standard
- Acceptance testing
C. Predictive vs. adaptive processes
- Heavyweight processes and the unpredictability in software development
- Listening for and responding to change
D. Feedback mechanisms
- Comprehensive test suite
- Integrated customer
- Whole team interaction
- Continuous improvement in estimation
E. Iterative development
- Focus on delivery
- Short release cycles
- Addressing highest priorities first
F. The "four variables" of every software project
- Time, quality, cost, scope
- Mitigating risks through scope management
G. Managing the costs of change
H. Leveling the cost-curve
- Decision making strategies
- Design and integration strategies
- Communication and quality strategies
I. XP life-cycle
J. Team roles and responsibilities
- Customer, Developer, Manager
- Responsibilities of each role
- Interdependencies between the roles
Section II: Planning
A. Organizing the whole team
- How the roles on an XP team participate in the formulation of a release plan
B. Allocation of authority
- Business decisions
- Technical decisions
C. Planning responsibilities among the team
- Dates, scope, priority
- Estimation, tracking, development
D. Business cycles & development cycle
E. The XP project timeline
- Projects, releases, iterations, and tasks
F. Story-driven workflow
- Customer and developer activities and responsibilities
- Connecting the workflow to plan formulation
G. The Planning Game
- The rules, the players, and the flow
H. Story writing
- The role of user stories
- Characteristics of good user stories
I. Estimation at the story and task level
- Dealing with interdependencies
- Activities to include in the estimate
- Understanding how scope influences estimates
- Using past experience in story estimation
- What to do when no experience exists for a story context
J. Release Planning
- Customer story selection
- Developer story estimation
- Negotiation and compromise
- How far to plan and when to adjust the plan
- Documenting the plan
K. Iteration Planning
- Iterations as milestones
- Planning workflow at the iteration level
- Establishing regular duration
- Selecting stories for the team
- How to run an iteration planning meeting
L. Breaking tasks out of stories
- Decomposing stories into the tasks needed to complete them
- How tasks become developer work products
- Sharing tasks between stories
M. Iteration tracking
- Tracking as a feedback mechanism
- Doing load-balancing to keep the teams commitments viable
N. Stand-up meetings
- Regular daily communication as a feedback mechanism
- Purpose and format
- How to run the daily stand-up meeting
O. Measuring the team velocity
- What "velocity" represents and how to use it in planning
- How to calculate the velocity of the team
P. Load-balancing within the team
- Responding to overload
Q. End-of-Iteration Demo (the proof is in the pudding)
- Demo as a feedback mechanism
- How to run an iteration wrap-up meeting
R. Evolving the process with Retrospectives
- What has worked and what hasn't worked (yet another feedback mechanism)
- Setting the tone for an open and honest retrospective
- Integrating input back into the process
Section III: Principles of Automated Testing
A. Test-Driven Development
- The relationship between testing and design
- "How to": Steps of TDD
- The benefits: repeatability, coverage, simplified code, less debugger use
B. When to write and run automated tests
C. Guiding development at different levels
- Considering the interface at the unit, integration, and user level and applying testing techniques as guides for design
D. What to test (and how)
- Business rules
- Exceptional conditions
- Bugs
- "Published" interfaces
- Interactions and observable side-effects at the unit/integration/acceptance levels
E. Test-writing strategies
- Using descriptive language to communicate intent
- Dealing with large tests or complex testing targets
- Testing the "contract" vs. the implementation
Section IV: Acceptance Testing
A. Overview for application-level testing
- Expressing business rules in testable form
- Using language from the business domain
B. Story Test-Driven development
- Step-by-step guide for expressing story details as items in a test
- Considering testable requirements
- Automating story tests
- Handling tests that cannot be automated
C. Pairing with customers to capture business-rules tests
D. FIT - The Framework for Integrated Test
- The origin and approach of the FIT framework
- The accessibility of table-based testing
- FIT Fixtures, connecting the framework to your
E. Calculation-style testing (Column Fixture)
- Describing business rules that apply cleanly to and outputs
- The composition and layout of the table
- A fixture to support table expectations
F. Observing groups of values (Row Fixture)
G. Conversational interaction testing (Action Fixture)
- The system "device" metaphor
- Keywords that describe the interaction with the demonstrate and observe business rule enforcement
- The layout of the table and the fixture to support
H. Testing flow-like sequences
- The FitLibrary extension to FIT
- Using DoFixture as an alternative to ActionFixture
- Focusing on readability in the expression of flow-
- 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
- The use of interfaces and other "mockable" structures dependencies between concrete types
E. Testing in isolation
- Mocks, stubs and the difference between the
- Interaction-based vs. state-based testing
F. Unit testing tools (JUnit)
- Assertions and test runners
Section VI: Refactoring
A. Definition and motivation for re-factoring
B. How re-factoring complements design
C. When to re-factor
D. The automated test safety-net
E. Eliminating code "smells" with re-factoring
- Duplicated code
- Long methods
- Large classes or classes with too much responsibility
- Switch statements
- Over-dependence on primitive types
- Feature envy
F. Refactoring patterns
- Extract method
- Form template method
- Change bidirectional association to unidirectional
- Extract class
- Replace data value with object
- Replace conditional with polymorphism
- Replace parameter with explicit methods
