No bugs journey episode 2: Its a matter of values

Posted by: Eric Gunnersons C# Compendium, on 22 Feb 2015 | View original | Bookmarked: 0 time(s)

Read episode 1 first.

Here we are at episode 2, and time for another question. Of the three, which one do you value the most?

  1. Shipping on schedule
  2. Shipping with a given set of features
  3. Shipping with high quality

Write down your answer.

Ha ha! It was a trick question. Pretty much everybody is going to say, it depends, because its a tradeoff between these three. Lets try an alternate expression:

  1. Build it fast
  2. Build a great product
  3. Build it right

All of these are obviously important. Hmm. Lets try a different tact

If you get in a situation where you need to choose between schedule, features, and quality, which one would you choose?

  1. Shipping on schedule with the right set of features but adequate quality
  2. Shipping late with the right set of features and high quality.
  3. Shipping on schedule and with high quality but with fewer features than we had hoped

Write down your answer.

Lets talk about option #1. First off, it doesnt exist. The reason it doesnt exist is that there is a minimum quality level at which you can survive and grow as a company. If you are trying to hold features and schedule constant, as you develop features you are forcing the quality level down it *has to* go down because something has to give if you get behind (short estimates, etc.). That means you start with a product that you just shipped, and then it degrades in quality as you do features, and then at some point you want to ship, so you realize you need quality, so you focus on getting back to *adequate*. Unfortunately, fixing bugs is the activity with the most schedule uncertainty, so there is no way you are shipping on time.

Its actually worse than this. Typically, youve reached a point where your quality is poor and you know that there is no way that you are going to get the features done and reach acceptable quality, so you cut features.

And you end up with a subset of features that ships late with barely adequate quality. Theres an old saying in software that goes, schedule/features/quality pick 2, but what few people realize is that its very easy to pick zero.

I hope Ive convinced you that the first approach doesnt work, and given that Im saying this series is about no bugs, you probably arent surprised. Lets examine the other options.

Ive see #2 work for teams; they had a feature target in their head, built their software to high quality standards, and then shipped when they were done. This was common in the olden days when box products were common, when the only way to get your product out there was produce a lot of CDs (or even diskettes) and ship them out to people. It worked, in the sense that companies that used the approach were successful.

It is, however, pretty disruptive on the business as a whole; its hard to run a business where you dont know:

  • If new revenue is going to show up 1 year or 3 years from now
  • When youll be spending money on sales and marketing
  • Whether the market has any interest in buying what you build

Not to mention making it tough on customers who dont know when theyll get that bug fix and enhancement they requested.

Which leaves option #3, which through an amazing coincidence, is the one that is the most aligned with agile philosophy. Heres one way to express it:

Given that:

  • It is important to the rest of the business and our customers that we be predictable in our shipping schedule
  • Bugs slow us down, make customers unhappy, and pose significant schedule risk
  • The accuracy at which we can make estimates of the time to develop features is poor
  • Work always expands (people leave the team or get sick, we need to spend time troubleshooting customer issues, engineering systems break), forcing us to flex somewhere

The only rational option that we have is to flex on features. If we are willing to accept that features dont show up as quickly as we would like (or had originally forecast), it is possible to ship on time with high quality.

I chose the phrase it is possible carefully; it is possible to build such a system but not get the desired result.

Flexing on features effectively

Time for another exercise. Studies have shown that you will get a much better review of a plan if you spend some focused time thinking about how it might go wrong.

Thinking about the world I just described, what could go wrong? What might keep us from shipping on time with high quality?

Write down your answers.

Heres my list:

  1. At the time we need to decide to cut features, we might have 10 features that are 80% done. If we move out all 10 of them to the next iteration, we have nothing to ship.
  2. We might have a hard time tracking where we are early enough to make decisions; most people have seen a case where all the features were on schedule until a week before shipping and suddenly 25% were behind by a week or more. If this happens, it may be too late to adapt.
  3. We might have teams that are dependent on each other; the only way to make my schedule is to cut work from team A, but that means that teams B & C cant finish their work as planned, and they will have to adjust, using time we dont have.
  4. This release was feature A and a few bugfixes, and feature A isnt on schedule. Well look silly if we just shipped bugfixes.

(At this point Im really hoping that you dont have something important on your list that Ive missed. If so, thats what comments are for)

How can we mitigate? Well, for the first one, we can focus on getting one feature done before we move on to the next one. That means that we would have 8 features 100% done instead of 10 features 80% done. This is one of the main drivers for the agile work together as a team approach.

This mitigation works for the second one as well. If we make our tracking is the feature fully complete and ready to ship, we can tell where we are (3/10 features current done and ready to ship (done done in agile terminology)) and we have a better chance of predicting where we are going. This is another driver for work together as a team. Note that for both the first and the second one, the more granular our features are, the easier it is to make work; it works great if the team has 5-10 items per iteration but poorly if it only has two. This is the driver for small self-contained stories and velocity measurement in agile.

I have a few thoughts on the third one. You can mitigate by using short cycles and having teams B and C wait until A is done with their work. You can try to break the work A does into parts so the part the other teams need can be delivered further.  Or you can go with a vertical team approach, which works great. 

For the fourth one, the real problem is that we put all of our eggs in one basket. Chopping feature A up will give us some granularity and the chance to get part way there. I also think that a shorter cycle will be our friend; if we are giving our customers updates every month, they will probably be fine with a message that says, this months update only contains bugfixes.

To summarize, if we have small stories (a few days or less) and we work on them sequentially (limiting how many we are working on at one time), our problems about tracking and having something good enough to ship become much more tractable. We can predict early what features are not going to make it, and simply shift them to the next cycle (iteration). That is our pressure-relief valve, the way that we can make sure we have enough time to get features completed on the shipping schedule with great quality.

The world isnt quite as simple as Ive described it here, but Ive also omitted a number of advanced topics that help out with that, so I think its a pretty fair overview.

Before I go on, Id like to address one comment Ive heard in relation to this approach.

If we flex on features, then Im not going to be able to forecast where we will be in 6 months

The reality is that nobody has ever been able to do that, you were just pretending. And when you tried, you were often spending time on things that werent the most important ones because of new priorities.

Instead, how about always working on whatever is the highest priority for the business, and having the ability to adjust that on a periodic basis? How does that sound?

The culture of commitment

Time for another question:

What are the biggest barriers to making this work in your organization?

Write down your answers.

I have a list, but Im only going to talk about one, because it is so much more important than the rest. Its about a culture of commitment.

Does your organization ask development teams to *commit* to being done in the time that they estimated? Does it push back when developer estimates are too large? Do developers get emails or visits from managers telling them they need to be done on time?

If so, you are encouraging them to write crappy code. You have trained them that being on the not done list is something to be avoided, and they will do their best not to avoid it. They can either work harder/longer which has limited effectiveness and is crappy for the company in other ways or they can cut corners. Thats all they can do.

Pressure here can be pretty subtle. If my team tracks days done and I have to update my estimate to account for the fact that things were harder than I thought, that puts pressure on me to instead cut corners.

This is one reason agile uses story points for estimation; it decouples the estimation process from the work process.

Changing the culture

Here are my suggestions:

  1. Get rid of any mention the words committed or scheduled WRT work. The team is *planning* what work they will attempt in the next iteration.
  2. Change the are you going to be done? interaction to ask, is there anything you would like to move out to the next iteration? Expect that initially, people arent going to want to take you up on this, and you may have to have some personal interactions to convince somebody that its really okay to do this.
  3. When you have somebody decide to move something out, make sure that you take public note of it.

    To adjust the amount of work to the capacity of the team and maintain shippable quality, the paypal feature has been moved out to the next iteration.
  4. When teams/individuals check in unfinished features (buggy/not complete) instead of letting those features make it into the common build, force them to remove them or disable them. Make this part of the team-wide status report for the iteration (the email invoice feature did not meet quality standards and has been disabled for this iteration).
  5. I highly recommend switching to a team-ownership approach. Teams are much more likely to change how they work and improve over time than individuals.

You will need to be patient; people are used to working in the old ways.

This cultural change is the most important thing you can do to reduce the number of bugs that you have.

Category: Agile | Other Posts: View all posts by this blogger | Report as irrelevant | View bloggers stats | Views: 532 | Hits: 13

Similar Posts

  • Driving a "no bugs" team culture - level 200 more
  • DNN News Feeds 03.03.08 Beta more

News Categories

.NET | Agile | Ajax | Architecture | ASP.NET | BizTalk | C# | Certification | Data | DataGrid | DataSet | Debugger | DotNetNuke | Events | GridView | IIS | Indigo | JavaScript | Mobile | Mono | Patterns and Practices | Performance | Podcast | Refactor | Regex | Security | Sharepoint | Silverlight | Smart Client Applications | Software | SQL | VB.NET | Visual Studio | W3 | WCF | WinFx | WPF | WSE | XAML | XLinq | XML | XSD