Agile Software Development is Driven by Nested Feedback Loops

A linchpin of software engineering practice is an observation made years ago by Barry Boehm that the cost of changes increases exponentially the farther along you are in the development cycle. This is why the traditional “waterfall” development process seeks to make all design decisions and changes as early in the software development process as possible. Much time is spent up front in requirements gathering and design so that changes will not be required later on. However, the problem is that in an unpredictable world no amount of analysis, regardless of time spent, can foresee all the system requirements and changes that will eventually be needed.

Agile development takes a radically different approach to solving this problem. In an agile development process the creation of a big application system is divided into the iterative creation of many smaller subsystems where each subsystem provides value in its own right so it can be put into production and used by business people as soon as it is delivered. This creates shorter development cycles and each cycle delivers a subsystem with fewer functional requirements needing less time to define and design. The strength of the agile approach is its embrace of a development process that is short, circular and iterative instead of the traditional lengthy, linear and sequential process. Therefore effective tools to support agile development must support specific practices and feedback loops that drive this iterative software development process.

[ I do lively presentations on this and related topics - mhugos@yahoo.com ]

In a conversation with the managing director of ThoughtWorks Studios, Cyndi Mitchell, she described their newly released suite of agile development tools - Twist, Cruise, and Mingle – and explained how they facilitate agile development practices. The three packages are based upon an agile process model composed of nested feedback loops articulated in a whitepaper authored by Glenn Vanderburg titled “A Simple Model of Agile Software Processes – or – Extreme Programming Annealed”. In his whitepaper Vanderburg lays out thirteen agile practices that group together into three feedback loops to produce effective results.

Feedback Loops Reinforce Agile Development Practices

He starts by noting that a handful of these practices are smaller-scale practices which in turn drive the larger-scale practices. As Vanderburg puts it, “Smaller-scale practices strengthen larger-scale practices by providing high-quality input.” Those lower level practices are: pair programming; coding standards; unit and function testing; refactoring; simple design; and the 40-hour week. These small-scale practices combine to create the innermost of the three nested feedback loops driving effective agile development. This innermost feedback loop drives the creation of well engineered software which is critical for success in any agile project.

Vanderburg goes on to say that “larger-scale practices guide smaller-scale activities, and also defend against the mistakes that might slip through.” The higher level practices are: system metaphor; continuous integration; on-site customer; collective ownership; acceptance testing; planning game; and short releases. These larger-scale practices combine to create a second level feedback loop that defines and constantly adjusts the direction that an agile project will follow in order to track as closely as possible with the needs of the business users that the application system is being developed for.

The third and highest level of the agile model of nested feedback loops is composed of project management activities used to monitor and manage agile projects. This third level is what gives project visibility to all the participants and stakeholders involved in agile development so that everybody knows what is happening on the project, and

Continue Reading