Scaling Software Agility: Best Practices for Large Enterprises
- What Are We Changing with Agile?
- The Heartbeat of Agile: Working Code in a Short Time Box
- Summary
This chapter is from the book
This chapter is from the book
This chapter is from the book
With Ryan Martens1
- Conceptually, agile is simple. Most everything is different.
What Are We Changing with Agile?
We've now reviewed a variety of agile methods and an iterative and incremental one that can be applied in a substantially agile fashion. As we begin to analyze them for commonality, we will find many common practices among them, and these common practices, plus a few extensions, form the basis for Parts II and III of this book.
And yet, when we compare the methods in aggregate to our former plan-based, stage-gated, and waterfall-like processes, we find far more differences than similarities. Indeed, it would not be too extreme to say that when it comes to software development and software project management in general, agile changes everything, as Figure 7-1 shows.
)
Figure 7-1 Changing paradigms in agile
These changing paradigms provide both the power and the consternation of agile, because addressing change on such a wholesale basis in an enterprise is not a trivial thing. And yet, team by team, organizations are making these changes over time, allowing them to approach the full benefits of agile development. Let's examine each of these new paradigms to see what additional clues we can find as to what is so different about agile.
New Measures of Success
The basic measures of success are different in agile. Teams and organizations evolve from conformance to plan2 to the ability to respond to change.
|
Measure of Success |
Conformance to plan |
Response to change, working code |
|
Work breakdown structure |
Feature breakdown |
|
|
Single, detailed, complete plan |
Two-level plan |
|
|
Serial functions |
Parallel functions |
|
|
Follow the plan |
Adapt to changing facts |
|
|
Procedural stage gates |
Time boxes, inspections |
|
|
Documents models, reviews |
Working code |
This transition involves moving from traditional work breakdown structures to a "value-delivery focus" by implementing stories and requirements on a prioritized basis. Procedural and documentation stage gates are replaced with success measures based on working, tested, and demonstrated code. The plan is fluid and flexible; the actual is the best that can be achieved under the facts present at the time. More importantly, the actual is potentially shippable.
Different Management Culture
In many ways, agile turns the traditional approach to software management upside down.
|
Management Culture |
Command and control |
Leadership/collaborative |
|
Management defines dates and scope |
Teams bid stories |
|
|
Management dictates implementation |
Team selects approach |
|
|
Culture of sign-offs |
Shared learning |
|
|
Protect the scope |
Protect the date |
|
|
Demonstrate at end |
Demonstrate always |
|
|
Weekly status meetings |
Daily stand-up meeting |
Traditionally, management fixed scope, dates, and resources and set the technical direction for the team. Management was also responsible for the team's performance. In agile, the table is turned. Management sets direction; the teams bid the work and figure out how to accomplish as much of the work as possible in the time frame given. The team self-organizes as necessary to meet the objectives. The team makes the technical decisions and corrects them on the fly as necessary.
Management's job is to eliminate impediments within the organization and trust the team to meet the objectives (this trust is reinforced daily with visibility of progress and the presence of working, integrated code). In turn, the team is fully accountable for the deliverable and is responsible for meeting the dates and delivering the requisite quality. Team empowerment and team accountability are two sides of the same agile coin.
Different Approach to Requirements, Architecture, and Design
Our strategies for how to approach requirements, architecture, and design evolve as well.
|
Requirements and Design |
Big and up front |
Continuous/emergent/just-in-time |
|
Marketing requirements up front |
Vision and backlog |
|
|
Software specification up front |
Just-in-time elaboration |
|
|
Models and plans |
Build in increments |
|
|
Big design up front |
LRM3 design decisions |
|
|
Architecture is planned |
Architecture emerges |
Instead of investing months in building detailed software requirements specifications, architectural models, and even prototypes, teams focus on delivering early, value-added stories into an integrated baseline. Early delivery serves to test the requirements and architectural assumptions, and it drives risk out by proving or disproving assumptions about integration of features and components. If it doesn't work, the team refactors the code until it does, allowing for constant user feedback and visibility along the way.
No longer do management and the user community wait breathlessly for months, hoping that the team is building the right thing. At worst, the next checkpoint is only a week or so away, and with a little luck and foresight, users may be able to deploy or at least evaluate even the earliest iterations in their own working environment.
Revised Coding and Implementation Practices
Coding is different too. Instead of the developers working on all the functionality in parallel with a big bang at the end, the whole team "swarms" over the earliest and highest priorities first.
|
Coding and Implementation |
Code all features in parallel/test later |
Code and unit test, deliver serially |
|
Build in parallel |
Build serially |
|
|
Integrate late |
Integrate continuously |
|
|
Hand off to test |
Partner with test |
|
|
Demonstrate at end |
Demonstrate always |
|
|
Individual code responsibility |
Shared code ownership |
|
|
Never miss dev. complete date |
Never break the build |
|
|
Test code later |
Code unit test first |
Integration is continuous. Testing is not deferred; it is done first (XP or TDD) or concurrently with the development of the code. Pairing is routine. Conversation is continuous. There is only one kind of code that results: tested, working, integrated code. Feedback is immediate and continuous. All team members know where they are every day and what they need to do that day to meet the goals of the iteration.
Changes to Test and Quality Assurance Practices
The testing and QA organizations are in for big changes as well.
|
Test and Quality Assurance |
Big, planned/test late |
Continuous/concurrent/test fast |
|
Contract with customer |
Partner with customer |
|
|
Big test plan sign off |
LRM testing decisions |
|
|
Testing at the end |
Test from the beginning |
|
|
QA is responsibility for test |
Everyone is responsible |
|
|
Testers write all the tests |
Everyone writes tests |
|
|
Testing squeezed |
Low features squeezed |
|
|
Big stand-alone test teams |
Integrated with dev |
|
|
Automate tests later |
Automate tests now |
The impact on the testing organization is substantial. Often, entire QA and test organizations are refactored (largely disbanded as a separate organization) and instead dispatched to become part of individual component or feature teams. Testing is no longer a lifecycle phase; it is a continuous activity. No longer do testers test large blocks of untested code; rather, they tests systems that include new code that has already been unit- and acceptance-tested. Development of testing automation is the rule rather than the exception. Testing skill levels increase as testers participate in design decisions and test automation development. Programmers' skills increase as they understand how to write code that is straightforward enough to be tested. QA personnel do real QA instead of managing legions of manual testers.
New Ways of Planning and Scheduling
Planning and scheduling change too.
|
Planning and Scheduling |
PERT/detailed/fix scope, estimate time and resource |
Two-level plan/fix date, estimate scope |
|
Detailed planning early |
Detailed planning JIT |
|
|
Measures on intermediate deliverables |
Measures based on code |
|
|
Protect the scope |
Protect the date |
|
|
Demonstrate at end |
Demonstrate always |
|
|
Weekly status meetings |
Daily stand-up meeting |
But contrary to rumor, planning does not disappear in agile; indeed, it is quite intense and it reappears at two levels: gross-level plans for releases and fine-grained plans for iterations. Planning doesn't happen just once, and up-front planning happens at every release and every iteration boundary. Planning is no longer lumpy and ad hoc—it is systematic and routine.
Planning is greatly simplified because the dates are always known in advance, and the teams, with the product owner driving, are responsible for determining priorities. Tracking is simpler too, because daily status meetings and frequent demonstrations illustrate progress. No longer is there a separation between plan and actual. Managers don't worry about interdependent events, such as who has a vacation this week—teams do.
The Biggest Change: Scope versus Schedule—Schedule Wins!
As we learned in DSDM, perhaps the biggest change of all is that, in the battle of date versus scope, the date always wins. That is, iteration length (or periodic release date at the release level) is determining scope instead of scope determining the length of a development cycle. In plan-driven methods, scope determined time, and two variables (scope and time) varied with every planning cycle and every significant change. Since agile methods fix the time and let that define scope, only one variable remains (the scope of what gets built). This frees the team to organize as necessary and to remain constantly focused on what can be accomplished by the date. And since the scope is always prioritized, team members can be assured that they will deliver the best possible solution in the time available, as the DSDM pyramid in Figure 7-2 illustrates.
)
Figure 7-2 Plan-driven (traditional) versus value-driven (agile) methods
If for some reason, the delivered result lacks sufficient functionality to be "above the bar" (which can only be determined by the users when they have a system to evaluate), have no fear because the next iteration is only a week away, and the next release will be available only a month or two thereafter.