Lean Principles #2 - Build Quality In
by
Join the DZone community and get the full member experience.
Join For FreeIn my previous post about lean software development, I explained Lean Principles #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...
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.
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 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.
Build (game engine)
Lean (proof assistant)
agile
Software development
unit test
scrum
Extreme programming
Published at DZone with permission of Kelly Waters, DZone MVB. See the original article here.
Opinions expressed by DZone contributors are their own.
Trending
-
Essential Architecture Framework: In the World of Overengineering, Being Essential Is the Answer
-
Building a Flask Web Application With Docker: A Step-by-Step Guide
-
Using Render Log Streams to Log to Papertrail
-
Cucumber Selenium Tutorial: A Comprehensive Guide With Examples and Best Practices
Comments