Agile
Getting Started with Lean Software Development
By Curt Hibbs , Steve Jewett and Mike Sullivan
16,802 Downloads · Refcard 93 of 151 (see them all)
Download
FREE PDF
The Essential Lean Development Cheat Sheet
People who downloaded this DZone Refcard also liked:
Getting Started with Lean Software Development
By Curt Hibbs, Steve Jewett, and Mike Sullivan
About Lean Software Development
Lean Software Development is an outgrowth of the larger Lean movement that includes areas such as manufacturing, supply chain management, product development, and back-office operations. Its goal is the same: deliver value to the customer more quickly by eliminating waste and improving quality. Though software development differs from the manufacturing context in which Lean was born, it draws on many of the same principles.
Seven Principles of Lean Software Development
Lean Software Development embodies seven principles, originally described in the book Implementing Lean Software Development: From Concept to Cash1, by Mary and Tom Poppendieck. Each of these seven principles contributes to the “leaning out” of a software development process.
Eliminate Waste
Waste is anything that does not contribute value to the final product, including inefficient processes, unnecessary documentation, and features that won't be used. Eliminating waste is the guiding principle in Lean Software Development.
Build Quality In
Building quality into a product means preventing defects, rather than using post-implementation integration and testing to detect them after the fact.
Create Knowledge
The knowledge necessary to develop a project, including requirements, architecture, and technologies, is seldom known or understood completely at project startup. Creating knowledge and recording it over the course of the project ensures the final product is in line with customer expectations.
Defer Commitment
Making irreversible decisions at the last reasonable moment allows time for the creation of more knowledge, which results in better decisions. Deferring commitment is positive procrastination.
Deliver Fast
Delivering fast puts the product in front of the customer quickly so they can provide feedback. Fast delivery is accomplished using short iterations, which produce software in small increments by focusing on a limited number of the highest priority requirements.
Respect People
Respecting people means giving the development team's most important resource, its members, freedom to find the best way to accomplish a task, recognizing their efforts, and standing by them when those efforts are unsuccessful.
Optimize the Whole
Optimizing the whole development process generates better results than optimizing local processes in isolation, which is usually done the expense of other local processes.
Lean vs. Agile
Comparing Lean and Agile software development reveals they share many characteristics, including the quick delivery of value to the customer, but they differ in two significant ways: scope and focus. The narrow scope of Agile addresses the development of software and focuses on adaptability to deliver quickly. Lean looks at the bigger picture, the context in which development occurs, and delivers value quickly by focusing on the elimination of waste. As it turns out, they are complementary, and real world processes often draw from both.
GETTING STARTED
Newcomers to Lean Software Development sometimes have trouble implementing a Lean process. The Lean principles don't describe an “out-of-the-box” solution, so one approach is to start with an Agile methodology. However, a number of methodologies exist, and choosing the right one can be difficult.
One Step at a Time
All is not lost. What follows is a set of inter-related practices organized in a step-by-step fashion to allow projects to implement Lean Software Development one step at a time.
The following practices can stand-alone, and implementing any of them will have a positive effect on productivity. Lean Software Development relies on prioritization, so the practices are prioritized to generate the highest return on investment. While implementing any one practice will help lean out a process, doing them in order will return the most “bang for the buck.”
The list of six practices is preceded by two prerequisites, or “zero practices”, every software project should be doing, whether Lean, Agile or something more traditional. If your project doesn't do these things, this is the best place to start.
ZERO PRACTICES
Source Code Management and Scripted Builds are prerequisites for other practices outlined here. They are referred to as zero practices because they need to be in place before taking the first step toward Lean Software Development.
Source Code Management
Source code management (SCM) is a shared repository for all artifacts needed to build the project from scratch, including source code, build scripts, and tests. SCM maintains the latest source code so developers and build systems have up-to-date code.

Figure 1: Centralized Repository
Source code management is the first practice described because it is the foundation for a practical development environment, and it should be implemented before going any further.
- Select an appropriate SCM system. Subversion is a popular open source option. Git is a newer distributed SCM system useful for large projects and distributed teams.
- Put everything needed to build the product from scratch into the SCM system so critical knowledge isn't held only by specific individuals.
Scripted Builds
Scripted builds automate a build process by executing a set of commands (a script) that creates the final product from the source code stored in SCM. Scripts may be simple command files, make files, or complex builds within a tool such as Maven or Ant.
Scripted builds eliminate the potential errors of manual builds by executing the same way each time. They complete the basic development cycle of making changes, updating the SCM repository, and rebuilding to verify there are no errors. Select an appropriate build tool for your project. Integrated development environments like Visual Studio or Eclipse have build managers or integrate with 3rd party build managers. Create a script that builds the product from scratch, starting with source code from SCM.

Figure 2: Zero Practices
Lean Principles
- Create Knowledge: SCM consolidates project knowledge in a single place.
- Eliminate Waste: Manual work is eliminated by automating builds.
- Build Quality In: Automating builds eliminates a source of errors.
DAILY STANDUP
Daily standup meetings allow each team member to provide status and point out problems or issues. The meetings are short and not intended to resolve problems, rather they serve to make all team members aware of the state of the development effort.
Borrowing from the Scrum methodology, standups are conducted by having each member of the team answer three questions:
What did I do yesterday?
What will I do today?
What problems do I have?
Effective daily standups result from adhering to several simple rules:
- Require all team members to attend. Anyone who cannot attend must submit their status via a proxy (another team member, email, etc.).
- Keep the meeting short, typically less than 15 minutes. Time-boxing the meeting keeps the focus on the three questions.
- Hold the meeting in the same place at the same time, everytime.
- Avoid long discussions. Issues needing further discussion are addressed outside the meeting so only the required team members are impacted.

The Japanese word tsune roughly translated means “daily habits”. It refers to things such as taking a shower that are so ingrained into a daily routine that skipping them leaves one feeling that something is missing2. Make the daily standup part of the team's tsune so that a day without a standup feels incomplete.
Lean Principles
- Respect People: Standups foster a team-oriented attitude; team members know what other members are doing and can get or give help as needed to move the project forward.
- Create Knowledge: Sharing information regularly creates group knowledge from individual knowledge.
AUTOMATED TESTING
Automated testing is the execution of tests using a single command. A test framework injects pre-defined inputs, validates outputs against expected results, and reports the pass/fail status of the tests without the intervention of a human tester. Automated testing ensures tests are run the same way every time and are not subject to the errors and variations introduced by testers.
While automated testing can be applied to all types of testing from unit and integration tests to user acceptance and performance/load tests, unit and integration testing is the best place to start.
- Identify an appropriate test framework for the language in use. JUnit (for Java) and NUnit (for Microsoft .NET languages) are common frameworks.
- Require all new code modules to have a unit test suite before being included in the build.
- Retrofit unit test suites to existing legacy code only when the code is modified (writing unit tests for code which is already written and functional usually is not cost effective).
- Develop integration tests by combining code modules and testing the modules together.
- Use stubs and mock objects to stand in for code which has not yet been developed.

Developing automated tests alongside production code may be a paradigm shift for many developers. One way to help developers adjust is to define testing standards calling out both what to test and how to do it. Adherence to the standards will create a culture where automated tests are the norm and will pay off in higher quality software.

Figure 3: Automated Testing
Test Execution
Each developer runs unit tests on individual code modules prior to adding them to the source code repository, ensuring all code within the repository is functional. An automated build runs both unit and integration tests to ensure changes do not introduce errors. The next practice, continuous integration, will make use of the build scripts and test suites to test the entire system automatically each time changes are checked into the repository.
Lean Principles
- Build Quality In: Automated tests executed regularly and in a consistent manner prevent defects.
- Eliminate Waste: Defects detected early are easier to correct and don't propagate.
- Create Knowledge: Tests are an effective way to document how the code functions.
CONTINUOUS INTEGRATION
Continuous integration (CI) is the frequent integration of small changes during implementation. It seeks to reduce, or even eliminate, the long, drawn-out integration phase traditionally following implementation. Integrating small changes doesn't just spread the effort out over the whole cycle, it reduces the amount of integration time because small changes are easier to integrate and aid debugging by isolating defects to small areas of code.
CI systems use a source code repository, scripted builds, and automated tests to retrieve source code, build software, execute tests, and report results each time a change is made.
- Use a dedicated build machine to host the CI system. Refer to the Continuous Integration: Servers and Tools Refcard (#87) for details on setting up a CI system.
- Check code changes into the repository a minimum of once a day (per developer); once an hour or more is even better.
- Immediately address any failures in the build. Fixing the build takes precedence over further implementation.

While the use of a dedicated computer, or build machine, to host the CI system may seem obvious for a large project, it provides advantages on small projects as well:
- Dedicated machines don't compete for resources, so builds are quicker and the results get back to the developers sooner.
- Dedicated machines have a stable, well-known configuration. Builds don't fail because a new version of a library was loaded or the runtime environment was changed.
A CI system can also check coding standards, analyze code coverage, create documentation, create deployment packages, and deploy the packages. Anything that can be automated can be included in a CI system.

Lean Principles
- Build Quality In: Continuous build and test ensures code is always functional.
- Eliminate Waste: Frequent, small integrations are more efficient than an extended integration phase.
LESS CODE
Less code is not about writing less software, it's about implementing required functionality with a minimum amount of code. Large code bases mean more implementation, integration, and debugging time, as well as higher long term maintenance costs. All of these are non-value added work (i.e., waste) when the code base contains unneeded or inefficient code.
All aspects of software development can affect the code base size. Requirements analysis resulting in features with little likelihood of use and overly generic, all-encompassing designs generate extra code. Scope creep and unnecessary features increase the amount of code. Even testing can generate unnecessary code if the code under test is itself unnecessary.
Minimizing code base size requires two actions: identify and eliminate unnecessary code, and write efficient code. Minimizing code base size is not unlike a fitness program: diet to eliminate the excess, and exercise to shape up what's left.
Eliminate Unnecessary Code
Eliminating unnecessary code means identifying the code, or the forces that create it, and removing it.
- Adopt a fierce, minimalist approach. Every bit of code added to the code base must be justifiable. Remove excessive requirements, simplify designs, and eliminate scope creep.
- Reuse code and employ libraries to reduce the amount of new code that must be written.
- Prioritize requirements so developers implement important features first. As customers adjust the priorities over the course of development, they drive development of only useful features; unused features never get implemented.
- Develop only for the current iteration. Working too far ahead risks doing work that will be thrown away as requirements and design change over time.
Improve Code Efficiency
Code efficiency doesn't refer to creating small, compact code by using arcane tricks and shortcuts. In fact, the opposite is true; efficient code uses coding standards and best practices.
- Use coding standards to write readable and understandable code. Use best practices and proven techniques that are well understood by other developers.
- Develop flexible, extensible code. Design and implement code with design patterns, refactoring, and emergent design.

The “big design up front”, or BDUF, approach to design can lead to overdesign and unused code. The opposite approach, sometimes referred to as “you ain't gonna need it” or YAGNI, creates only what is needed at the moment, but it can lead to brittle designs and inefficient code. A compromise that creates only what currently is necessary, but tempers that with some thought for the future, is a better approach. Scott Bain's book Emergent Design2 describes such an approach.
Lean Principles
- Eliminate Waste: Frequent, small integrations are more efficient than an extended integration phase.
- Build Quality In: Automated tests executed regularly and in a consistent manner prevent defects.
SHORT ITERATIONS
Iterations are complete development cycles resulting in the release of functional software. Traditional development methodologies often have iterations of six months to a year, but Lean Software Development uses much shorter iterations, typically 2 to 4 weeks. Short iterations generate customer feedback, and more feedback means more chances to adjust the course of development.
Feedback and Course Corrections
Feedback from the customer is the best way to discover what's valuable to them. Each delivery of new functionality creates a new opportunity for feedback, which in turn drives course corrections due to clarification of the customer's intent or actual changes to the requirements. Short iterations produce more feedback opportunities and allow more course corrections, so developers can hone in on what the customer wants.

Figure 5: Course Corrections
Using Short Iterations
Several techniques aid in the implementation of a process using short iterations:
- Work requirements in priority order. High priority requirements typically are well-defined, easiest to implement, and provide the most functionality in a short period of time.
- Define a non-negotiable end date for the iteration; sacrifice functionality to keep the team on schedule. End dates focus the team on delivering the required functionality. Even if some features are not completed, delivering those that are ensures customers get new functionality on a regular basis.
- Mark the end of the iteration with a demo and an official handoff to the customer. Demos foster pride in the product by allowing the team to show off its work.
- Deliver the product to the customer, whether it's a ready-for-deployment application or an interim release. Getting the product in the customer's hands for in-depth evaluation is the best way to generate feedback.

Teams struggling to complete iterations successfully are often tempted to lengthen their iterations; however, longer iterations tend to hide problems. Instead, struggling teams should reduce the iteration length, which reduces the scope, focuses the team on a smaller goal, and brings impediments to the surface more quickly so they can be resolved.
Lean Principles
- Eliminate Waste: Frequent, small integrations are more efficient than an extended integration phase.
- Deliver Fast: New, functional software is delivered to the customer in closely-spaced intervals.
CUSTOMER PARTICIPATION
Customer participation in traditional projects typically is limited to requirements specification at the beginning of the project and acceptance testing at the end. Collaboration between customers and developers in the intervening time is limited, typically consisting of status reports and the occasional design review.
Lean Software Development approaches customer participation as an on-going activity spanning the entire development effort. Customers write requirements and developers produce functional software from those requirements. Customers provide feedback on the software and developers act on that feedback, ensuring developers are producing what the customer really wants.
Involve the Customer
Key to establishing effective customer collaboration is involving the customer in the entire development process, not just at the beginning and end. Engaging the customer, reporting status, and providing a feedback path all help keep the customer involved.
- Engage the customer by having them write and prioritize the requirements. Customers get a sense of ownership, and they can direct the course of development.
- Have the customers write the acceptance tests (or at least specify their content), and, if possible, run the tests as well. Involvement in testing the product allows customers to specify exactly what it means to satisfy a requirement.
- Provide useful, easily-accessible status. For example, a list of the requirements in work and the status of each. Include status on problems affecting development to avoid surprises.
- Provide access to the product so the customer can see for themselves how it works, and provide a simple, direct feedback path so customers can input feedback easily.
Collaborate
Collaborating directly with the customer is necessary for developers to refine the requirements and understand exactly what the customer wants.
- Designate a customer representative. The representative writes and/or collects requirements and prioritizes them. The representative clarifies requirements for developers.
- Schedule face-to-face time with the customer. At the very least, include a demo at the end of each iteration.

Actual customers make the best customer representatives, but when customer representatives are not available a customer proxy can fill the role. A customer proxy should be from the development team's organization and must have a good understanding of the customer's needs and business environment.
Lean Principles
- Create Knowledge: Through collaboration, requirements are discovered and refined over time.
- Defer Commitment: Involving customers throughout the process eliminates the need to make decisions up front.
SUMMARY
Most discussions of Lean Software Development don't define specific practices for implementing the process, and the large number of Agile methodologies to choose from can leave newcomers confused and uncertain where to start. The specific practices outlined here provide a step-by-step approach to implementing a Lean Software Development process. Adopt one, several, or all the practices and take your first step into the world of Lean Software Development.
References
1 Implementing Lean Software Development: From Concept to Cash, Poppendieck/Poppendieck, Addison-Wesley Professional, 2006
2 Moving Toward Stillness, Lowry, Tuttle Publishing, 2000.
3 Emergent Design: The Evolutionary Nature of Professional Software Development, Bain, Addison-Wesley Professional, 2008
Some of the concepts and material in this Refcard were adapted from The Art of Lean Software Development, Hibbs/ Jewett/Sullivan, O'Reilly Media, 2009.
About The Authors

Curt Hibbs
Curt Hibbs co-leads the Boeing team responsible for the adoption of Lean and Agile software engineering practices across Boeing's Defense, Space & Security business unit. He has been a software engineer for 30+ years, and during that time he has done just about everything related to developing software products, from working for WordStar, Hewlett Packard, the C.I.A, and more, to being the CTO of several startups. He has worked for Boeing since 2003.

Steve Jewett
Steve Jewett is a software developer with the Boeing Company, where he is involved in the development of cognitive decision support systems. Over a 25 year career he has developed software for automated test equipment, weapon/aircraft integration, embedded systems and desktop and web applications. He currently leads an agile software development team and works to promote Lean-Agile software development at Boeing.

Mike Sullivan
Mike Sullivan has over 6 years of experience teaching at the university level, and has spent the last 5+ years working with software teams in small companies and large corporations to drive valuable solutions and improve team dynamics. He is currently working in a small research team within a large corporation, implementing Lean techniques to improve the software his team delivers.
Recommended Book
This succinct book explains how you can apply the practices of Lean software development to dramatically increase productivity and quality. The Art of Lean Software Development is ideal for busy people who want to improve the development process but can't afford the disruption of a sudden and complete transformation. The Lean approach has been yielding dramatic results for decades, and with this book, you can make incremental changes that will produce immediate benefits.
BUY NOW

Curt Hibbs co-leads the Boeing team responsible for the adoption of Lean and Agile software engineering practices across Boeing’s Defense, Space & Security business unit.
Steve Jewett is a software developer with the Boeing Company, where he is involved in the development of cognitive decision support systems.
your friends & followers...
DZone greatly appreciates your support.
Your download should begin immediately.
If it doesn't, click here.
Agile Adoption
Reducing Cost
By Gemba Systems
17,907 Downloads · Refcard 54 of 151 (see them all)
Download
FREE PDF
The Essential Agile Adoption Cheat Sheet
People who downloaded this DZone Refcard also liked:
Agile Adoption: Reducing Cost
By Gemba Systems
About this agile adoption refcard
Faster, better, cheaper. That’s what we must do to survive. The Time to Market Refcard (a companion in this series) addresses faster, the Quality Refcard addresses better, and this Refcard addresses cheaper. This is about building the system for less.
Some of the costs of software development are associated with man hours needed to build the system, others with cost of maintenance over time, and yet others include hardware as well as software platform costs. Practices that educe any or all of these costs without sacrificing quality reduce the overall cost of the system.
Then there is the Pareto principle – a.k.a. the 80/20 rule. This rule suggests that roughly 20% of the software system is used 80% of the time. This is also backed up by research that is even more dramatic [figure with usage]. Practices that help the team build only what is needed in a prioritized manner reduce the cost and still deliver the most important business value to the customer (the part she uses).
Figure 1 Practices that help reduce the cost of building software.

You will be able to use this Refcard to get 50,000 ft view of what will be involved to reduce the cost of developing your systems.
Four Strategies to reduce cost
Software development is complex and often very complicated. It is HARD. This is not some new revelation, in fact Fred Brooks in the well known paper, “No Silver Bullet.”, states:
The essence of a software entity is a construct of interlocking concepts ...
I believe the hard part of building software to be the specification, design, and testing of this conceptual construct, not the labor of representing it and testing the fidelity of the representation.
There are four major strategies that can help you reduce the cost of building and maintaining your software
Maintain the Theory of the Code
One way to look at software development is ‘theory building’. That is, programs are theories – models of the world mapped onto software – in the head of the individuals of the development team. Great teams have a shared understanding of how the software system represents the world. Therefore they know where to modify the code when a requirement change occurs, they know exactly where to go hunting for a bug that has been found, and they communicate well with each other about the world and the software.
Conversely, a team that does not have a shared ‘theory’ make communication mistakes all the time. The customer may say something that the business analyst misunderstands because she has a different world view. She may, in turn, have a different understanding than the developers, so the software ends up addressing a different problem or, after several trials, errors and frustrations, the right problem but very awkwardly. Software where the theory of the team does not match, or even worse, the theory is now lost because the original software team is long-gone, is very expensive to maintain.
Building a shared theory of the world-to-software-mapping is a human process that is best done face-to-face by trial and error and with significant time.
Build Less
It has been shown that we build many more features than are actually used. In fact, we can see in Figure 2, only about 20% of functionality we build is used often or always. More than 60% of all functionality built in software is rarely or never used!

One way to reduce the cost of software is to find a way not to build the unused functionality. There are several Agile practices that help you get to that point.
Functionality Usage
Figure 2: Most functionality built is never used.
Pay Less for Bug Fixes
Typically, anywhere between 60%-90% of software cost goes into the maintenance phase. That is, most of our money goes into keeping the software alive and useful for our clients after the initial build. Practices that help us reduce the cost of software maintenance will significantly affect the overall cost of the software product or system.
Figure 3: Maintain the theory of the code helps reducing the cost of making design changes and fixing bugs. Building less enables better understanding and helps to understand the theory of the code for a change because there is less to change
Pay Less for Changes
The only thing constant in today’s software market is change. If we can embrace change, plan for it, and reduce its cost
when it eventually happens we can make significant savings. One of the strongest points of Agile development is that its practices enable you to roll with the punches and change your software as the business world changes.
The four strategies above: maintain the theory of the code, build less, paying less for maintenance and being able to react to change are not independent.
The practices
Evolutionary Design
Evolutionary Design
![]() |
Evolutionary design is the simple design practice done continuously. Start off with a simple design and change that design only when a new requirement cannot be met by the existing design. |
![]() |
Evolutionary design reduces the cost by focusing on always building less. This, in turn, directly affects the cost of change drastically. |
![]() |
You are on a development team practicing automated developer tests, refactoring, and simple design. That’s it, because this is one of those things that is applicable to all types of development projects. The context is especially a match if the technology used technologies is new to a large part of the team. |
Simple Design

![]() |
If a decision between coding a design for today’s requirements and a general design to accommodate for tomorrow’s requirements needs to be made, the former is a simple design. Simple design meets the requirements for the current iteration and no more. |
![]() |
Simple design reduces cost because you build less code to meet the requirements and you maintain less code afterwards. Simple designs are easier to build, understand, and maintain. |
![]() |
Simple design should only be used when your team also is writing automated developer tests and refactoring. A simple design is fine as long as you can change it to meet future requirements. |
Refactoring

![]() |
The practice of Refactoring code changes the structure (i.e., the design) of the code while maintaining its behavioe. |
![]() |
Costs are reduced because continuous refactoring keeps the design from degrading over time, ensuring that the code is easy to understand, maintain, and change. |
![]() |
You are on a development team that is practicing automated developer tests. You are currently working on a requirement that is not well-supported by the current design. Or you may have just completed a task (with its tests of course) and want to change the design for a cleaner solution before checking in your code to the source repository. |
Automated Developer Tests
![]()
![]() |
Automated developer tests are a set of tests that are written and maintained by developers to reduce the cost of finding and fixing defects—thereby improving code quality—and to enable the change of the design as requirements are addressed incrementally. |
![]() |
Automated developer tests reduce the cost of software development by creating a safety-net of tests that catch bugs early and enabling the incremental change of design. Beware, however, that automated developer tests take time to build and require discipline. |
![]() |
You are on a development team that has decided to adopt iterations and simple design and will need to evolve your design as new requirements are taken into consideration. Or you are on a distributed team. The lack of both face-to-face communication and constant feedback is causing an increase in bugs and a slowdown in development. |
Evocative Document
![]()
![]() |
Evocative documents are documents that evoke memories, conversations, and situations that are shared by those who wrote the document. They are more meaningful and representative of a team’s understanding of the system than traditional documents. |
![]() |
Evocative documents help by accurately representing the team’s internal model of the software and allowing that model to be handed down from master to apprentice. The better understanding of the system over time also reduces the maintenance cost of the system over time because appropriate changes reduce the deterioration of the software. |
![]() |
Current documentation isn’t working – as a document is passed from one person to another much of the context and value is lost, and as a result, the maintenance team’s understanding of the codebase constantly deteriorates. This is resulting in the calcification of your software system. |
Automated Acceptance Tests

![]() |
Automated acceptance tests are tests written at the beginning of the iteration that answer the question: “what will this requirement look like when it is done?”. This means that you start with failing tests at the beginning of each iteration and a requirement is only done when that test passes. |
![]() |
This practice builds a regression suite of tests in an incremental manner and catches errors, miscommunications, and ambiguities very early on. This, in turn, reduces the amount of work that is thrown away and therefore enables building less. The tests also catch bugs and act as a safety-net during change. |
![]() |
You are on a development project with an onsite customer who is willing and able to participate more fully as part of the development team. Your team is also willing to make difficult changes to any existing code. You are willing to pay the price of a steep learning curve. |
The remaining practices also help reduce the cost of software development. Because of the limited size of the refcard, we will only summarize them below.
![]() |
A backlog is a prioritized list of requirements that enable a team to build less by making sure they always work on the most important items first and help the team understand the theory of the code when used as an evocative document that shows a larger picture of the system. |
| An iteration is a time-box where the team builds what is on the backlog and is a potential release and therefore enables building less. | |
![]() |
The done state is a definition agreed upon by the entire team of what constitutes the completion of a requirement. The closer the done state is to deployable software, the better it is because it forces the team to resolve all hidden issues early and thus reduces cost. |
![]() |
The cross-functional team is one that has the necessary expertise among its members to take a requirement from its initial concept to a fully deployed and tested piece of software within one iteration. A requirement can be taken off of the backlog, elaborated and developed, tested, deployed. |
![]() |
A self-organizing team is in charge of its own fate. Management gives the team goals to achieve and the team members are responsible for driving towards those goals and achieving them. A self-organizing team recognizes and responds to changes in their environment and in their knowledge as they learn. A self-organizing team is frequently a cross functional team as well. |
![]() |
The Retrospective is a meeting held at the end of a major cycle - iteration or release - to gather and analyze data about that cycle and decide on future actions to improve the team’s environment and process. A retrospective is about evaluating the people, their interactions, and the tools they use. |
![]() |
Continuous integration reduces the total time it takes to build a software system by catching errors early and often. Errors caught early cost significantly less to fix when caught later. It leverages both automated acceptance tests and automated developer tests to give frequent feedback to the team and to pay a much smaller price for fixing a defect. |
![]() |
A user story is an evocative document for requirements. A user story is a very high level description of the requirement to be built –it usually fits on a 3 x 5 index card – and is a “promise for a conversation” later between the person carrying out the Customer Part of Team practice and the implementers. |
How to adopt Agile practices successfully
To successfully adopt Agile practices let’s start by answering the question “which ones first?” Once we have a general idea of how to choose the first practices there are other considerations.
Become “Well-Oiled” First
One way to look at software development is to see it as problem solving for business. When considering a problem to solve there are two fundamental actions that must be taken:
- Solving the right problem. This is IT/Business alignment.
- Solving the problem right. This is technical expertise.
Intuitively it would seem that we must focus on solving the right problem first because, no matter how well we execute our solution to the problem, if it is the wrong problem then our solution is worthless. This, unfortunately, is the wrong way to go. Research shows in Figure 3, that focusing on alignment first is actually more costly and less effective than doing nothing. It also shows that being “well-oiled”, that is focusing on technical ability first, is much more effective and a good stepping-stone to reaching the state where both issues are addressed.

Figure 4: The Alignment Trap (from Avoiding the Alignment Trap in Information Technology, Shpilberg, D. et al, MIT Sloan Management Review, Fall 20078.)
This is supported anecdotally by increasing reports of failed Agile projects that do not deliver on promised results. They adopt many of the soft practices such as Iteration, but steer away from the technically difficult practices such as Automated Developer Tests, Refactoring, and Done State. They never reach the “well-oiled” state.
So the lesson here is make sure that on your journey to adopt Agile practices that improve time to market (or any other business value for that matter), your team will need to become “well-oiled” to see significant, sustained improvement. And that means you should plan on adopting the difficult technical practices for sustainability.
Know What You Don’t Know
The Dreyfus Model of Skill Acquisition, is a useful way to look at how we learn skills – such as learning Agile practices necessary to reduce cost. It is not the only model of learning, but it is consistent, has been effective, and works well for our purposes. This model states that there are levels that one goes through as they learn a skill and that your level for different skills can and will be different. Depending on the level you are at, you have different needs and abilities. An understanding of this model is not crucial to learning a skill; after all, we’ve been learning long before this model existed. However, being aware of this model can help us and our team(s) learn effectively.
So let’s take a closer look at the different skill levels in the Dreyfus Model:

Figure 5: The Dreyfus Model for skill acquisition. One starts as a novice and through ecperience and learning advances towards expertise.
How can the Dreyfus Model help in an organization that is adopting agile methods? First, we must realize that this model is per skill, so we are not competent in everything. Secondly, if agile is new to us, which it probably is, then we are novices or advanced beginners; we need to search for rules and not break them until we have enough experience under our belts. Moreover, since everything really does depend on context, and we are not qualified to deal with context as novices and advanced beginners, we had better get access to some people who are experts or at least proficient to help guide us in choosing the right agile practices for our particular context. Finally, we’d better find it in ourselves to be humble and know what we don’t know to keep from derailing the possible benefits of this new method. And we need to be patient with ourselves and with our colleagues. Learning new skills will take time, and that is OK.
Choosing a Practice to Adopt
Choosing a practice comes down to finding the highest value practice that will fit into your context. Figure 1 will guide you in determining which practices are most effective in decreasing your time to market and will also give you an understanding of the dependencies. The other parts in this section, How to Adopt Agile Practices Successfully?, discuss other ideas that can help you refine your choices. Armed with this information:

Figure 5: Steps for choosing and implementing practices.
What Next?
This Refcard is a quick introduction to Agile practices that can help you reduce the cost of building and maintaining your software and an introduction of how you to choose the practices for your organizational context. It is only a starting point. If you choose to embark on an Agile adoption initiative, your next step is to educate yourself and get as much help as you can afford. Books and user groups are a beginning. If you can, find an expert to join your team(s). Remember, if you are new to Agile, then you are a novice or advanced beginner and are not capable of making an informed decision about tailoring practices to your context.
References
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| Astels, David. 2003. Test-driven development: a practical guide. Upper Saddle River, NJ: Prentice Hall. | x | x | ||||||||||||
| Avery, Christopher, Teamwork is an Individual Skill, San Francisco: Berrett-Koehler Publishers, Inc., 2001 | x | |||||||||||||
| Bain, Scott L., 2008, Emergent Design, Boston, MA: Pearson Education | x | x | x | x | ||||||||||
| Beck, Kent. 2003. Test-driven development by example. Boston, MA: Pearson Education. | x | x | ||||||||||||
| Beck, K. and Andres, C., Extreme Programming Explained: Embrace Change (second edition), Boston: Addison-Wesley, 2005 | x | x | x | x | x | x | x | x | ||||||
| Cockburn, A., Agile Software Development: The Cooperative Game (2nd Edition), Addison-Wesley Professional, 2006. | x | |||||||||||||
| Cohn, M., Agile Estimating and Planning, Prentice Hall, 2005. | x | x | ||||||||||||
| Crispin, L. and Gregory, J., Agile Testing: A Practical Guide for Testers and Agile Teams | x | |||||||||||||
| Derby, E., and Larson, D., Agile Retrospectives: Making Good Teams Great, Raliegh: Pragmatic Bookshelf, 2006. | x | x | ||||||||||||
| Duvall, Paul, Matyas, Steve, and Glover, Andrew. (2006). Continuous Integration: Improving Software Quality and Reducing Risk. Boston: Addison-Wesley. | x | |||||||||||||
| Elssamadisy, A., Agile Adoption Patterns: A Roadmap to Organizational Success, Boston: Pearson Education, 2008 | x | x | x | x | x | x | x | x | x | x | x | x | x | x |
| Feathers, Michael. 2005. Working effectively with legacy code. Upper Saddle River, NJ: Prentice Hall. | x | x | ||||||||||||
| Jeffries, Ron. “Running Tested Features.” http://www.xprogramming.com/xpmag/jatRtsMetric.htm | x | |||||||||||||
| Jeffries, Ron. 2004. Extreme programming adventures in C#. Redmond, WA: Microsoft Press. | x | x | ||||||||||||
| Kerth, N., Project Retropsectives: A Handbook for Team Reviews, NY: Dorset House Publishing Company, 2001. | x | |||||||||||||
| Kerievsky, Joshua. “Don’t Just Break Software, Make Software.” http://www.industriallogic.com/papers/storytest.pdf | x | |||||||||||||
| Larman, C., Agile and Iterative Development: A Manager’s Guide, Boston: Addison-Wesley, 2004 | x | x | ||||||||||||
| Larman, C., and Vodde, B., Scaling Lean and Agile Development, Boston: Addison-Wesley, 2009 | x | x | x | |||||||||||
| Massol, Vincent. 2004. Junit in action. Greenwich, CT: Manning Publications. | x | x | ||||||||||||
| Meszaros, XUnit Test Patterns: Refactoring Test Code, Boston: Addison-Wesley, 2007 | x | x | ||||||||||||
| Mugridge, R., and W. Cunningham. 2005. Fit for Developing Software: Framework for Integrated Tests. Upper Saddle River, NJ: Pearson Education. | x | |||||||||||||
| Poppendieck, M., and Poppendieck, T., Implementing Lean Software Development, Addison-Wesley Professional, 2006. | x | |||||||||||||
| Rainsberger, J.B. 2004. Junit recipes: Practical methods for programmer testing. Greenwich, CT: Manning Publications. | x | x | ||||||||||||
| Schwaber, K., and Beedle, M., Agile Software Development with Scrum, Upper Saddle River, New Jersey: Prentice Hall, 2001. | x | x | x | x | ||||||||||
| Senge, P., The Fifth Discipline: The Art and Practice of The Learning Organization, NY: Currency 2006. | x | |||||||||||||
| Surowiecki, J., The Wisdom of Crowds, NY: Anchor, 2005. | x |
About Gemba Systems
Gemba Systems is comprised of a group of seasoned practitioners who are experts at Lean & Agile Development as well as crafting effective learning experiences. Whether the method is Scrum, Extreme Programming, Lean Development or others - Gemba Systems helps individuals and teams to learn and adopt better product development practices. Gemba Systems has taught better development techniques - including lean thinking, Scrum and Agile Methods - to thousands of developers in dozens of companies around the globe. To learn more visit http://us.gembasystems.com/
Recommended Book
Agile Adoption Patterns will help you whether you’re planning your first agile project, trying to improve your next project, or evangelizing agility throughout your organization. This actionable advice is designed to work with any agile method, from XP and Scrum to Crystal Clear and Lean. The practical insights will make you more effective in any agile project role: as leader, developer, architect, or customer.
Gemba Systems is comprised of a group of seasoned practitioners who are experts at Lean & Agile Development as well as crafting effective learning experiences.
your friends & followers...
DZone greatly appreciates your support.
Your download should begin immediately.
If it doesn't, click here.
Agile Adoption
Decreasing Time to Market
By Gemba Systems
16,181 Downloads · Refcard 45 of 151 (see them all)
Download
FREE PDF
The Essential Agile Adoption Cheat Sheet
People who downloaded this DZone Refcard also liked:
Agile Adoption: Decreasing time to market
By Gemba Systems
About Agile Adoption
There are a myriad of Agile practices out there. Which ones are right for you and your team? What are the business values you want out of adopting Agile and what is your organization’s context? This Refcard is focused on helping you evaluate and choose the practices for your team or organization when getting to market faster is of prime importance. Instead of focusing on entire methods such as Scrum and XP, we will talk about the practices that are the building blocks of these methods such as iterations and automated developer tests. We will answer two basic questions:
- What Agile practices should you consider to improve Time to Market?
- How should you go about choosing from those practices given your organization and context?
What Agile Practices improve time to market?
Figure 1-These are the Agile practices that improve time to market. The most effective practices are near the top of the diagram. Therefore iteration is more effective than Onsite Customer for improving time to market. The arrows indicate dependencies. Continuous Integration depends on Automated Developer Tests for it to be effective.
Iteration
*Practices in pink are ones that don’t directly address time to market but are needed to support practices that do (hence a dependency). They are not described in this Refcard but can be found in the external references.
![]() |
An iteration is a time-boxed event that is anywhere between 1 to 4 weeks long. The development staff works throughout this period – without interruption – to build an agreed upon set of requirements that are accepted by the customer and meet an agreed upon “done state”. |
![]() |
To get the most of an iteration and reduce your time to market, an iteration needs to work from an iteration backlog and reach a solid done state at its completion. Such an iteration reduces time to market because every time-boxed iteration is a potential release. There is little “work in progress” between iterations and defects are found early and often for cheaper and faster removal. |
![]() |
Any software team that is building software where they are not 100% sure of their outcome is a candidate for performing iterations. Without iterations the majority of learning (from mistakes) only happens at the end and coursecorrections are difficult if not impossible. |
Continuous Integration
Figure 2-The cost of fixing a defect increases over time because of context switching, communication, and bugs being built on existing bugs.
Release Often
![]() |
Release your software to your end customers as often as you can without inconveniencing them. |
![]() |
Releasing often streamlines your development process and makes you deal with the pains of getting software good enough to go live. A team that releases often faces the pains and addresses the problems that make deployment difficult so that releasing is just another development task. |
![]() |
You are on a project where releasing often will enable you to produce revenue earlier. Having new features available frequently will not inconvenience your customer base. The quality of your releases is superb and your customers eagerly await your next release (instead of religiously keeping away from your 1.0 releases). |
Done State
![]() |
The done state is a definition agreed upon by the entire team of what constitutes the completion of a requirement. The closer the done state is to deployable software, the better it is because it forces the team to resolve all hidden issues. |
![]() |
A done state that is close to deployment enables the team to be confident in its work. The psychological effect of this confidence is a development team that gives good estimates, delivers regularly, and is confident in releasing its software. An executive decision can be made to release what has been built at anytime. |
![]() |
A team that should consider using a done state is one that has the necessary expertise and resources to build a requirement from end-to-end and perform all of the necessary build and deployment tasks. |
Iteration Backlog
![]() |
A backlog is a prioritized list of requirements. There are two common flavors of backlogs, one for the current iteration and one for the product. The product backlog contains all of the requirements prioritized by value to the customer. The iteration backlog is a list of requirements that a team has committed to building for an iteration. |
![]() |
Properly prioritized backlogs that are used to set the goals for every iteration ensure that the team is always working on the most important requirements. When paired with iterations that produce working, tested software, backlogs give a development team the option to release at the end of any iteration having always worked on the most important issues. |
![]() |
An expert on business value is needed to be part of the team to prioritize the backlog. If your team has such a person or someone that can coordinate with the business stakeholders to do so then use a product backlog. If you are using iterations then use an iteration backlog to set clear goals for the iterations and a release backlog to maintain long-term goals. |
Automated Developer Tests
![]() |
Automated developer tests are a set of tests that are written and maintained by developers to reduce the cost of finding and fixing defects—thereby improving code quality—and to enable the change of the design as requirements are addressed incrementally. |
![]() |
Automated developer tests reduce the time to market by actually reducing the development time. This is accomplished by reducing a developer’s time in debugging loops by catching errors in the safety-net of tests. |
![]() |
You are on a development team that has decided to adopt iterations and simple design and will need to evolve your design as new requirements are taken into consideration. Or you are on a distributed team. The lack of both face-to-face communication and constant feedback is causing an increase in bugs and a slowdown in development. |
Automated Acceptance Tests
![]() |
Automated acceptance tests are tests written at the beginning of the iteration that answer the question: “what will this requirement look like when it is done?”. This means that you start with failing tests at the beginning of each iteration and a requirement is only done when that test passes. |
![]() |
This practice builds a regression suite of tests in an incremental manner and catches errors, miscommunications, and ambiguities very early on. This, in turn, reduces the amount of work that is thrown away and enables faster development as you receive early feedback when a requirement is no longer satisfied. |
![]() |
You are on a development project with an onsite customer who is willing and able to participate more fully as part of the development team. Your team is also willing to make difficult changes to any existing code. You are willing to pay the price of a steep learning curve. |
Onsite Customer
![]() |
The onsite customer role in an Agile development team is a representative of the users of the system who understands the business domain of the software. The customer owns the backlog, is responsible for writing and clarifying requirements, and responsible for checking that the software meets the requirements specified. |
![]() |
The role of customer helps improve time to market by supporting the developers by giving them clear requirements, providing clarifications and verifying that the software does really meet the needs of the user base. The customer provides early feedback to the development team so they never spend more than an iteration down a blind alley. Finally, having a customer who correctly prioritizes a backlog allows the team to deliver the most important items first when time is of the essence. |
![]() |
The practice of onsite customer works best when the development team can be co-located with one or more domain experts. The person fulfilling the customer role is crucial to the success of the team and therefore will need sufficient time and resources to do the job. |
Simple Design
*Practices in pink are ones that don’t directly address time to market but are needed to support practices that do (hence a dependency). They are not described in this Refcard but can be found in the external references.
![]() |
If a decision between coding a design for today’s requirements and a general design to accommodate for tomorrow’s requirements needs to be made, the former is a simple design. Simple design meets the requirements for the current iteration and no more. |
![]() |
Simple design improves time to market because you build less code to meet the requirements and you maintain less code afterwards. Simple designs are easier to build, understand, and maintain. |
![]() |
Simple design should only be used when your team also is writing automated developer tests and refactoring. A simple design is fine as long as you can change it to meet future requirements. |
Refactoring
*Practices in pink are ones that don’t directly address time to market but are needed to support practices that do (hence a dependency). They are not described in this Refcard but can be found in the external references.
![]() |
The practice of Refactoring code changes the structure (i.e., the design) of the code while maintaining its behavior. Collective code ownership is needed because a refactoring frequently affects other parts of the system. Automated developer tests are needed to verify that the behavior of the system has not changed after the design change introduced by the refactoring. |
![]() |
Refactoring improves time to market by supporting practices like Simple Design which, in turn, allow you to only write the software for the features that are needed now. |
![]() |
You are on a development team that is practicing automated developer tests. You are currently working on a requirement that is not well-supported by the current design. |
Cross-Functional Team
![]() |
The team that utilizes the Cross Functional Team practice is one that has the necessary expertise among its members to take a requirement from its initial concept to a fully deployed and tested piece of software within one iteration. A requirement can be taken off of the backlog, elaborated and developed, tested, deployed. |
![]() |
Cross-functional teams primarily affect time to market by enabling true iterative and incremental development. Resource bottlenecks are resolved and teams can build features end-to-end. |
![]() |
There is a hardening cycle at the end of each release indicating unresolved integration issues. Building a slice of functionality end-to-end in your system finds errors early and requires diverse expertise of many different people. |
How to adopt agile practices successfully
To successfully adopt Agile practices let’s start by answering the question “which ones first?” Once we have a general idea of how to choose the first practices there are other considerations.
Become “Well-Oiled” First
One way to look at software development is to see it as problem solving for business. When considering a problem to solve there are two fundamental actions that must be taken:
- Solving the right problem. This is IT/Business alignment.
- Solving the problem right. This is technical expertise.
Intuitively it would seem that we must focus on solving the right problem first because, no matter how well we execute our solution to the problem, if it is the wrong problem then our solution is worthless. This, unfortunately, is the wrong way to go. Research shows in Figure 3, that focusing on alignment first is actually more costly and less effective than doing nothing. It also shows that being “well-oiled”, that is focusing on technical ability first, is much more effective and a good stepping-stone to reaching the state where both issues are addressed.
This is supported anecdotally by increasing reports of failed Agile projects that do not deliver on promised results. They adopt many of the soft practices such as Iteration, but steer away from the technically difficult practices such as Automated Developer Tests, Refactoring, and Done State. They never reach the “well-oiled” state.
So the lesson here is make sure that on your journey to adopt Agile practices that improve time to market (or any other business value for that matter), your team will need to become “well-oiled” to see significant, sustained improvement. And that means you should plan on adopting the difficult technical practices for sustainability.
Figure 3-The Alignment Trap (from Avoiding the Alignment Trap in Information Technology, Shpilberg, D. et al, MIT Sloan Management Review, Fall 2007.)
Minimize What You Build
Statistics show that most of what software development teams build is not used. In Figure 4 we see that only 7% of functionality is always used. And 45% is never used. This is a sad state of affairs, and an excellent opportunity. One of the easiest ways to speed up is to do less. If you have less to build, then not only do you spend less time writing and testing software, but you also reduce the complexity of the entire application. And by reducing the complexity of the application it takes less time to maintain because you have a simpler design, fewer dependencies, and fewer physical lines of code that your developers must understand and maintain.
Figure 4- Most functionality built is not used
Cross-Functional Team
Figure 5- Context matters. Choose Agile practices that fit your context.
The practices are all described within context. So, for example,the context for the Release Often practice indicates that your customers should be willing to install and run frequent releases and that the quality of your current builds are exceptional. If this is not the case, if your current releases go through a ‘stabilization phase’ and your customers have learned never to take a 1.0 release, then do not adopt Release Often, you will end up hurting your relationship with your customers.
Learning is the Bottleneck
Here is a hypothetical situation that we have presented to many experienced software development teams:
Suppose I was your client and I asked you and your team to build a software system for me. Your team proceeds to build the software system. It takes you a full year – 12 months – to deliver working, tested software.
I then thank the team and take the software and throw it out. I then ask you and your team to rebuild the system. You have the same team. The same requirements. The same tools and software. Basically – nothing has changed – it is exactly the same environment.
How long will it take you and your team to rebuild the system again?
When we present this hypothetical situation to development practitioners – many of them with 20+ years experience in building software – they typically respond with anywhere between 20% to 70% of the time. That is, rebuilding a system that originally takes one year to build takes only 2.5 to 8.5 months to build. It is a huge difference!
So, what is the problem? What was different? The team has learned. They learned about each other as a team and have gelled over the year. They learned about the true requirements – not just those written down. They also learned to use the toolset, they experienced the idiosyncrasies that come up during all software development, and basically they worked through all the unknowns until they built and delivered a successful software solution. Learning is THE bottleneck of software engineering.
The learning that occurs makes up a significant percentage of the time spent on the work. That’s the main reason that Agile practices work so well – they are all about recognizing and responding to change. Agile practices, from continuous integration to iterations, all consist of cycles that help the team learn fast. By cycling in every possible practice, Agile teams accelerate learning, addressing the bottleneck of software engineering. Call it “scientific method,” “continuous improvement” or “inspect and adapt”, to truly benefit from these practices you and your team(s) must learn well and learn often.
Know What You Don’t Know
Since learning is the bottleneck, it makes sense to talk a bit about how we actually learn. The Dreyfus Model of Skill Acquisition, is a useful model of learning. It is not the only model of learning, but it is consistent, has been effective, and works well for our purposes. This model states that there are levels that one goes through as they learn a skill and that your level for different skills can and will be different. Depending on the level you are at, you have different needs and abilities. An understanding of this model is not crucial to learning a skill; after all, we’ve been learning long before this model existed. However, being aware of this model can help us and our team(s) learn effectively.
So let’s take a closer look at the different skill levels in the Dreyfus Model:
Figure 6-The Drefyus Model for skill acquisition. One starts as a novice and through experience and learning advances towards expertise.
How can the Dreyfus Model help in an organization that is adopting agile methods? First, we must realize that this model is per skill, so we are not competent in everything. Secondly, if agile is new to us, which it probably is, then we are novices or advanced beginners; we need to search for rules and not break them until we have enough experience under our belts. Moreover, since everything really does depend on context,and we are not qualified to deal with context as novices and advanced beginners, we had better get access to some people who are experts or at least proficient to help guide us in choosing the right agile practices for our particular context. Finally, we’d better find it in ourselves to be humble and know what we don’t know to keep from derailing the possible benefits of this new method. And we need to be patient with ourselves and with our colleagues. Learning new skills will take time, and that is OK.
Choosing a Practice to Adopt
Choosing a practice comes down to finding the highest value practice that will fit into your context. Figure 1 will guide you in determining which practices are most effective in decreasing your time to market and will also give you an understanding of the dependencies. The other parts in this section discuss other ideas that can help you refine your choices. Armed with this information:
Figure 7- Steps for Choosing and Implementing Practices
Small steps and failing fast are the most effective methods to release quickly. Weed out defects early because the earlier you find them, the less they will cost to fix as shown in Figure 2 and you won’t be building on a crumbling foundation. This is why Continuous Integration and Iteration lead the practices that most positively affect time to market. They are both, however, dependent on several practices to be effective, so consider starting with Automated Developer Tests and the Iteration trio – Iteration, Iteration Backlog, and Done State.
Next Steps
This refcard is a quick introduction to Agile practices that can help you improve your time to market and an introduction of how you to choose the practices for your organizational context. It is only a starting point. If you choose to embark on an Agile adoption initiative, your next step is to educate yourself and get as much help as you can afford. Books and user groups are a beginning. If you can, find an expert to join your team(s). Remember, if you are new to Agile, then you are a novice or advanced beginner and are not capable of making an informed decision about tailoring practices to your context.
Reference table
![]() |
![]() |
![]() |
![]() |
|||||||
| Astels, David. 2003. Test-driven development: a practical guide. Upper Saddle River, NJ: Prentice Hall. |
||||||||||
| Beck, Kent. 2003. Test-driven development by example. Boston, MA: Pearson Education. |
||||||||||
| Beck, K. and Andres, C., Extreme Programming Explained: Embrace Change (second edition), Boston: Addison-Wesley, 2005 |
||||||||||
| Cockburn, A., Agile Software Development: The Cooperative Game (2nd Edition), Addison-Wesley Professional, 2006. |
||||||||||
| Cohn, M., Agile Estimating and Planning, Prentice Hall, 2005. | ||||||||||
| Duvall, Paul, Matyas, Steve, and Glover, Andrew. (2006). Continuous integration: Improving Software Quality and Reducing Risk. Boston: Addison-Wesley. |
||||||||||
| Elssamadisy, A., Agile Adoption Patterns: A Roadmap to Organizational Success, Boston: Pearson Education, 2008 |
||||||||||
| Feathers, Michael. 2005. Working effectively with legacy code. Upper Saddle River, NJ: Prentice Hall. |
||||||||||
| Jeffries, Ron. “Running Tested Features.” http://www.xprogramming.com/xpmag/jatRtsMetric.htm |
||||||||||
| Jeffries, Ron. 2004. Extreme programming adventures in c#. Redmond, WA: Microsoft Press. |
||||||||||
| Kerievsky, Joshua. “Don’t Just Break Software, Make Software.” http://www.industriallogic.com/papers/storytest.pdf |
ABOUT Gemba Systems
Gemba Systems
Gemba Systems is comprised of a group of seasoned practitioners who are experts at Lean & Agile Development as well as crafting effective learning experiences. Whether the method is Scrum, Extreme Programming, Lean Development or others - Gemba Systems helps individuals and teams to learn and adopt better product development practices. Gemba Systems has taught better development techniques - including lean thinking, Scrum and Agile Methods - to thousands of developers in dozens of companies around the globe. To learn more visit http://us.gembasystems.com/
Recommended Book
Agile Adoption Patterns will help you whether you’re planning your first agile project, trying to improve your next project, or evangelizing agility throughout your organization. This actionable advice is designed to work with any agile method, from XP and Scrum to Crystal Clear and Lean. The practical insights will make you more effective in any agile project role: as leader, developer, architect, or customer.
BUY NOW
Gemba Systems is comprised of a group of seasoned practitioners who are experts at Lean & Agile Development as well as crafting effective learning experiences.
your friends & followers...
DZone greatly appreciates your support.
Your download should begin immediately.
If it doesn't, click here.
Getting Started with Kanban for Software Development
By David J. Anderson and Janice Linden-Reed
18,592 Downloads · Refcard 109 of 151 (see them all)
Download
FREE PDF
The Essential Kanban Cheat Sheet
People who downloaded this DZone Refcard also liked:
Getting Started with Kanban for Software Development
By David J. Anderson and Janice Linden-Reed
About Kanban
Software organizations want development to be predictable: to accurately state what work will be done and when it will be finished. To make such predictions, mechanisms must be in place to determine prioritization, workflow and lead time to delivery.
Even if all these mechanisms are in place, there is the risk that unfolding events can throw off predictability. What if someone is not available for a handoff? What if the conditions of the business change, forcing re-prioritization? A business needs to be able to see their situation clearly and make needed corrections quickly.
Kanban takes an organization’s current development process and provides greater visibility into the status of the work and how it is proceeding. Kanban provides a method to continually adapt in order to smooth out kinks in the arrival of new development work. In this way, it allows the organization to avoid crises and respond more quickly and easily to issues that do arise.
Kanban also gives more precise direction on how to invest development energy into only the most valuable work. The end result is a development pipeline that is predictably and efficiently delivering high value work.
The Kanban Method reduces risk and increases flexibility, resulting in a more resilient development cycle.
Why Kanban?
Why make any change in your development process? Consider your organization’s unique situation and goals before starting. Here are some benefits that can be delivered by the Kanban Method.
Goal 1: Optimize Existing Processes – Introduction of visualization and the limiting of work-in-progress (WIP) will catalyze change with minimal disruption.
Goal 2: Deliver with Higher Quality – Limiting work-in-progress and defining policies for work prioritization will bring greater focus on quality. Policies can also address quality criteria directly.
Goal 3: Improve Lead Time Predictability – There is a correlation between the amount of work-in-progress, lead time and defect rates. Limiting WIP makes lead times dependable and keeps defect rates low.
Goal 4: Improve Employee Satisfaction – Kanban reduces context switching and pulls work at the rate the team can complete it. Working at a more even, predictable pace, means employees are never overloaded.
Goal 5: Provide Slack to Enable Improvement – Creating slack in the value chain improves responsiveness to urgent requests and bandwidth to enable process improvement and quality improvement.
Goal 6: Simplify Prioritization – Kanban enables fast reprioritization to accommodate changes in the market.
Goal 7: Provide a Transparency on the System Design and Operation – Improved visibility builds trust with customers and managers. It also shows the effects of actions or inactions. As a result, collaboration improves.
Goal 8: Enables Emergence of a “High-Maturity” Organization – As improvements are implemented, organizational maturity improves leading to better decision making and improved risk management. Risk, managed appropriately, brings predictable results.
The Kanban method
The Kanban Method is defined by a set of key principles and practices. Five core princples enable The Kanban Method.
| 1. Visualize the Workflow | Represent the work items and the workflow on a card wall or electronic board. |
| 2. Limit Work-in-Progress (WIP) | Set agreed upon limits to how many work items are in progress at a time. |
| 3. Measure & Manage Flow | Track work items to see if they are proceeding at a steady, even pace. |
| 4. Make Process Policies Explicit | Agree upon and post policies about how work will be handled. |
| 5. Use Models to Evaluate Improvement Opportunities | Adapt the process using ideas from Systems Thinking, W. E. Deming, etc |
When these 5 conditions are present, a Lean software development method will emerge over time.
Attributes of Lean Software development
Lean software development has these principles: Respect people, eliminate waste, defer commitment, create knowledge, deliver fast, build quality in and optimize the whole.
Think of the development process as a pipeline. Anything that slows down the pipeline is waste. Look for ways to increase the value while improving the efficiency of the process. The improvements will happen when you can see what is going on and reduce waste.
Lean software development looks to the system, the way work is managed or handed off, for the source of errors. When an issue is identified, the development group looks to how they can change the system for permanent improvement.
Lean Thinking asks us to focus on the system – the process and its policies – and not the performance of individuals. The focus is on a better economic outcome rather than on utilization of individual workers.
Visualize the workflow
The Kanban Method takes an existing software development process and brings it into sharper focus. Rather than redefining the development process, it reveals details about the current process providing visibility that allows the organization to better understand and better communicate about needed changes.
Kanban brings greater visibility into what work is being done and the issues that arise with work items or the workflow. Understanding the current capability of the system of development gives more accurate predictability.
Mapping the Value Creation Network
The value creation network is the complex sequence of information discovery and creativity that takes place from initial request to delivery of software. Visualizing such a network can be challenging and it typical degenerates into a rough sequence of steps: common handoffs are shown; and time spent queuing is shown. Optimization often occurs from analysis of the value creation network.
Different work item types may flow differently and require a separate analysis and visualization.
The card wall will be created for the portion of the value creation network that is under political control of managers supportive of the Kanban initiative.
Creating the Card Wall
It is typical to draw card walls to show the activities that happen to the work rather than specific functions or job descriptions.
Draw columns on the board that represent the activities performed, in the order first performed. Model in-progress and completed work by splitting the columns. Add the initial input queue and any downstream delivery steps that you wish to visualize. Finally, add any buffers or queues (Ready or Done states) between activities.

It is important to create a card wall that reflects the current development process, with the intent to improve it over time.
The cards themselves could be sticky notes or index cards. They may represent features, stories or tasks. Critical information for a card would be title, reference number, and date it entered the system.
Limit Work-in-progress (WIP)
Leadership is the secret ingredient - all 5 core principles of the Kanban Method will not enable a significant improvement to happen without it. The WIP limit provokes the conversations that lead to improvements.
A limit on work-in-progress constrains how many work items can be in each workflow step at a time. When a work item progresses, a slot opens and a new work item can flow into the development step.
A key result of a WIP limit is that blocked work “holds up the line”. A blocked work item still counts against the limit, so a situation may arise in which no new work can progress until the block is resolved. This drives collaboration as the team is highly motivated to clear the blockage.

Blocked item in Test must clear to open up a space
If a conflict with the limit arises, the team has a choice to break the WIP limit and ignore the issues, or face up to the issues and address them using models from lean thinking.
How big a limit? - WIP limits for workflow steps should be set as an average number of items per person, developer pair or small, collaborative team. Limits should be in the range of one to three items per person, pair or team.
Excessive time should not be wasted trying to determine the perfect WIP limit; simply pick a number that is close enough, and make progress. Empirically adjust if necessary.
Agreed upon limits - WIP limits should be agreed upon through consensus with up- and downstream stakeholders and senior function management as well as the development team. Not every step must have a limit.
Limit the queue - A work-in-progress (WIP) limit on the input queue of upcoming work focuses attention on what to start next.
It provokes a focus on value. A queue between the backlog and development can be used for interim prioritization.
Queue limits should be kept small, typically only large enough to absorb the natural variation in size of items and task duration, and the period between queue replenishment meetings.
Handling bottlenecks - Bottlenecks, once identified, should be buffered. Add a lane on the card wall as a holding area for stories around the bottleneck area. This introduces some slack into the process.
Buffer sizes should be as small as possible but large enough to ensure the bottleneck is never idle.
No WIP limit? - Care should be taken that establishing any unlimited (no WIP limit) workflow steps does not introduce bottlenecks or cause excessive transaction- or coordination costs when deliveries (batch transfers downstream) are made.
Collaboration - Limited WIP means that team members might have to “swarm” on a work item to complete it. This crossfunctional collaboration is a strong way to finish work faster and with higher quality.
Measure and manage flow
Flow is the visible progression of the work items through the system. Flow should proceed at a consistent pace. If a work item seems to languish, a conversation should happen to resolve how the team can get it “flowing” again. If all work items within a particular step of the workflow seem to stall, this may suggest a bottleneck in the system. A conversation and action toward resolution can happen with the team and management based on such visible evidence of an issue.
Flow is not something that can be manipulated directly. It is an indicator that notifies when some aspect of the process needs adjusting or some area needs attention. The goal with a kanban system is to create the conditions for the work to flow at a dependable, measurable pace. The systemic variables that can be directly influenced are the team members, the typical work item size, the workflow steps, and the WIP limit. Flow of an individual item can be affected by issues such as ambiguous requirements, dependencies, or approvals.
Explicit Process policies
Having agreed upon policies regarding: workflow; WIP limits; approvals; prioritization; and other process topics; results in greater understanding, greater compliance, and less contentious discussions when exceptions do occur. If a suggestion to violate a policy is made, a discussion can happen reviewing the current policy and posing the question of whether the group feels the policy should be changed, or if it is worthwhile to allow a one-time exception. Focus on policies depersonalizes issues and exceptional circumstances. This leads to a healthier, more collaborative workplace. It is often best to post explicit process policies in a public team area such as next to the card wall.
Use models to eval uate improvement
W. Edwards Deming suggested that we should study the system and its capabilities. The Kanban Method embraces this idea. Gathering data on system performance: flow time; WIP; delivery throughput; will provide scientific insight into opportunities for improvements. It is common (and encouraged) for kanban teams to frequently modify their processes and policies during their daily check-in meeting and at formal retrospectives and operations review meetings.
Useful models to learn and use may include work from:
- Womack & Jones on Waste Reduction
- Eliyahu M. Goldratt on Theory of Constraints
- John Seddon and Peter Senge on Systems Thinking
- W. Edwards Deming’s System of Profound Knowledge and specifically his work on variability
- Taiichi Ohno (Toyota Production System) on muda, muri and mura.
Introducing Kanban
The best way to introduce Kanban into an organization is incrementally rather than through a planned transition initiative and prescribed training program. It may also be useful to start with a pilot team who can “try it out” and demonstrate it for the rest of the organization. The most important thing is to gain consensus around the introduction of Kanban and just start using it, changing as little of the existing culture and process as possible. Here are 12 steps to getting started with Kanban.
- Agree on a set of goals for introducing Kanban. What benefit do you want to see for your organization?
- Determine a set of unique types of customer valued work that flow through the organization, examples include bug, change request, or feature.
- Map the value creation network for different types of work. This will represent the underlying model of your system (see step 5).
- Begin to visualize the flow through the system and study the system performance and capabilities. The purpose is to understand the system operation not affect performance or implement control.
- Define some starting point from where you want to control system performance. Identify what is upstream of that point and the upstream stakeholders. Define some exit point beyond which you do not intend to control system performance. Identify what is downstream of that point and the downstream stakeholders.
- If there are different urgency criteria for the different work item types, define a class of service for each with relative priorities.
- Study the demand for each work item type. Is the arrival seasonal or event-driven? What is the tolerance for late or unreliable delivery of each? Create a risk profile that allocates a percentage of resources to each work item type.
- Meet with team members, upstream and downstream stakeholders to discuss and agree on policies around WIP limits, prioritization meetings, and release mechanisms. If you choose to introduce the concept of class of service, discuss and agree target delivery policy for each class of service.
- Create a board/card wall to visualize the workflow. This will cover the workflow that exists between the input and exit points defined in step 5.
- Optionally, create an electronic system to track and report the same.
- Agree to have a standup meeting every day in front of the card wall/board, as a daily opportunity to drive improvements. Agree to have a regular operations review meeting for longer term retrospective analysis of process performance.
- Educate the team on the new board, WIP limits, and pull system operation.
Coordination practices
Holding regular meetings reduces the coordination cost for those meetings and improves attendance.
Input queue replenishment and delivery planning should be done independently and have their own independent cadence.
Daily standup meetings should be used to discuss issues, impediments and flow. Such standup meetings do not typically follow the established pattern of other Agile development methods.
Daily standups are an essential part of a culture of continuous improvement. Because the standup brings the whole team together briefly each day, it provides an opportunity for all stakeholders to suggest and discuss process performance problems. The period immediately after the standup often develops into informal process-improvement discussions.
Grooming the backlog with regular triage to reduce its size improves the effectiveness and efficiency of input queue replenishment meetings.
Issue management, escalation and resolution is a core discipline in improving the performance of the system. It is important that teams develop a core capability at issu management, escalation and resolution.
For all types of work items escalation paths and policies should be clearly defined.
Emergent Behavior
Through its 5 core principles, the Kanban Method enables incremental process improvement through repeated discovery of issues affecting process performance. It supports gradual, continual improvement toward higher performance and greater quality. It drives process evolution, rather than a revolution.
Once in place, Kanban has been observed to stimulate emergent behavior in many organizations. Such emergent behaviors may include:
Process uniquely tailored to each project/value stream
Decoupled cadences (or “iterationless” development)
Work scheduled by (opportunity) cost of delay
Value optimized with classes of service
Risk managed with capacity allocation
Tolerance for process experimentation
Quantitative Management
Viral spread (of Kanban) across the organization
Small teams merged for more liquid labor pools
Prioritization
In a limited WIP pull system, prioritization practices will guide which work items should be pulled next to optimize value. The following techniques help to enable flow by creating prioritization process policies that the management and the team can agree on and follow.
Input Queue Replenishment Meetings
Kanban decouples input queue replenishment cadence from development lead time and delivery. This is unlike Agile methods that couple prioritization activity to a time-boxed period of development activity such as 2 weeks.
Frequent queue replenishment meetings provide visibility for upstream stakeholders and help to build trust.
Ad-hoc or on-demand input queue replenishment meetings can make sense for high-maturity organizations with strong capability to coordinate such meetings at short notice. Such teams can call such a meeting whenever they pull a new feature to develop. Other organizations should schedule input queue replenishment with a regular cadence such as weekly.
Capacity Allocation by Work Item Type
Different work items can have different workflows. For example, a defect may enter the development process at a different point and may be processed in a different way than a new feature . A “defect” and a “new feature” are 2 examples of work item types.
Relative priorities can be set for each work item type. Establishing a policy around how much of the development team’s availability will be used for each work item type at any time is called capacity allocation by work item type.
It is useful to set an allocation by work item type to provide clarity about which kinds of work the team is spending time developing. It sets an agreement with the development team and management about how their resources are best spent.
Displaying on the card wall - Horizontal swimlanes are often used for each work item type and a WIP limit set for each swimlane.
Setting policies - Capacity allocation requires comparative demand analysis across the different types of work received by the kanban system. Some work item types will enter the system more frequently or they may be considered more urgent. These factors should be considered when creating a policy about the quantity of resources to allocate to each work item type.

A card wall showing allocation by work item type & limits
Prioritization by Class of Service
Class of service allows the development team and the management to assign handling priority to work according to its urgency.
If classes of service are used properly and combined with a regular delivery cadence, very few complaints are likely to be received, even if a significant portion of items miss their target lead time. The most time critical work items will be prioritized ahead and should be delivered on time.
Classes of service enable a team to self-organize around the flow of work and free up management time to focus on the process and its performance (or capability).
Establishing Class of Service - Work items can be assigned to a class of service according to their business impact. Examples of class of service would be “fixed date”, “expedite”, or “standard”. It is typical to assign class of service based on impact and time-criticality. Items that incur high costs or lose value quickly will receive faster treatment via a higher class of service.
Setting policies - A set of management policies should be defined for each class of service. The policies should show which class of service is highest. For example, an “Expedite” class might always be prioritized ahead of a “Standard” class item. These policies will determine which work item to pull on a daily basis. Well defined and understood classes of service enable managers to trust that team members make appropriate risk decisions when selecting work.
Displaying on the card wall - Classes of service should be visually displayed by using, for example, different colored cards to represent the class of service or different horizontal swim lanes on the card wall.
Capacity Allocation - It is also possible and useful to allocate capacity within the kanban system to classes of service. It is helpful to set an allocation to make to ensure that items in the lower priority classes are completed. It is also generally helpful for the team and the management to specify allocation as an agreement of how their resources should be spent.

A card wall showing allocation by Class of Service
Predictability via Service Level Agreements (SLA)
A Service Level Agreement (SLA) should include the target lead time from when a work item enters the input queue to when it will be delivered. The SLA represents the promise to the customer for ae work item of a given type and class of service
Work items should be tracked and measured as they move from step to step through the system. Performance against the SLAs should be monitored and reported at operations review meetings. Process improvements should be made to improve predictability against the customer promise defined in the SLAs. SLAs should be matched to system capability, and the system improved to match with customer expectations and market demands.
What Next?
The best approach to working with the Kanban Method is to get started. It is not necessary to implement all 5 core principles initially. They can be introduced gradually and adjusted to match the needs of the organization and its culture.
There are books, blogs, mailing lists and conferences dedicated to kanban and lean. Some of the best resources are located at kanban101.com, limitedwipsociety.org & leanssc.org.
Kanban Book and Website
“Kanban” by David J. Anderson is the 250-page definitive guide to Kanban as a change management system for software development. It explains what Kanban is, why it is used, and how to implement it.
“Kanban”is available at major online book retailers and also at channelkanban.com.
About The Authors

By David J. Anderson
David J. Anderson leads a management consulting firm focused on improving performance of technology companies. He has been in software development for 26 years and has managed teams on agile software development projects at Sprint, Motorola, Microsoft and Corbis. David is credited with the first implementation of a kanban process for software development in 2005. David was a founder of the agile movement through his involvement in the creation of Feature Driven Development. He was also a founder of the APLN, a founding signatory of the Declaration of Interdependence, and a founding member of the Lean Software and Systems Consortium. He moderates several online communities for lean/agile development. He is the author of the books “Kanban - Successful Evolutionary Change for Your Technology Business” and “Agile Management for Software Engineering - Applying the Theory of Constraints for Business Results”. David has worked to create a synergy of the CMMI model for organizational maturity with Agile and Lean methods through projects with Microsoft and the SEI. He is based in Seattle, Washington, USA.

Janice Linden-Reed
Janice Linden-Reed is a Lean-Agile Certified Scrum Master. Janice has 20 years of experience as a project manager, including over 4 years of agile, lean and kanban management work. She has worked with all sizes of software development organizations including large international teams. Janice has a particular interest in lean startups and teams making the transition to agile or lean. To help novice users, Janice created the Kanban101.com website. She has presented to agile groups on kanban fundamentals and on lean-agile transition topics. Janice is an Associate with David J. Anderson and Associates, Inc. She was an organizer for the Lean and Kanban conference as well as the Lean Software and Systems Conference. She actively manages multiple distributed teams as a CSM.
Recommended Book
Order the definitive guide to Kanban. The Kanban Method will improve your existing development process. This book explains why and shows you how to get started using it right now. Case studies and illustrations make it easy to adopt the improvements you need for your unique situation.
BUY NOW

David J. Anderson is the man behind the Kanban method for software development. He has been in software development for 28 years.
Janice Linden-Reed has 20 years of experience as a project manager, including over 4 years of agile, lean and kanban management work.
your friends & followers...
DZone greatly appreciates your support.
Your download should begin immediately.
If it doesn't, click here.
Agile Adoption
Improving Software Quality
By Gemba Systems
20,201 Downloads · Refcard 74 of 151 (see them all)
Download
FREE PDF
The Essential Agile Adoption Cheat Sheet
People who downloaded this DZone Refcard also liked:
Agile Adoption: Improving Software Quality
By Shashank Tiwari
About Improving Software Quality
Faster, better, cheaper. That's what we must do to survive. The Time to Market Refcard addresses faster, the Reduce Cost Refcard addresses cheaper, and this Refcard addresses better. This is about improving the quality of your software; that means reducing bugs and improving design.
The vast majority of software projects suffer from a steady degradation of design quality and it becomes more and more difficult to maintain the software with the same level of quality. As the software ages it calcifies and becomes harder and harder to maintain. In some cases it becomes too expensive to maintain and so it the software is put to rest and rewritten. In others, the software is released with a steadily increasing number of defects. Both of these common situations are deeply unsatisfying, but there is another way.
Many of the practices from the Agile world stop the degradation of software quality and turn the trend around. It is not unheard of for teams to have maintained a zero-defect status for months and years. Design and architecture have become malleable; they now emerge and transform over time. In fact, Gartner now recommends an emergent approach to enterprise architecture (http://www.gartner.com/it/page.jsp?id=1124112).
Figure 1 Practices that help improve the quality that your software development team(s) builds.

Figure 1: Improve Quality Practices
You will be able to use this refcard to get a 50,000 ft view of what will be involved to incrementally improve the quality of your software.
Strategies for improving quality
The Agile community has been fertile ground for quality improvements in software development.
There are four major strategies that can help you improve the quality of your software:
Reduce Defects

Reducing defects is the first thing that comes to mind when examining the quality of software. A low defect count is often synonymous with high quality software. Defects are also the most visible sign of quality problems.
Improve Design

Design is the model that a development team builds and maintains. High quality design makes for an application that is easy to understand and change as new requirements are discovered. Traditionally, the team has one shot to get the design right and then it degrades over time as it is patched over time. Agile practices, however, give an alternative; using practices like test driven development and refactoring teams are now able to continuously improve the design of their system.
Theory Building

One way to look at software development is 'theory building'. That is, programs are theories models of the world mapped onto software in the head of the individuals of the development team. Great teams have a shared understanding of how the software system represents the world. Therefore they know where to modify the code when a requirement change occurs, they know exactly where to go hunting for a bug that has been found, and they communicate well with each other about the world and the software.
Conversely, a team that does not have a shared 'theory' makes communication mistakes all the time. The customer may say something that the business analyst misunderstands because she has a different worldview. She may, in turn, have a different understanding than the developers, so the software ends up addressing a different problem or, after several trials, errors and frustrations, the right problem but very awkwardly. Software where the theory of the team does not match, or even worse, the theory is now lost because the original software team is long-gone, degrades in quality as design changes are made that don't fit with the theory, or even just as bad, cut & paste work is done because the theory is not understood. Building a shared theory of the world-to-software-mapping is a human process that is best done face-to-face by trial and error with ample time.
Build Less

It has been shown that we build many more features than are actually used. In fact, we can see in Figure 2 that most functionality we do build is never used. So, one very effective way to improve the quality of our software is to build less of it. It makes it easier to understand, gives us more time to focus on the important parts that are actually used, and almost always has fewer defects.

Figure 2: Functionality Usage, only about 20% of functionality we build is used often or always. More than 60% of all functionality built in software is rarely or never used! One way to improve the quality of software is to write less code which makes it easier to understand and maintain. There are several Agile practices that help you get to that point.
The four strategies above: maintain the theory of the code, build less, building less and improving the design are not independent.

Figure 3: Strategy Dependencies
Maintaining the theory of the code makes it easier to modify the design because of a greater understanding of the existing design and also directly affects the number of defects and the difficulty in fixing those defects once found. Improving the design also makes it easier address defects by being inherently easier to change. And building less code makes it easier to understand and communicate the theory of the code and is directly related to the number of defects in the system.
The Practices

| Test Driven Development
|
|
| Test Driven Development is an effective cluster of practices that brings automated developer tests to the forefront of development and subordinates the design to testability. | |
| This form of development produces loosely-coupled designs which are easy to maintain, greatly reduce defect counts, and enable building and maintaining only what's needed. Finally, well-written tests act as a type of executable requirements that help keep the theory of the code from decaying. | |
| You are on a development team practicing automated developer tests, refactoring, and simple design. That's it, because this is one of those things that is applicable to all types of development projects. The context is especially a match if the technology used is new to a large part of the team. | |
![]()
| Test Driven Requirements
|
|
| Test Driven Requirements call for the customer to provide requirements in an unambiguous format, usually an acceptance test, at the beginning of the iteration. | |
| Test driven requirements drive the architecture of the system much like test driven development drives the design. They also help developers only build what is needed and maintain the theory of the code as up-todate executable requirements. | |
| Test driven requirements needs a customer who is willing and able to participate more fully as part of the development team. Your team will also be willing to make difficult changes to the code to accommodate for testing. Finally, you are willing to pay the steep price of the learning curve for this practice (which is well worth it). | |

| Done State
|
|
| The Done State practice is a definition that a team agrees upon to precisely describe what must take place for a requirement to be considered complete. | |
| Defining and adhering to a done state directly affects the quality of the software by reducing defects. A properly defined done state is as close as possible to deployable software which means that defects are removed to achieve the done state. There is no partial credit with done state, either you are 100% done or you are 0% done; this mindset is crucial to successfully implementing this practice. | |
| You are on a development team performing iterations; this implies that you need specific, measurable goals for requirements to be met at the end. Alternatively, you may not be performing iterations and have a high rate of defects. You can agree on a done state to be met for each and every requirement and still gain the benefits of improved quality. | |
| Automated Developer Tests
|
|
| Automated developer tests are a set of tests that are written and maintained by developers to reduce the cost of finding and fixing defectsthereby improving code qualityand to enable the change of the design as requirements are addressed incrementally. | |
| Automated developer create a safety-net of tests that catch bugs early and enable the incremental improvement of design. Beware, however, that automated developer tests take time to build and require discipline. | |
| You are on a development team that has decided to adopt iterations and simple design and will need to evolve your design as new requirements are taken into consideration. Or you are on a distributed team. The lack of both face-to-face communication and constant feedback is causing an increase in bugs and a slowdown in development. | |
| Automated Acceptance Tests
|
|
| Automated acceptance tests are tests written at the beginning of the iteration that answer the question: "What will this requirement look like when it is done?" This means that you start with failing tests at the beginning of each iteration and a requirement is only done when that test passes. | |
| This practice builds a regression suite of tests in an incremental manner and catches errors, miscommunications, and ambiguities very early on. This, in turn, reduces the amount of work that is thrown away and therefore enables building less. The tests also catch bugs and act as a safety-net during change. Finally, by making the codebase testable, you are implicitly reducing the coupling which often result in improved design. | |
| You are on a development project with an onsite customer who is willing and able to participate more fully as part of the development team. Your team is also willing to make difficult changes to any existing code. You are willing to pay the price of a steep learning curve. | |
| Refactoring
|
|
| The practice of Refactoring code changes the structure (i.e., the design) of the code while maintaining its behavior. | |
| Incremental improvement of design is the name of the game with refactoring; continuous refactoring keeps the design from degrading over time, ensuring that the code is easy to understand, maintain, and change. | |
| You are on a development team that is practicing automated developer tests. You are currently working on a requirement that is not wellsupported by the current design. Or you may have just completed a task (with its tests of course) and want to change the design for a cleaner solution before checking in your code to the source repository. | |
| Pair Programming
|
|
| Two developers work together at the same computer to build a feature. One developer is the driver, and the other is the navigator; the driver is at the keyboard building the task-at-hand, and the navigator is thinking forward to design implications and reviewing the work being done. Pair programming is sometimes described as a continuous form of peer review. | |
| This practice improves the design and reduces the defects because two people working together to solve the same problem almost always do a better job even if they are mismatched in experience and talent. Also, because they build the software together, the theory of the code is communicated to more than one person. | |
| Your are on a development team where quality is near the top in business values or you are going through a period of adopting some of the more difficult practices such as test driven development. You have the ability to trade off some development speed for quality. | |
The remaining practices also help improve the quality software development. Because of the limited size of the Refcard, we will only summarize them below.
| Continuous Integration |
Continuous integration reduces the defects in a software system by catching errors early and often and enabling a stop-and-fix process. It leverages both automated acceptance tests and automated developer tests to give frequent feedback to the team and prompts removing these defects promptly. |
| Collective Code Ownership |
Collective code ownership means that members of a development team have the right and responsibility to modify any part of the code. They get more exposure to the entire code base and are able to remove defects wherever they are found and incrementally modify the design of the system accordingly. |
| Evolutionary Design |
Evolutionary design is the simple design practice (below) done continuously. Teams start off with a simple design and change that design only when a new requirement cannot be met by the existing design. |
| Iteration |
An iteration is a time-box where the team builds what is on the backlog and is a potential release and therefore enables building less and forces regularly removing defects to reach the agreed upon done state. |
| Release Often |
Releasing your software to your end customers as often as you can without inconveniencing them forces you to constantly have your software in releasable quality and allows you to build in smaller increments and get feedback before too much of an investment is made. |
| Simple Design |
If a decision between coding a design for today's requirements and a general design to accommodate for tomorrow's requirements needs to be made, the former is a simple design. Simple design meets the requirements for the current iteration and no more. In fact, Gartner now recommends an emergent approach to enterprise architecture (http://www.gartner.com/it/page.jsp?id=1124112). |
| Stand Up Meeting |
Stand up meetings are daily meetings for the team to synch-up and share progress and impediments daily. This helps keep the entire team aware of what is being done and where in the system. |
How to adopt agile practices success fully
To successfully adopt Agile practices let's start by answering the question "which ones first?" Once we have a general idea of how to choose the first practices there are other considerations. Then, once you've chosen the first practices that best fit your environment, you and your team(s) will need to be aware of the mindset you'll need to get the most out of the practices you choose.
Choosing a Practice to Adopt
Choosing a practice comes down to finding the highest value practice that will fit into your context. Figure 4 contains practices that help improve the quality that your software development team(s) builds. Figure 4 will also guide you in determining which practices are most effective in increasing the quality of your software and will also give you an understanding of the dependencies. The other parts in this section discuss other ideas that can help you refine your choices. Armed with this information:
Figure 4: Steps for Choosing and Implementing Practices
For improving quality, the set of practices that will give you the most value are those nearest the top of Figure 1. Four of the practices are independent: done state, automated developer tests, automated acceptance tests, and pair programming. Consider adopting pair programming as a support practice to the other three practices, then take them on one or two at a time. Next on your list (or maybe even concurrent) to consider should be done state and automated developer tests, and then finally automated acceptance test (probably the most difficult of this set to adopt correctly).
The Mindset
Be Disciplined, Confront Issues, Respond Positively to Pain
The practices involved in improving the quality to market are some of the most difficult to do from the body of Agile practices. Things will get harder before they get easier. The first rule is to expect the difficulty, be patient, and don't stop the practices just because they uncover significant problems; be disciplined in your practice. Once you start a practice give it a chance because you will slow down and confront frustrations before speeding up. For example, pair programming is frequently seen as a waste of resources and uncomfortable to many developers who are used to (and enjoy) working alone. Consider giving it a chance by agreeing as a team to practice pair programming for a couple of months before deciding whether it is worth adopting permanently.
Figure 5: Learning Curve
Figure 5 The J-curve is what to expect when adopting new practices. First things will be hard and you will be less productive; stay with it and it will improve.
Confront issues when they come up instead of stopping a practice because it is 'too painful'. Deal with pain differently than you are used to; instead of discontinuing something painful, examine it and find the source. Often Agile practices will uncover problems that have always been there but have not been felt. Feeling the pain is a chance to correct a problem and improve towards your goal of increased quality. A good example of this happens when teams start adopting done states for the first time. There is no partial credit, either you are 100% done or 0% done. A team that adopts this for the first time frequently works on multiple features at a time and at the end of the iteration they have not fully completed any of the features. Therefore they are 0% done with all of their tasks. This is discouraging and painful and a common response is to stop doing the practice instead of examining the pain and looking for alternatives to correct the problems in the next iteration.
Get Good at Small Steps
Small steps are going to save your life with these practices because many are completely new ways of doing things that may slow you down and frustrate you as you are learning them. Take one practice, do it well, and do it regularly. You might consider pair programming along with any and all of the practices to make it easier and keep you on-track. How do you know you are doing a practice well? You get the value that you originally hoped to get - i.e. the quality of your software noticeably increases. You also have confronted pains and learned from them. If a practice is completely easy and comfortable from the get-go, or has not noticeably improved the quality of your work then you probably are not done yet.
Be Prepared to "Suspend Your Disbelief"
Much of what you will be doing will not make immediate sense. It will feel that you are doing things that are more trouble than they are worth. For example writing your tests first, before writing your code in the automated developer tests practice is non-intuitive. What can you possibly gain by doing things backward? Those who have successfully adopted this practice have "suspended their disbelief" and done it anyway. After experientially learning the practice they then made their judgments about its utility and usually kept doing it because they saw the value.
Know What You Don't Know
The Dreyfus Model of Skill Acquisition, is a useful way to look at how we learn skills such as learning Agile practices necessary to improve quality. It is not the only model of learning, but it is consistent, has been effective, and works well for our purposes. This model states that there are levels that one goes through as they learn a skill and that your level for different skills can and will be different. Depending on the level you are at, you have different needs and abilities. An understanding of this model is not crucial to learning a skill; after all, we've been learning long before this model existed. However, being aware of this model can help us and our team(s) learn effectively.
So let's take a closer look at the different skill levels in the Dreyfus Model:
Figure 6 The Drefyus Model for skill acquisition. One starts as a novice and through experience and learning advances towards expertise.
How can the Dreyfus Model help in an organization that is adopting agile methods? First, we must realize that this model is per skill, so we are not competent in everything. Secondly, if Agile is new to us, which it probably is, then we are novices or advanced beginners; we need to search for rules and not break them until we have enough experience under our belts. Moreover, since everything really does depend on context, and we are not qualified to deal with context as novices and advanced beginners, we had better get access to some people who are experts or at least proficient to help guide us in choosing the right agile practices for our particular context. Finally, we'd better find it in ourselves to be humble and know what we don't know to keep from derailing the possible benefits of this new method. And we need to be patient with ourselves and with our colleagues. Learning new skills will take time, and that is OK.
What Next?
This Refcard is a quick introduction to Agile practices that can help you improve the quality of your software by reducing defects, improving design, sharing the theory of the code and building less. It includes an introduction of how to choose the practices for your organizational context. It is only a starting point. If you choose to embark on an Agile adoption initiative, your next step is to educate yourself and get as much help as you can afford. Books and user groups are a beginning. If you can, find an expert to join your team(s). Remember, if you are new to Agile, then you are a novice or advanced beginner and are not capable of making an informed decision about tailoring practices to your context.
References
| Astels, David. 2003. Test-driven development: a practical guide. Upper Saddle River, NJ: Prentice Hall. | x | x | ||||||||||||
| Avery, Christopher, Teamwork is an Individual Skill, San Francisco: Berrett-Koehler Publishers, Inc., 2001 | x | |||||||||||||
| Bain, Scott L., 2008, Emergent Design, Boston, MA: Pearson Education | x | x | x | x | ||||||||||
| Beck, Kent. 2003. Test-driven development by example. Boston, MA: Pearson Education. | x | x | ||||||||||||
| Beck, K. and Andres, C., Extreme Programming Explained: Embrace Change (second edition), Boston: Addison-Wesley, 2005 | x | x | x | x | x | x | x | x | ||||||
| Cockburn, A., Agile Software Development: The Cooperative Game (2nd Edition), Addison-Wesley Professional, 2006. | x | |||||||||||||
| Cohn, M., Agile Estimating and Planning, Prentice Hall, 2005. | x | x | ||||||||||||
| Crispin, L. and Gregory, J., Agile Testing: A Practical Guide for Testers and Agile Teams | x | |||||||||||||
| Duvall, Paul, Matyas, Steve, and Glover, Andrew. (2006). Continuous Integration: Improving Software Quality and Reducing Risk. Boston: Addison-Wesley. | x | x | x | x | x | |||||||||
| Elssamadisy, A., Agile Adoption Patterns: A Roadmap to Organizational Success, Boston: Pearson Education, 2008 | x | x | x | x | x | x | x | x | x | x | x | x | x | x |
| Fowler, Martin. 1999. Refactoring: Improving the Design of Existing Code. Boston: Addison-Wesley. | x | x | x | x | ||||||||||
| Feathers, Michael. 2005. Working effectively with legacy code. Upper Saddle River, NJ: Prentice Hall. | x | x | x | x | x | |||||||||
| Jeffries, Ron. "Running Tested Features." http://www.xprogramming.com/xpmag/jatRtsMetric.htm. | x | x | x | |||||||||||
| Jeffries, Ron. 2004. Extreme programming adventures in C#. Redmond, WA: Microsoft Press. | x | x | x | x | x | x | ||||||||
| Kerievsky, Joshua. "Don't Just Break Software, Make Software." http://www.industriallogic.com/papers/storytest.pdf . | x | x | x | |||||||||||
| Larman, C., Agile and Iterative Development: A Manager's Guide, Boston: Addison-Wesley, 2004 | x | x | x | x | ||||||||||
| Larman, C., and Vodde, B., Scaling Lean and Agile Development, Boston: Addison-Wesley, 2009 | x | x | x | x | x | x | ||||||||
| Martin, Robert C., Clean Code: A Handbook of Agile Software Craftsmanship, Upper Saddle River, NJ: Pearson Education. 2008. | x | x | x | x | x | x | x | |||||||
| Massol, Vincent. Junit in action. Greenwich, CT: Manning Publications. 2004. | x | |||||||||||||
| Meszaros, XUnit Test Patterns: Refactoring Test Code, Boston: Addison-Wesley, 2007. | x | x | ||||||||||||
| Mugridge, R., and W. Cunningham. Fit for Developing Software: Framework for Integrated Tests. Upper Saddle River, NJ: Pearson Education. 2005. | x | x | x | x | ||||||||||
| Poppendieck, M., and Poppendieck, T., Implementing Lean Software Development, Addison-Wesley Professional, 2006. | x | x | x | x | x | x | ||||||||
| Rainsberger, J.B. 2004. Junit recipes: Practical methods for programmer testing. Greenwich, CT: Manning Publications. | x | |||||||||||||
| Schwaber, K., and Beedle, M., Agile Software Development with Scrum, Upper Saddle River, New Jersey: Prentice Hall, 2001. | x | x | x | x | x | x |
About The Author
Gemba Systems
Gemba Systems is comprised of a group of seasoned practitioners who are experts at Lean & Agile Development as well as crafting effective learning experiences. Whether the method is Scrum, Extreme Programming, Lean Development or others - Gemba Systems helps individuals and teams to learn and adopt better product development practices. Gemba Systems has taught better development techniques - including lean thinking, Scrum and Agile Methods - to thousands of developers in dozens of companies around the globe. To learn more visit http://us.gembasystems.com/
Recommended Book
Agile Adoption Patterns will help you whether you're planning your first agile project, trying to improve your next project, or evangelizing agility throughout your organization. This actionable advice is designed to work with any agile method, from XP and Scrum to Crystal Clear and Lean. The practical insights will make you more effective in any agile project role: as leader, developer, architect, or customer.

Gemba Systems is comprised of a group of seasoned practitioners who are experts at Lean & Agile Development as well as crafting effective learning experiences.
your friends & followers...
DZone greatly appreciates your support.
Your download should begin immediately.
If it doesn't, click here.
Scrum
By Michael James
38,779 Downloads · Refcard 50 of 151 (see them all)
Download
FREE PDF
The Essential Scrum Cheat Sheet
People who downloaded this DZone Refcard also liked:
Getting Started with Scrum
By Michael James
About Scrum
Scrum is a simple management framework for incremental product development using one or more cross-functional, selforganizing teams of about seven people each.
Scrum teams use fixed length iterations, called Sprints, typically two weeks or 30 days long. They attempt to build a potentially shippable (properly tested) product increment every iteration.
An Alternative to Waterfall
Scrum’s incremental, iterative approach trades the traditional phases of “waterfall” development for the ability to develop a subset of high-business value features first, incorporating user feedback sooner.
Figure 1: Traditional “waterfall” development assumes perfect understanding of requirements at outset.

Figure 2: Scrum blends all development activities into every iteration, adapting to discovered realities at fixed intervals.
Scrum has been used for a variety of products, but has initially been most popular for software products using object-oriented technologies. It is particularly suited to high risk endeavors where traditional efficiency concerns are secondary to the ability to deliver the right product, or any product, by the required date.
A Disruptive Framework to Transform Organizations
The reality checks forced by the short feedback loops are intended to expose dysfunction at the individual, team, and organizational level. Rather than modify Scrum to mask these dysfunctions, organizations are encouraged to challenge these constraints and transform themselves.
Scrum is a framework, not a defined process or methodology. Scrum provides a simple structure of roles, meetings, rules, and artifacts1. Scrum teams are responsible for creating and adapting their processes within this framework. Scrum’s management practices are similar to those of eXtreme Programming (XP), but, unlike XP, Scrum does not prescribe specific engineering practices.
Scrum Roles
Product Owner
The Product Owner is the single individual responsible for return on investment (ROI) of the product development effort. The Product Owner owns the product vision, constantly re-prioritizes the Product Backlog, and revises release plan expectations. The Product Owner is the final arbiter of requirements questions, including which items are considered “done” at the Sprint Review Meeting.
Scrum Development Team
The Team is a self-organizing/-managing group of about seven (give or take two) individuals. While the Team may contain specialists, collectively it is cross-functional, containing the range of skills (including testing) which were traditionally found in different departments. The Team is given autonomy regarding how to achieve the commitments they’re held responsible for between the Sprint Planning and Sprint Review meetings.
A Scrum Development Team is most likely to succeed when members are co-located in a team room.
ScrumMaster
The ScrumMaster facilitates the Scrum process, keeps the Scrum artifacts visible, facilitates Team self-organization (keeping it in the “zone”), helps resolve impediments (at the team level and organizational level), shields the team from interference, and advocates improved engineering practices2.
The ScrumMaster does these things (and more) without any authority on the Team. The ScrumMaster does not make business decisions or technical decisions, does not commit to work on behalf of the Team, etc.
Scrum Meetings
All Scrum Meetings are facilitated by the ScrumMaster, though he has no decision-making authority at these meetings.

Figure 3: Scrum Meetings
Sprint Planning Meeting
Part 1: At the beginning of each iteration, the Product Owner and Team negotiate which Product Backlog Items the Team will attempt this Sprint. The Product Owner is responsible for declaring which items are the most important to the business, and the Team is responsible for committing to the amount of work they feel they can accomplish without accruing technical debt.
Part 2: The Team decomposes the selected Product Backlog Items into an initial list of Sprint Tasks and makes a final commitment to do the work. The Product Owner’s full attendance is often not necessary during Part 2. The maximum time for planning a 30-day Sprint is 8 hours.
Daily Scrum
Every day, at the same time and place, the Scrum Development Team members spend 15 minutes reporting to each other. Each team member reports to the rest of the team what he did the previous day, what he will do today, and what impediments he has.
The team will typically examine the current Sprint Task list, Sprint Burndown Chart, and impediments list.
The Product Owner’s attendance is often not necessary at the Daily Scrum and may actually impede team self-organization.
Topics that require additional discussion may be handled as optional sidebars after every team member has reported. It’s a common practice to stand at this meeting to create a sense of urgency, so it’s sometimes called the “standup meeting.”
Reporting to an entire team, rather than to a boss, is one of the new habits Scrum team members learn.
Sprint Review Meeting
At the end of each Sprint execution, the Team demonstrates the actual working product increment they built to the Product Owner and other stakeholders. The Product Owner declares which committed items will be considered “done” according to the previously negotiated agreement. Incomplete items are returned to the Product Backlog as candidates for future Sprints. Feedback from stakeholders is converted to new Product Backlog Items.
The Sprint Review Meeting is an opportunity to inspect and adapt the product as it emerges and iteratively refine the understanding of the requirements. New products, particularly software products, are hard to visualize in a vacuum. Many customers need to be able to react to a piece of functioning software to discover what they actually want.
Sprint Retrospective
At the end of every Sprint, the team meets to reflect on its own process. They inspect their own behavior and take action to adapt it for future Sprints. This meeting provides an inspectand- adapt mechanism for the team’s process.
Techniques ScrumMasters can use to facilitate retrospectives3 include silent writing, timelines, satisfaction histograms, and many others. Common topics include: “What went well?”; “What could be improved?”; “What did we learn?”; “What still puzzles us?”; “What actions will we take?”
As with the Daily Scrum, the team may choose to invite the Product Owner. Candid communication will help the team gain common understanding of multiple perspectives and come up with actions that will take the team to the next level.
Backlog Refinement Meeting
The team estimates the effort of items in the Product Backlog so the Product Owner can prioritize them before the next Sprint Planning Meeting. Large, vague items are split and clarified. New stories might be written by a subset of the team, in conjunction with the Product Owner and other stakeholders, before involving the entire team in estimation.
This meeting lacks an official name, thus may also be called “Backlog Maintenance,” “Backlog Grooming,” “Backlog Estimation Meeting,” etc.

Figure 4: Product Backlog
Product Backlog
- Force-ranked list of desired functionality
- Visible to all stakeholders
- Any stakeholder (including team) can add items
- Constantly re-prioritized by Product Owner
- Items at top are more granular than items at bottom
- Maintained during Backlog Refinement Meeting
Product Backlog Item (PBI)
- Specifies the WHAT, not the HOW, of a customercentric feature.
- Often written in “User Story” form
- Has acceptance criteria (and/or product-wide definition of “done”) to prevent technical debt
- Effort is estimated by Team, ideally in relative units (e.g. story points)
- Business value is estimated by Product Owner

Figure 5: Each PBI represents a customer-centric feature, usually requiring several tasks to achieve definition of done.

Figure 6: Large PBIs (often called “epics”) split into thin vertical feature slices (“stories”), not horizontal implementation phases, when they rise toward the top of the Product Backlog.

Figure 7: The Sprint Backlog is often represented on an “information radiator” such as a physical task board.
Sprint Backlog
- Committed PBIs negotiated between Team and Product Owner during Sprint Planning Meeting
- Scope Commitment is fixed during Sprint Execution
- Initial tasks created by Team during Sprint Planning Meeting, and expected to change during Sprint Execution
- Visible to Team (primarily)
- Referenced during Daily Scrum Meeting

Figure 8: The Sprint Backlog may also be represented electronically in a collaboration tool such as ScrumWorks® Pro. This tool’s electronic task board mimics the cards of a physical task board.
Sprint Task
- Specifies “how” to achieve the PBIs’ “what”
- About one day or less of work
- Remainig effort re-estimated daily, typically in hours
- Task point person volunteers to see that it gets done, but commitment is owned by entire team and collaboration is expected

Figure 9: Sprint Burndown Chart
Sprint Burndown Chart
- Total remaining team task hours within one Sprint
- Re-estimated daily, thus may go up before going down
- Intended to facilitate team self-organization, not a management report
- Fancy variations, such as itemizing by point person, tend to reduce effectiveness at encouraging collaboration

Figure 10: A Release Burndown Chart variation popularized by Mike Cohn4. The red line tracks PBIs completed over time (velocity), while the blue line tracks new PBIs added (new scope discovery). The intersection projects release completion date from empirical data5.
Product/Release Burndown Chart
- Tracks remaining Product Backlog effort from one Sprint to the next
- May use relative units such as “Story Points” for Y axis
- Depicts empirical trends, introducing reality check to Product Owner’s release plan
Scaling
Scrum addresses uncertain requirements and technology risks by grouping people from multiple disciplines into one team, ideally in one team room, to maximize communication bandwidth, visibility, and trust.
When requirements are uncertain and technology risks are high, adding too many people makes things worse.
Traditional practices of grouping people by specialty or architectural component can also make things worse. Typical

Figure 11: Communicaton pathways increase geometrically with team size.
problems include messy team interdependencies, late discovery of integration risks (being “90% done 50% of the time”), and poor alignment of effort with business value.
A more successful approach has been fully cross-functional “feature teams,” able to operate at all layers of the architecture, and across components if necessary6.

Figure 12: Cross-functional teams organized around related features
Rather than get all aspects of a component working first, a feature team focuses on thin user-centric slices of functionality that cut through multiple architectural layers or physical components.
Since multiple feature teams risk stepping on each other’s work, it’s wise to get practices of continuous integration (with robust test coverage enforced through a product-wide definition of “done”) established by one feature team before adding other teams.
Multiple teams coordinate with each other in a variety of ways, including sending delegates to each other’s meetings or to central “Scrum of Scrums” meetings. Individuals working on particular components may form informal working groups with their counterparts on other feature teams. They are primarily responsible to their feature teams, however.
Organizations seeking to scale Scrum are advised to pursue training, coaching, and to examine previous case studies.
Related Practices
Scrum is a general management framework coinciding with the agile movement in software development, which is partly inspired by Lean manufacturing approaches such as the Toyota Production System. Scrum has been popularized by people like Ken Schwaber, organizations like the Scrum Alliance, and companies like Danube Technologies, Inc.
Unlike eXtreme Programming (XP), Scrum does not prescribe specific engineering practices.
Scrum focuses on incrementally improving the definition of “done” (particularly around testing) before work is demonstrated. This can motivate the team to adopt engineering practices associated with XP and now proven to reduce technical debt: Continuous Integration (continuous automated testing), Test Driven Development (TDD), constant refactoring, pair programming, frequent check-ins, etc.

Figure 13: The green line represents the general goal of agile methods. Doing Scrum properly entails incrementally improving the definition of “done” to prevent technical debt. 7
When is scrum appropriate?
Defined Processes vs. an Empirical Framework
Teams applying Scrum rigorously (as intended by this author) may find themselves questioning traditional “best practices.”
The expectation of a working product demonstrated early and often, combined with frequent retrospection, leads teams to challenge assumptions from respected sources such as the Project Management Institute’s Project Management Body of Knowledge (PMBOK®), existing waterfall habits, and more prescriptive processes for iterative development such as IBM’s Rational Unified Process (RUP). Scrum teams may even question agile practices such as eXtreme Programming (XP).

Figure 14: Scrum is intended for the green space labeled as “Chaotic” above. 8 9
The disruption of introducing Scrum is not always advisable when defined processes could meet the needs. Ken Schwaber has said, “If waterfall suits current needs, continue using it.” Consider whether the underlying mechanisms are well understood. Scrum was not originally intended for repeatable types of production and services.
Scrum is intended for the kinds of work defined processes have often failed to manage: uncertain requirements combined with unpredictable technology implementation risks. These conditions usually exist during new product development.
Challenges and Opportunities of Team Self-Organization
This author has seen self-organizing teams radically outperform larger, more experienced, traditionally managed teams. Familysized groups naturally self-organize when they are committed to clear, short-term goals, all members can gauge the group’s progress, and all members can observe each other’s contribution.
Psychologist Bruce Tuckman describes stages of group development as “forming, storming, norming, performing.”10 Optimal self-organization takes time, introducing a reasonable risk the team will perform worse during early iterations than it might have as a traditionally managed working group.
Research suggests heterogeneous teams outperform homogeneous teams when doing complex work, and they experience more conflict11. Disagreements are to be expected on a motivated team -- team performance will be determined by how well the team handles these conflicts.
“Bad apple theory” suggests a single negative individual (“withholding effort from the group, expressing negative affect, or violating important interpersonal norms”12) can disproportionately reduce performance of an entire group. Such individuals are rare, but their impact is magnified by a team’s reluctance to remove them. This can be partly mitigated by giving teams greater influence over who joins them.
Other individuals who underperform in a boss/worker situation (due to being under-challenged or micromanaged) will shine on a Scrum team.
Self-organization is hampered by conditions such as geographic distribution, boss/worker dynamics, part-time team members, and interruptions unrelated to sprint goals. Most teams will benefit from a full-time ScrumMaster, whose responsibilities include helping mitigate these kinds of impediments.
Scrum Education and certificates
Scrum is mainly an oral tradition conveyed through Certified ScrumMaster (CSM) courses. These are typically two-day events led by trainers who have been vetted by the Scrum Alliance13. The CSM credential does not prove proficiency. It is intended as a stepping stone toward Certified Scrum Practitioner (CSP), an indication of at least one year of experience doing Scrum. The Scrum Alliance also certifies Scrum Product Owners, coaches, and trainers.
References
- Agile Project Management with Scrum, Schwaber, Microsoft Press, 2004. See Appendix A “Rules.”
- http://danube.com/blog/michaeljames/a_scrummasters_checklist
- Agile Retrospectives: Making Good Teams Great, Derby/Larsen, Pragmatic Bookshelf, 2006
- Agile Estimating and Planning, Cohn, Prentice Hall PTR, 2005.
- Example generated by ScrumWorks® Basic, a free tool.
- Scaling Lean & Agile Development: Thinking and Organizational Tools for Large-Scale Scrum, Larman/Vodde, Addison-Wesley Professional, 2008.
- Graph inspired by Ron Jeffries lecture at http://www.infoq.com/news/2006/12/jeffries-running-tested-features
- Extensively modified version of a graph in Strategic Management and Organizational Dynamics, Stacey, 1993, referenced in Agile Software Development with Scrum, Schwaber/Beedle, 2001.
- Quote is from Process Dynamics, Modeling, and Control, Ogunnaike, Oxford University Press, 1992.
- “Developmental Sequence in Small Groups.” Psychological Bulletin, 63 (6): 384-99 Tuckman, referenced by Schwaber.
- Group Genius: The Creative Power of Collaboration, Sawyer, Basic Books, 2007.
- “How, when, and why bad apples spoil the barrel: Negative group members and dysfunctional groups.” Research in Organizational Behavior, Volume 27, 181–230, Felps/Mitchell/Byington, 2006.
- Scrum training/coaching also available from http://danube.com/
About The Author

Michael James
Michael James, Danube Technologies, Inc.
Michael is a software process mentor, team coach,
and Scrum trainer with a focus on the engineering
practices (TDD, refactoring, continuous integration,
pair programming) that allow agile project
management practices. He is also a recovering
“software architect” who still loves good design.
Many other articles from Michael can be found at
http://danube.com/blog/michaeljames
Danube Technologies, Inc. is a Scrum consulting and tools company.
Danube hosts hundreds of Certified ScrumMaster courses yearly around the
world. To find out more about ScrumMaster Certification see http://danube.
com/courses. Danube produces ScrumWorks Pro, the first commercial
tool designed specifically for Scrum. With more than 105,000 active users
worldwide, ScrumWorks is used by more than half of the Fortune 100 and
boasts the largest market share of any agile management tool. Learn more
at http://danube.com/scrumworks
Recommended Book
Danube’s ScrumMaster Certification Course The best way to get started with Scrum is through handson experience in a Danube ScrumCORE CSM course. Taught by Michael James and other experts with deep experience working in Scrum environments, Danube’s twoday course covers the fundamental principles, mechanics, and values of Scrum through a combination of simulated sprint activities and examples of real projects.
BUY NOW
For more information, visit:
http://www.danube.com/courses

Michael James is a software process mentor, team coach, and Scrum trainer with a focus on engineering practices (TDD, refactoring, CI, pair programming).
your friends & followers...
DZone greatly appreciates your support.
Your download should begin immediately.
If it doesn't, click here.
































