Some Extreme Programming

Essentials

“Software development fails to deliver, and fails to deliver value. This failure has huge economic and human impact. We need to find a new way to develop software.”

Kent Beck, Extreme Programming Explained

Extreme Programming (XP) is a lightweight, incremental method, influential not only as a highly successful process (for smaller projects) but for the innovative practices (tools and techniques) described and the agile philosophy espoused.

XP values

• communication,
• simplicity,
• feedback and
• courage.

“For small projects, Agile, extreme programming and high-level programming languages are key practices because coding is the dominant activity for small applications.”

Capers Jones, Software Engineering Best Practices

XP believes in

• rapid feedback,
• assuming simplicity,
• incremental change,
• embracing change and
• quality work.

“The exact limits of XP aren't clear yet. But there are some absolute showstoppers that prevent XP from working — big teams, distrustful customers, technology that doesn't support graceful change.”

Kent Beck, Extreme Programming Explained

XP practices

• pair programming,
• the planning game,
• short releases,
• simple design,
• metaphor,
• testing,
• refactoring,
• collective ownership,
• continuous integration,
• 40 hour week,
• with (at least one) customer on-site and
• coding standards.

“We can drive ourselves crazy with expectation. But by preparing for every eventuality we can think of, we leave ourselves vulnerable to the eventualities we can't imagine.”

Kent Beck, Extreme Programming Explained

XP separates traditional project management into

• coaching and
• tracking.

“XP is a lightweight, efficient, low risk, flexible, predictable, scientific, and fun way to develop software.”

Kent Beck, Extreme Programming Explained

Selected

Seed

• Extreme Programming
• XP Roadmap
• The New Methodology

Read

• Extreme programming explained
• The Art of Agile Development
• Extreme programming installed

Feed

• Ron Jeffries @RonJeffries
• Kent Beck @KentBeck
• James Shore @JamesShore

Some Testing

Essentials

“Optimism is an occupational hazard of programming. Feedback is the treatment.”

Kent Beck

TDD seemed so revolutionary when it test infected Jakarta (and most of the rest of Apache). This test automation proved a notable factor in the later success of Tomcat, Struts, Ant, Maven, Commons (and all the rest).

Tests bridge the gap between the language of the customer and the languages of software. Test first encourages alignment by starting with the customer then working inwards towards code.

Fine-grain unit tests execute fast, exercising a unit in isolation. Loosely coupled, cohesive designs are easier to unit test, so unit testing rewards good object-scale design.

Coarse-grain tests, exercising integrated components execute much more slowly, even with appropriate techniques (for example, switching to an in-memory store). Component-scale integration tests encourage cleaner, more reusable API designs.

The outermost layer exercises assembled applications. Fidelity to customer configuration is essential, and often means filling heavyweight stores with data. Set up and tear down costs are almost always high for enterprise applications.

Reasonable coverage using slow running integration and application layer tests costs. Avoid disrupting development flow: separate integration and application suites, and run them outside this flow. Consider triggering continuous integration after each commit. To avoid maintenance issues, integration test selectively, invest in good fixtures and use the language of the customer.

A wide variety of open source tools continue to emerge, with sweet spots spanning the space. So spike.

Tools like Cucumber and Fitness use the language of the customer, a fine match for outer (application and integration) layers. Mocking frameworks efficiently create test doubles to isolate the unit from its environment, and to efficiently verify behaviour (but not at the same time as state).

Efficient tools for special topics abound, for example web applications, load testing, performance testing, Swing, data access, JavaScript and so on...

Selected

Seed

• Cucumber
• XUnitTestPatterns
• Mocks Aren't Stubs

Read

• Test-driven development
• XUnit Test Patterns
• Specification by Example
  

Feed

• Gojko Adzic @gojkoadzic
• Martin Fowler @martinfowler
• Dan North @tastapod

Some Evolutionary Design

Essentials

“The best architectures, requirements, and designs emerge from self-organizing teams. ”

A Principle, The Agile Manifesto

Good design — perhaps a loosely coupled, appropriate blend of expressive, cohesive components — speaks for itself.

When XP arrived, democratising design — empowering the developer crowd — seemed radical. To some it still does.

Agile design bubbles up, just-in-time. Complementary practices, tools and techniques facilitate design evolution and mitigate risks.

Selected

Seed

• Is Design Dead?
• Essential XP: Emergent Design
• Big Design Up Front

Read

• Extreme Programming Explained
• Test-driven Development
• Refactoring

Feed

• Martin Fowler @martinfowler
• Abby Fichtner @HackerChick
• Kent Beck @KentBeck

Some Emergent Architecture

Essentials

“Architecture is about the important stuff. Whatever that is.”

Ralph Johnson

Just-in-time approaches to design fit well into agile development.

Evolutionary design reduces waste from over-engineering and design stock-piling; at the cost of some future reworking — a traditional focus of software architects.

Just-in-time approaches to architecture blend harmoniously with agile.

Let architecture emerge incrementally with no big upfront process.
Pay off pressing technical design debts before they become critical.

“Architecture is the decisions that you wish you could get right early in a project.”

Ralph Johnson

Selected

Seed

• Martin Fowler
• Six Principles of Agile Architecture
• Software Architecture in the Agile Life Cycle

Read

• Who Needs an Architect?

Feed

• Martin Fowler @martinfowler
• Dean Leffingwell
  
  

Some Story Points

Essentials

“velocity is a useful long-term predictor but is not a useful short-term predictor”

Mike Cohn

Story points are an artificial, relative unit of measure for development effort, often combined with timeboxed agile methods to estimate velocity.

Story points are coarse and atomic, arising from intuitive inductive judgement. Trade accuracy for speed, at the possible cost of future rework.

Teams may use tools — such as planning poker — to reach collective consensus valuations.

Estimates for
epics — supersized stories not yet decomposed — are almost always inaccurate.

So avoid unfounded perceptions of precision by limiting point values to a sequence — often inspired by Fibonacci.

Selected

Seed

• What Story Points Are Better Than Hours
• Explaining Story Points To Management
• Advantages of User Stories for Requirements
  

Read

• Agile Estimating and Planning
  
• User Stories Applied
  

Feed

• Mike Cohn @mikewcohn
• Scrum Log @jeffsutherland

Some Continuous Delivery

Essentials

“Release Early, Release Often”

Eric Steven Raymond

Agile development finishes features to a regular cadence, a rhythmic flow of potentially releasable versions.

By Christopher Little

The DevOps movement seeks a stronger but more dynamic relationship between upstream teams and downstream consumers in operations.

Continuous delivery engineers a pipeline for the last mile, extending from integration through proof to delivery.

“move from delivering services using projects to delivering them as products”

Jez Humble

Selected

Seed

• Continuous Delivery: The Value Proposition
• Anatomy of the Deployment Pipeline
• What DevOps Means for Enterprises

Read

• The Cathedral and the Bazaar
• Continuous Delivery

Feed

• Jez Humble @jezhumble
• Dave Farley
• Planet DevOps

Some Open Design

Essentials

“ Open source is chaotic. With its special magic comes a different reality. ”

James Duncan Davidson

Issuing open source an license is not enough. The benefits ascribed arise from opening the development process to a broad community.

Open design extends domain driven, consensual, emergent design beyond the agile team to engage a wider ecosystem.

Community building is non-trivial.
Sustainable communication and cooperation needs space to build and maintain relationships.

Walking the fine balance between technical leadership and openness to crowdsourced design ideas is an art.

Selected

Seed

• OSS Watch
• How Linux Kernel Development Works
• How The ASF Works

Read

• Producing Open Source Software
• Community Types
• FOSS Foundations

Feed

• OSS Watch @osswatch
• Ross Gardler @rgardler
• Simon Phipps @webmink
  

Some Planning Poker

Essentials

“The estimates are a useful by-product, if your organisation values such things, but actually the most important benefit you get from planning poker is the conversation.”

Matt Wynne

Playing planning poker exploits physicality, consensus and team collaboration to improve agile estimates.

And it's a fun way to get the work done.

Buy, make or take a set of cards.

Numbered each with story points, Fibonacci sequenced or not.

Each player is dealt cards with every number for each hand.

To play a hand, all reveal a card with their private estimate then discuss
outliers.

Until consensus - or timebox - repeat.

Selected

Seed

• James Grenning
• Do It Yourself Agile
• Mountain Goat

Read

• Planning Poker
• Agile estimating and planning

Feed

• Damon Poole @damonpoole
• Mike Cohn @mikewcohn
• James Grenning @jwgrenning

Some Kanban

Essentials

“All kanban systems are designed to limit work-in-progress, because the more work-in-progress, the slower the flow.”

Leading Lean Software Development

Kanban exploits physicality and pull scheduling to improve flow, and so throughput.

Downstream consumer demand pulls through the stages of a processing pipeline.

Progress may be visualised through a grid, visible to all players, showing the work in progress.

To improve flow, limit work in progress by focussing on bottlenecks. Eliminate waste.

A good solution for complicated processes, and a useful tool for complex problems.

Selected

Seed

• Lean Software Development
• Limited WIP Society
• Lean Software Engineering

Read

• Leading Lean Software Development

Feed

• Lean Essays @mpoppendieck
• Ash Moran @patchspace

Some Velocity

“Responding to change over following a plan”

The Agile Manifesto

Software development is complex, developers are not an interchangeable commodity and teams scale chaotically.
Domains with these flavours favour
empirical estimation techniques, such as velocity.

This technique extrapolates estimates from historic team velocity — story points done per unit timebox.

Selected

Read

• Agile Estimation and Planning
• Succeeding with Agile

Feed

• Mike Cohn @mikewcohn

Some Scrum

Essentials

Scrum is an agile, iterative and incremental framework for teams developing complex products, that is simple to describe but hard to master.

A scrum team has one product owner, one scrum master and 6±3 cross-functional self-organising developers.

Each sprint begins with one planning ceremony and ends with one review and one retrospective. Every day begins with one daily scrum. These events encourage inspection and adaptation.

Product and sprint backlogs are recorded. The orthodox school insists on burndown charts that are optional in the reformed school.
Rules relate these roles, events and artifacts into a prescriptive but extensible framework.

Of course, this description captures the mechanics but not the spirit.

Selected

Seed

• mountaingoatsoftware
• scrumalliance
• scrum

Read

• The Scrum Guide
• Succeeding with Agile

Feed

• Ken Schwaber @kschwaber
• Jeff Sutherland @jeffsutherland