All About Agile | Agile Development Made Easy


Lean Principle #2 – Build Quality In

by Kelly Waters, 6 September 2010 | Lean Development

In my previous post about lean software development, I explained Lean Principle #1 – Eliminate Waste.

Quality issues result in all sorts of waste. That’s a fact. There’s waste in testing the code more than once. Waste in logging defects. And waste in fixing them. As a result, lean principles specifically seek to address this point.

The second principle of 7 Key Principles of Lean Software Development is Build Quality In

In agile methodologies such as Scrum and Extreme Programming (XP) – which personally I think are great examples of lean thinking in action – there are various practices to help you do this…

Firstly, there are quality assurance processes designed to avoid quality issues in the first place. Two examples of this are Pair Programming and Test Driven Development.

Pair Programming seeks to avoid quality issues by applying the minds of two developers to each task. The task benefits from the collective, combined experience of two developers instead of one, often resulting in better productivity as they see solutions that on their own they might not have done. Another positive outcome of Pair Programming is improved quality, since one person can be thinking slightly ahead of the other, catching issues before they occur.

Test Driven Development avoids quality issues by writing tests before writing code. In the simplest form, think about a Test Analyst/QA person writing down the test conditions for each feature just before it’s developed. If the developer knows how it’s going to be tested, they are much more likely to write code that addresses all the scenarios. In its more sophisticated form, Extreme Programming advocates stubbing out the code and writing automated unit tests for each of the test conditions before actually writing the code. The developer then writes the code to pass the tests.

Both of these practices come from Extreme Programming and both seek to prevent quality issues from occurring.

Constant Feedback – Inspect and Adapt

Both Scrum and XP build quality into the process in another way, which is inherent in many of the 10 key principles of agile software development. By doing development in small incremental steps, through close collaboration, and by developing in small iterations, these agile methods provide the opportunity for constant 2-way feedback between the Product Owner and the team. This feedback can be immensely valuable, inspecting and adapting the product every single day in order to ensure the right level of quality – and most importantly of all – the right product.

Of course, the practices of XP and Scrum are completely complementary so it’s possible to use both.

Minimise Time Between Stages

Another important technique for building quality into the development process is to minimise the time between development, testing and bug fixing. Rather than logging bugs, deal with them immediately. Logging bugs in a lot of cases is in fact waste. If the tester can test the code as soon as it’s developed, and the developer can fix any bugs as soon as they are found, what is the value in logging them? On the other hand, a long gap between producing the code, testing it, and before fixing the bugs results in a loss of continuity. A loss in continuity that causes delays from task switching, knowledge gaps, and a lack of focus.

Frequent Integration

Most agile methods also advocate doing regular and frequent builds. At least daily, if not hourly. Extreme Programming advocates continuous integration, with code integrated into the overall system, built and automatically unit tested as soon as it is checked in. Minimising the gap between builds also reduces another form of waste, that is integration. On large waterfall projects, the integration and regression testing phases of the project can be very lengthy. Regular builds and frequent integration avoid that problem.

Automation

Agile development methods also encourage automated regression testing. Of course this is a practice that is not unique to agile development, but is another way to reduce the effort associated with finding quality issues before they occur in a live environment. This is admittedly the last stage, but quality assurance is built into every step in the process.

This is how Scrum and XP have translated lean principles into practice in software development and how they have built quality into the process. In your own situation, you may also see other opportunities to build quality in.

Managing Trade-offs

One word of warning though. Quality is only one dimension of the project – the others being time, cost and scope. Sometimes there will be commercial reasons to trade-off quality against other factors, or to watch out for situations where attention to quality costs more than the issues you are trying to avoid.

One example of where agile methods acknowledge this in principle is the acceptance of rework (‘refactoring’) as a result of not having a detailed spec and complete design up-front. In traditional methodologies, these practices were designed to improve quality early in the project lifecycle. However, over many years, many people have found them to be counter-productive and hence agile methods were born.

Similarly, if you are working on fairly low-complexity visual components that have a low impact, it may be worth spending less time on quality assurance as the risk of quality issues occurring, and the impact if they do, is much lower. Naturally this is a judgement decision and unfortunately it can be very hard to know where to draw the line.

In summary…

Quality is obviously extremely important, or you inevitably create all sorts of waste further down the line. Build quality in. Build it in as early as possible in the process to avoid quality issues materialising. And build it in throughout the entire development process, not just at the end.

Kelly.

7 Key Principles of Lean Software Development:

1. Eliminate Waste
2. Build Quality In
3. Create Knowledge
4. Defer Commitment
5. Deliver Fast
6. Respect People
7. Optimise The Whole

 

Home



7 Responses to “Lean Principle #2 – Build Quality In”

  1. Peter Saddington says:

    Great article. Wondering if you could elaborate a little more on great reasons for paired programming. Some clients are interested, but have a hard time making the jump! What are the biggest factors?

  2. kev says:

    Great article, I wholeheartedly agree, In my opinion quality is the key to increasing your velocity sustainably, most teams that I observe that struggle to do scrum seem to be affected by the lack of being able to apply the XP disciplines that focus on quality, pairing, tdd, done done..you have to make sure quality is happening right from the start and that it is continually improved, letting quality go by dropping the disciplines leads to legacy problems.

  3. kev says:

    re: reasons for paired programming – the primary reason/goal I believe is to allow you to deliver value early and often to your customer. People(developers, testers etc) who accept and adopt pairing will undoubtedly produce higher quality work which in turn will lead to an increase in capability/velocity. I actually pair not only on programming but on emails, on support documents, etc etc as in my experience quality is increased.
    Another reason is doing XP/Scrum (not scrumbut) is hard and two heads are better than one…especially when you first start trying TDD..try it and measure your velocity over a couple of sprints and make your own mind up.

  4. miniclip says:

    really awesome article i didint think that way but how about xp addiction..

  5. seo melbourne says:

    Very nice article but i like mostly Agile development methods also encourage automated regression testing.but there are present time variouse technology.

  6. Casey says:

    I love it. Develop fast, but you have to build quality products.

  7. Ryan Platte says:

    Refactoring as a regular part of software development keeps design quality high with near-zero inventory of design problems. As features are added, subtle design defects begin to evidence themselves. Developers practiced in continuous refactoring notice these “code smells” and address them inexpensively at the earliest possible moment. Your reference to refactoring seems to assume it’s long after the fact, which would indeed impede flow. XP advocated it as a continuous activity, the inexpensive JIT “middle way” between keeping an inventory of design up front (design before development) and winding up with an inventory of technical debt (design after development).

Leave a Reply

What is 1 + 7 ?
Please leave these two fields as-is:
Please do this simple sum so I know you are human:)