David –
Over a decade ago, when Jeff Sutherland
invented Scrum, he was faced with a situation in which his product development
process bottleneck was the capacity of skilled developers. He designed
Scrum specifically to exploit the capacity of the bottleneck, to subordinate
everything else to ensure maximum throughput through the software development
process, and to elevate the capacity of the bottleneck by removing impediments.
As we report in chapter 5 of Implementing
Lean Software Development, at PatientKeeper, Jeff requires that all
items eligible for inclusion on a sprint backlog be fully defined and ready for
implementation with all UI design, data format and other issues fully complete.
A nice summary of the TOC focusing steps
is at http://www.goldratt.com/lucas.htm
. You will notice there is also a fifth step, “If in the
previous steps a constraint has been broken, go back to step 1, but do not
allow INERTIA to cause a system's constraint.” Modern agile software development practices may very well take us
to the stage where step five directs us to look at whether the bottleneck ahs
moved to an earlier or later stage of the concept to cash value stream.
In the majority of organizations we critique value stream maps for we see that
the biggest delays and wastes are in the approval / requirements cycles or in
the testing / deployment cycles. If the bottleneck really is software
implementation, then, indeed the quality and timely availability of the inputs is
critical to maximizing throughput and downstream QA and deployment processes
that waste or delay availability of the output of the bottleneck will
negatively impact the cash available from the throughput of the process.
Keep in mind, however that TOC, like the
Toyota PRODUCTION system are applications of the scientific method to repetitive
PRODUCTION environments. While there may be analogies useful to product
development work, the two areas are NOT the same. When you apply the
scientific method to DESIGNING products rather than to manufacturing them,
I say part because I concur with Phil Armours
notion that software is not like other products as it is essentially executable
knowledge. The creation or discovery of the knowledge to be expressed by
the software is the primary determinant of the value generated by the whole
value stream. Lean focuses on maximizing customer value at the least
possible cost to maximize sustainable profit to the producing organization.
The test of the validity of the knowledge
or theory represented by a piece of software and by the product or business
process in which it is embedded is the success in the market or the impact on
the cash flow consumed or generated by the business process. The
effectiveness of the development process is the ratio of the cost to the
realized benefit. Each release is an experiment which provides more data
that can be used to systematically and deliberately extend the knowledge of the
team and the organization.
- Tom
From:
Sent: Wednesday, October 04, 2006
7:16 PM
To: leandevelopment
Subject: [leandevelopment] how do
I find bottlenecks?
Recently, there's been a Google-related discussion
going on in the XP
mailing list; that reminded me of something Mary said in one of her
talks at Agile 2006. Namely: optimizing locally is not only not
useful, it can be actively harmful. In that context, she suggested
that Google's policy of letting people spend 20% of their time
pursuing pet projects actually helps their productivity.
I'm a manager of a software team; I'm trying to figure out what, if
any, relevance this has to us. The flip side to Mary's claim is that
I doubt that the our extended group (us plus all the other teams
working on the same product) would have a productivity increase if
they let every single person spend 20% of their time working on pet
projects. Maybe it would - people would be more energized, and it
would increase the number of new product ideas floating through the
air - but, strictly from a queuing theory point of view, I'm a little
dubious. Instead (I'm taking this from Theory of Constraints)
are likely to be bottlenecks in our system that are determining the
extended group's productivity level; if my team is a bottleneck, then
we shouldn't lightly give up on-task time.
So: what do I do to determine if we're a bottleneck?
(Maybe this is explained in the new book; it's next in my to-read
queue.)
Thinking about this, one interesting aspect of XP is that it broadens
potential bottlenecks, eliminating many traditional ones: bottlenecks
happen when there's a scarce resource in high demand, but XP's
knowledge sharing means that individual knowledge is much less likely
to be a scarce resource. So either the team as a whole isn't a
bottleneck, or everybody on the team is part of a bottleneck! And
then a further advantage is that, because of the relatively
transparency of the value stream map in an XP context, it's probably
easier to figure out where the bottlenecks are.
Unfortunately, this transparency is an area where my team (and
surrounding groups) isn't doing so well: our Customer interaction
isn't as good as I'd like, and we don't yet have frequent real
(non-internal) releases. Perhaps as a result, my vision is a bit
muddled: it seems very useful to figure out where the bottlenecks are
in the process, but I'm having a hard time figuring that out.
I guess one traditional answer is "look where work is piling up". On
the one hand, there's no shortage of requests for us to do stuff, so
you could say that work is piling up before us. But if there are
further bottlenecks downstream from us, then that's kind of
irrelevant; I'm having a hard time seeing whether or not that is the
case.
Confused,
David Carlton
carlton@bactrian.