Home > Articles > Software Development & Management > Agile

Scaling Software Agility: Best Practices for Large Enterprises

  • Print
  • + Share This
When it comes to software development and software project management in general, agile changes everything. 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. The authors of Scaling Software Agility examine each of these new paradigms to see what additional clues we can find as to what is so different about agile.
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

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

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.

  • + Share This
  • 🔖 Save To Your Account