agile

  • submit to reddit

Getting Started with Lean Software Development

By Curt Hibbs , Steve Jewett and Mike Sullivan

16,799 Downloads · Refcard 93 of 151 (see them all)

Download
FREE PDF


The Essential Lean Development Cheat Sheet

Lean Software Development is an outgrowth of the larger Lean movement that includes areas such as manufacturing, supply chain management, product development, and office operations. Its goal is the same- to deliver value to the customer more quickly by eliminating waste and improving quality. This DZone Refcard covers the specific practices involved in 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.
HTML Preview
Getting Started with Lean Software Development

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.

Source Code Management Diagram

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.

Source Code Flow Diagram

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.

Hot Tip

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.

Hot Tip

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.

Automated Testing Flow Diagram

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.

Hot Tip

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.

CI Flow Diagram

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.

Hot Tip

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.

Course correction Diagram

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.

Hot Tip

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.

Hot Tip

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

Photo of author Curt Hibbs

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.

Photo of author Steve Jewett

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.

Photo of author Mike Sullivan

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

Art of Lean Software Development

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.


Share this Refcard with
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,903 Downloads · Refcard 54 of 151 (see them all)

Download
FREE PDF


The Essential Agile Adoption Cheat Sheet

Adopting Agile methods in your projects is easier than you think. This DZone Refcard series focuses on building software faster, better, and cheaper. This Refcard in particular teaches you four practical strategies for reducing the cost of software development. Learn how specific Agile methods like evolutionary design, refactoring and automated testing will help you reduce costs and eliminate risks. Other topics covered include how to adopt Agile practices successfully, as well as what’s next in Agile and a wealth of references. You’ll also enjoy Agile Adoption: Decreasing Time to Market, the first Refcard in this Agile Adoption series.
HTML Preview
JavaServer Faces 2.0

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.

reducecost

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

Brain

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!

Building

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.

Pie Chart

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

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.

Hand with money

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

Four Icons

Evolutionary Design

Evolutionary Design

Book 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.
Dollar Evolutionary design reduces the cost by focusing on always building less. This, in turn, directly affects the cost of change drastically.
Cubes 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

Evolutionary Design

Book 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.
Dollar 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.
Cubes 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

Diagram1

Book The practice of Refactoring code changes the structure (i.e., the design) of the code while maintaining its behavioe.
Dollar Costs are reduced because continuous refactoring keeps the design from degrading over time, ensuring that the code is easy to understand, maintain, and change.
Cubes 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

Icons

Book 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.
Dollar 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.
Cubes 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

Brain Small

Book 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.
Dollar 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.
Cubes 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

Diagram and icons

Book 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.
Dollar 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.
Cubes 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.

img1 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.
img2 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.
img3 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.
img4 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.
img5 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.
img6 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.
img7 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.
img8 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 3.2

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:

Pyramid

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

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

Column 1

Column 2

Column 3

Column 4

Column 5

Column 6

Column 7

Column 8

Column 9

Column 10

Column 11

Column 12

Column 13

Column 14

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

Maven

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.


Share this Refcard with
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,176 Downloads · Refcard 45 of 151 (see them all)

Download
FREE PDF


The Essential Agile Adoption Cheat Sheet

Agile methods are everywhere, but which one is the right fit for you and your business? What are the business values you want out of adopting Agile? This Dzone Refcard focuses on choosing the right Agile practices for your team or organization when getting to market faster is of prime importance. You’ll learn about the practices that are the building blocks of these methods- such as iterations, continuous integration, refactoring, automated developer tests, and many more.
HTML Preview
Agile Adoption:

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

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

Figure 2

*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.

Table 1.1 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”.
Table 1.2 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.
Table 1.3 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

Figure3

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

Diagram 1
Table 1.1 Release your software to your end customers as often as you can without inconveniencing them.
Table 1.2 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.
Table 1.3 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

Table 1.1 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.
Table 1.2 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.
Table 1.3 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

Backlog
Table 1.1 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.
Table 1.2 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.
Table 1.3 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

Table 1.1 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.
Table 1.2 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.
Table 1.3 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

Diagram 2
Table 1.1 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.
Table 1.2 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.
Table 1.3 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

Table 1.1 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.
Table 1.2 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.
Table 1.3 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

Figure4

*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.

Table 1.1 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.
Table 1.2 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.
Table 1.3 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

Figure5

*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.

Table 1.1 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.
Table 1.2 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.
Table 1.3 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

Table 1.1 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.
Table 1.2 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.
Table 1.3 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

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.1

Figure 4- Most functionality built is not used

Cross-Functional Team

Cartoon

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:

Pyramid Diagram

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:

Figure7

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

Collumn 2 Collumn 3 Collumn 4 Collumn 5 Collumn 6 Collumn 7 Collumn 8 Collumn 9 Collumn 10 Collumn 11
Astels, David. 2003. Test-driven development: a practical guide.
Upper Saddle River, NJ: Prentice Hall.
Pink Cross
Beck, Kent. 2003. Test-driven development by example. Boston, MA:
Pearson Education.
Blue Cross
Beck, K. and Andres, C., Extreme Programming Explained: Embrace
Change (second edition), Boston: Addison-Wesley, 2005
Pink Cross Pink Cross Pink Cross Pink Cross Pink Cross Pink Cross
Cockburn, A., Agile Software Development: The Cooperative Game
(2nd Edition), Addison-Wesley Professional, 2006.
Blue Cross
Cohn, M., Agile Estimating and Planning, Prentice Hall, 2005. Pink Cross
Duvall, Paul, Matyas, Steve, and Glover, Andrew. (2006). Continuous
integration: Improving Software Quality and Reducing Risk. Boston: Addison-Wesley.
Blue Cross
Elssamadisy, A., Agile Adoption Patterns: A Roadmap to
Organizational Success, Boston: Pearson Education, 2008
Pink Cross Pink Cross Pink Cross Pink Cross Pink Cross Pink Cross Pink Cross Pink Cross Pink Cross Pink Cross
Feathers, Michael. 2005. Working effectively with legacy code. Upper
Saddle River, NJ: Prentice Hall.
Blue Cross
Jeffries, Ron. “Running Tested Features.”
http://www.xprogramming.com/xpmag/jatRtsMetric.htm
Pink Cross
Jeffries, Ron. 2004. Extreme programming adventures in c#.
Redmond, WA: Microsoft Press.
Blue Cross
Kerievsky, Joshua. “Don’t Just Break Software, Make Software.”
http://www.industriallogic.com/papers/storytest.pdf
Pink Cross

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

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.


Share this Refcard with
your friends & followers...

DZone greatly appreciates your support.


Your download should begin immediately.
If it doesn't, click here.

Daily Dose: Mule's Integration PaaS Goes Beta

Mulesoft has announced the beta version of Mule iON, a cloud-based integration platform-as-a-service which allows developers to integrate and orchestrate services and applications whilst giving operations the visibility and control needed for important...

0 replies - 10744 views - 07/05/11 by Jim Moscater in Daily Dose

Daily Dose: Scala Moves From Subversion To Git Hub

In an unsurprising maneuver that seems to echo the strategies of many other projects, Scala has moved their repository from Subversion to Github. Some interesting responses we found on Hacker News:

0 replies - 10282 views - 06/14/11 by Jim Moscater in Daily Dose

Getting Started with Kanban for Software Development

By David J. Anderson and Janice Linden-Reed

18,587 Downloads · Refcard 109 of 151 (see them all)

Download
FREE PDF


The Essential Kanban Cheat Sheet

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. Kanban also gives more precise direction on how to invest development energy into only the most valuable work. This DZone Refcard provides you with an introduction to Kanban and how it can be used for Software Development. Learn about the Kanban Method and topics such as coordination practices, emergent behaviors, prioritization and more.
HTML Preview
Getting Started with Kanban for Software Development

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.

workflow

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.

worksheet2

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.

  1. Agree on a set of goals for introducing Kanban. What benefit do you want to see for your organization?
  2. Determine a set of unique types of customer valued work that flow through the organization, examples include bug, change request, or feature.
  3. Map the value creation network for different types of work. This will represent the underlying model of your system (see step 5).
  4. 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.
  5. 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.
  6. If there are different urgency criteria for the different work item types, define a class of service for each with relative priorities.
  7. 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.
  8. 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.
  9. 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.
  10. Optionally, create an electronic system to track and report the same.
  11. 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.
  12. 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.

allocation card

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.

allocation card2

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

Photo of author David J. Anderson

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.

Photo of author Janice Linden-Reed

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

Kanban

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.


Share this Refcard with
your friends & followers...

DZone greatly appreciates your support.


Your download should begin immediately.
If it doesn't, click here.

Get Started with Apache Ant!

Click here to download your free copy of our "Getting Started with Apache Ant" Refcard!  

0 replies - 16283 views - 06/28/10 by Lyndsey Clevesy in Announcements

Getting Started with Apache Ant

By James Sugrue

18,904 Downloads · Refcard 104 of 151 (see them all)

Download
FREE PDF


The Essential Apache Ant Cheat Sheet

Apache Ant is an XML based tool for automating software build processes. Today it is the most widely used build tool for Java projects, enabling developers to adopt Agile principles: most importantly test-driven development. This DZone Refcard will provide you with the perfect resource to help you automate software build processes with Apache Ant. The Refcard covers everything from a description of the Anatomy of an Ant Script along with a number of tables detailing, among others: Core Java Related Tasks, Infrastructure Tasks, and SCM Related Tasks.
HTML Preview
Getting Started with Apache Ant

Getting Started with Apache Ant

By James Sugrue

ABOUT APACHE ANT

Apache Ant is an XML based tool for automating software build processes. Starting out as part of the Apache Tomcat codebase, Ant got its first standalone release in July 2000. Today it is the most widely used build tool for Java projects, enabling developers to adopt agile principles: most importantly test-driven development.

Hot Tip

Download Instructions You can download the latest Ant distribution (1.8.1) as a standalone tool from http://Ant.apache.org/. Ant is also built into most Java development IDEs, such as Eclipse, and NetBeans which uses it as its internal build system.

The Anatomy of an Ant Script

A typical Ant script consists of a single build.xml file. The root element of the build script is the project tag. Within the project element there are one or more targets specified. A target contains a set of tasks to be executed.

The project element can specify a default target if no target is chosen during execution of the build script.

buildscript

Figure 1: The basic structure of an Ant build script.

The most important concept in Ant is that of dependencies. Each target may depend on other targets. When running, Ant resolves these dependencies so that your script gets executed in the order you have specified.

Attribute Description Required
name Name of the project. No
basedir Base directory from which all path calculations are done No
default The default target to run when no other target has been specified No

Table 1: Project element attributes

Attribute Description Required
name The name and identifier of this target Yes
depends Comma separated list of other targets that this target depends on No
if The name of a property which must be set for this target to run No
unless The name of a property which must not be set for this target to run No
description Description of this target No
extensionOf Add the target to the depends list of the named extension point No

Table 2: Target element attributes

Hot Tip

Extension Points Introduced in Ant 1.8.0 <extension-point> is similar to a <target> with its name and depends attributes. However, it does not contain any tasks and is used to collect targets that contribute to a state in the dependency relationships of the script.

Properties

Properties can be defined within the build script or in separate property files to provide more customizable build scripts.

Attribute Description Required
name Name of the property No
value The value of the property One of these when using name attribute
location Set value to absolute filename. If the value passed through is not an absolute path it will be made relative to the project basedir
refId Reference to an object defined elsewhere
file Location of the properties file When not using the name attribute (i.e. loading external properties)
resource Location in the classpath of the properties file
url URL pointing to properties file
basedir The basedir to calculate the relative path from No. Default is project basedir
classpath / classpathref The classpath to use when looking up a resource No
environment Prefix to use when accessing environment variables No
prefix Prefix to apply to properties loaded using file, resource or url No

Table 3: Property element attributes

All system properties that can be accessed from the System.getProperties() methods in Java can be used in Ant. Additionally, the following built-in properties are available:

Property Name Description
basedir Absolute path of projects basedir
ant.core.lib Absolute path of the ant.jar file
ant.file Absolute path of buildfile
ant.home Home directory of Ant
ant.java.version Java version detected
ant.project.default-target Name of the default target
ant.project.invoked-targets List of targets specified in the command line when invoking this project
ant.project.name Name of the project that is running
ant.version Version of Ant

Table 4: Built-in properties

Path Structures

Path structures can be created using a series of tags. For example, a classpath can be created using:


<classpath>
<pathelement location="/path/jarfile.jar"/>
<pathelement path="/path/lib/jar1.jar;/path/lib/jar2.jar"/>
</classpath>

File Sets

In order to bundle files together, Ant provides the <fileset> tag:

Property Name Description
casesensitive Whether include/excludes patterns must be treated with case sensitivity. Default true
dir Root of the directory tree of this fileset
defaultexcludes If default excludes should be used (set of definitions that are always excluded)
erroronmissingdir If true causes a build error, if false the fileset is ignored
excludes List of patterns of files to exclude
excludesfile Name of a file to exclude
file Shortcut for specifying a fileset containing a single file
followssymlinks Whether symbolic links should be followed. Default true

Table 5: Fileset attributes

Built-in Tasks

The following sections list out the most commonly used tasks in Ant build scripts. Required attributes are marked in bold.

Core Java Related Tasks

This section gives a complete reference of all tasks and their attributes that are most commonly used by Java Developers.

Compiling Java Code

Compilation is achieved with the <javac> task.

Attribute Description
srcdir Location of java files to compile
bootclasspath/ boothclasspathref Location of bootstrap class files or reference to a predefined path
classpath/ classpathref Classpath to use for compilation or reference to a predefined path
compiler Compiler implementation to use. Default is current VM
debug Whether source should be compiled with debug information (-g parameter). Defaults to off
debuglevel Can be lines, var or source. Used in the -g parameter for the compiler
depend Enables dependency tracking on jikes and classic compilers
deprecation Whether source should compile with deprecation information
destdir Destination for compiled .class files
encoding Encoding of source files
errorProperty Property to set to true if compilation fails
excludes Comma separated list of files that must be excluded from compilation. Wildcard patterns can be used
excludesFile File that contains the exclusion list
executable Path to javac executable to use when fork set to yes
extdirs Location of installed extensions
fork Whether to execute javac using the JDK compiler externally. Default no
failonerror Whether compilation error fails the build. Default true
includes Comma separated list of files that must be included in compilation. Wildcard patterns can be used
includeAntRuntime Whether to include ANT runtime libraries in the classpath. Default yes
includeDestClasses Whether classes compiled to the dest directory are included in the classpath. Default true. When false, causes recompilation of dependent classes
includesFile File containing the exclusion list
includeJavaRuntime Whether to include default libraries from VM.Default no
listfiles Whether source files to be compiled will be listed. Default no
memoryInitialSize / memoryMaximumSize Initial and maximum memory sizes for VM if run externally
nowarn Whether -nowarn should be used with the compiler. Defaults to off
optimize Whether to compile with optimization, ignored since JDK1.3
source Value of the -source command line switch
sourcepath/ sourcepathref Defaults to value of srcdir or reference to a predefined path
target Generate class files for a particular VM version
tempdir Temporary file location if fork set to yes
updatedProperty Property to set for successful compilation
verbose Use verbose output on the compiler

Table 6: javac tasks properties

Additional command line arguments can be passed through to the compiler using the <compilerarg> nested element.

Hot Tip

Compiler Choice To use different compilers set the build.compiler property to classic (1.1, 1.2) modern (1.3-1.6) or choose a separate compiler such as jikes, jvc, kjc, gcj or sj.

Class file dependencies can be managed using the <depend> task.

Attribute Description
srcdir Location of Java files to compile. Will be examined to determine which files are out of date
cache Directory where dependency information is stored and retrieved. No cache if not used
classpath Classpath from which dependencies also need to be checked
closure If true, all classes depending on an out-of-date class are deleted
destdir Location of class file to be analyzed
dump If true dependency info is written to the debug level log
warnOnRmiStubs Disables warnings about files that look like rmic generated stubs but no .java source

Table 7: Depend task properties

Hot Tip

Ivy For Dependency Management Ivy (http://ant.apache.org/ivy), a sub project of Ant, can also be used to manage dependencies.
Distributing Compiled Code

Jar files can be created using the task.

Attribute Description
destfile JAR file to create
basedir The directory to build from
compress Compress data in jar. Defaults true
createUnicodeExtraFields Whether to create unicode extra fields to store file names a second time inside the entry's metadata
defaultexcludes Whether default excludes should be used. Default true
duplicate Behavior when a duplicate file is found - add (default), preserve, fail
keepcompression For entries coming from other archives, keep its compression, overriding compress
encoding Character encoding for filenames. Default UTF8
excludes List of patterns of files to exclude
excludesfile The name of a file that defines an exclude pattern
fallbacktoUTF8 If the specified encoding cannot be used, whether to fallback to UTF8
filesonly Store only file entries. Default false
filesetmanifest Behavior for when a manifest is found in a zipfilesset. Can merge, mergewithoutmain or skip (default)
flattenAttributes Merge attributes occurring more than once in a section into one single attribute
includes List of patterns of files to include
includesfile The name of a file that defines an include pattern
index Whether to create an index list to speed up classloading. Default false
indexMetaInf Whether to include META-INF in the index. Default false
level Compression level for files from 0 (none) to 9 (maximum)
manifest Location of manifest for jar
manifestencoding Encoding to use for manifest. Default is platform encoding
mergeClassPathAttributes Merge classpath attributes of different manifests when merging
preserve0permissions If a file has permissions value of 0, it will preserve this instead of applying default values
roundup Whether to round up file modification time to the next even number of seconds
strict How to handle breaks of packaging version specification Fail, warn or ignore (default)
update Whether to overwrite files that already exist. Default false
useLanguageEncodingFlag Whether to set language encoding if encoding set to UTF8 only
whenmanifestonly Behavior when no files match - fail, skip or create (default)

Table 8: Jar task properties

Hot Tip

War and Ear Archive Tasks Both <war> and <ear> tasks have similar attributes to the <jar> task, adding in attributes for web.xml or application.xml respectively.

Additionally, you can sign jar archives using the <signjar> task.

Attribute Description
alias The alias to sign under
jar The jar file to sign
storepass The password for keystore integrity
executable Specific jarsigner executable to use in place of default in JDK
force Force signing if already signed or not out of date
internals Whether to include the .SF file inside signature block. Default false
keypass The password for the private key
keystore Keystore location
lazy Whether a signature file being present means the jar is signed
maxmemory Maximum memory the VM will use when signing
preservelastmodified Signed files keep the same modification time as original jar files
sectionsonly Whether to compute the hash of entire manifest
sigfile The name of the .SF or .DSA file
signedjar The name of the signed jar file
storetype The keystore type
tsacert Alias in keystore for timestamp authority
tsaurl URL for timestamp authority
verbose Whether to use verbose output. Default false

Table 9: Signjar task properties

Manifests can be included using the <manifest> task.

Attribute Description
file Manifest file to create or update
encoding Encoding to read existing manifest
flattenAttributes Merge attributes occurring more than once in a section into one single attribute
mergeClassPathAttributes Merge classpath attributes of different manifests when merging
mode Either update or replace (default)

Table 10: Manifest task properties

Generating Documentation

JavaDoc generation is done through the <javadoc> task.

Attribute Description
sourcepath
sourcepathref
sourcefiles
Location of the source files for the task. At least one of these attributes required for this specification
destdir Destination directory required unless a doclet is specified
access Access mode (public, private, protected, package)
additionalparam Additional parameters to pass through
author Include @author parts
bootclasspath /
bootclasspathref
Location of class files loaded by bootstrap class loader
bottom Bottom text for each page
breakiterator Use new breakiterator algorithm
charset Charset for cross platform viewing
classpath/classpathref Location of classpath
defaultexcludes Whether default excludes should be used
docencoding Encoding of output file
docfilessubdirs Deep copy of doc-file subdirectories
doclet/docletpathref Classfile that starts to doclet used
doctitle Title for the package index page
encoding Source file encoding
excludepackagenames Packages to exclude from javadoc
executable Specify a javadoc executable instead of VM default
extdirs Location of installed extensions
failonerror Stops build process if command fails
footer Footer text for each page
group Group specified packages together in overview page
header Header text for each page
helpfile Specifies help file to include
includenosourcepackages When true includes packages with no source
link Create links to javadoc output at given url
linksource Generate links to source files
locale Locale to be used
maxmemory Maximum amount of memory to allocate in VM
nodeprecated Do not include @deprecated information
nodeprecatedlist Do not generate deprecated list
notree Do not generate class hierarchy
noindex Do not generate index
nohelp Do not generate help link
nonavbar Do not generate naviation bar
noqualifier Enables -noqualifier argument for a list of packages (or all)
overview Read overview documentation from HTML file
packagenames List of package files to use
packageList File containing packages to use
public Show only public classes and members
protected Show only protected/public classes and members
package Show only package/protected/public classes and members
private Show all classes and members
serialwarn Warn about @serial tag
source Source level used for compilation
splitindex Split index into one file per letter
stylesheetfile Specifies CSS stylesheet
use Create class and package usage pages
verbose Output all messages of javadoc process
version Include @version parts
windowtitle Browser window title for documentation

Table 11: JavaDoc task properties

Executing Java Classes

Java classes can be executed from Ant using the task.

Attribute Description
classname jar The jar file or classname to execute. If using jar, fork must be set to true
append Whether output/error files should be appended or overwritten
args Arguments for class. Better to use nested elements
classpath / classpathref Classpath to use for execution
clonevm Clones system properties and bootclasspath of forked VM to be the same as the Ant VM
dir Directory to invoke VM in
error File to write error (System.err) output to
errorproperty Property to store error output from command
failonerror Stops Ant build process if failure occurs
fork Executes the class in another VM
input File where standard input is taken from
inputstring String where standard input is taken from
jvm Command used to invoke JVM. Default is java
javmargs Arguments for forked JVM. Better to use nested
logError Shows error output in Ant log
maxmemory Maximum memory to allocate to the forked VM
newenvironment When fork=true, do not propogate current environment variables
output File to write output to
outputproperty Property to store output of the command
resultproperty Property where return code of command is stored
spawn Need fork set to true. Will spawn a process independent of calling Ant process
timeout Timeout for the command to execute within before being stopped

Table 12: Java task properties

Running Unit Tests

JUnit tests are executed from Ant through the <junit> task

Attribute Description
clonevm Clones system properties and bootclasspath of forked VM to be the same as the Ant VM
dir Directory from which to invoke the VM
errorproperty Property to set when errors occur
failureproperty Property to set when failure occurs
filtertrace Filter out JUnit or Ant stack frames from stack traces in errors or failures
fork Run JUnit in a separate VM
forkmode How many VMs to create when forking tests. (preTest, perBatch or once)
haltonerror Stop build process if an error happens
haltonfailure Stops build process if a test fails
includeAntruntime Stops build process if a test fails
jvm Command used to invoke VM, default java
logfailedtests Log a FAILED message for each failed test to Ant's logging system
maxmemory Maximum memory to allocate to forked VM
newenvironment When fork=true, do not propogate current environment variables
outputformatters Send output generated by tests to test formatters
printsummary Print statistics for each test case. (on, off, withOutAndErr)
reloading Whether a new classloader should be instAntiated for each test
showoutput Send output to Ant log
tempdir Location for temporary files
timeout Cancel tests if not complete in specified time

Table 13: JUnit task properties

Tests are defined in nested elements within the <junit> task. Batch tests are defined using the <<batchtest> tag:

Attribute Description
name Name of test class
errorproperty Property to set when errors occur
failureproperty Property to set when failure occurs
filtertrace Filter out JUnit or Ant stack frames from stack traces in errorsor failures
fork Run tests in a separate VM, overriding the value set in the <junit> task
haltonerror Stop build process if an error happens
haltonfailure Stops build process if a test fails
if Property condition to run test against, if set
todir Directory to write reports to
unless Property condition to run test against, if not set

Table 14: JUnit batch test definition

Hot Tip

Single Tests If you just need to run a single test, the <test> tag can be used to specify the test. This contains similar attributes to the <batchtest> tag.

Test results can be written to different formats, using the outputformatters attribute in the <junit> task. The following table shows the options for formatter definition:

Attribute Description
type A predefined formatter type of either xml, plain, brief or failure
classname If no type specified, use a customer formatter implementing org.apache.tools.Ant.taskdefs.optional.junit .JUnitResultFormatter
if Use formatter if property is set
unless Use formatter if property is not set
usefile If output should be sent to a file. Default true

Table 15: JUnit formatter definition

Once tests are completed, reports can be generated for the tests using the <junitreport> task.

Attribute Description
todir The directory that will contain the results
tofile The name of the XML file that will aggregate all previously generated results

Table 16: JUnitReport task properties

The <junitreport> task contains a fileset that collects all the reports from previous Junit tests.

To output to a report file, use the internal <report> tag.

Attribute Description
format Format of report (frames or noframes)
styledir Directory containing stylesheets. Files must be junit-frames.xsl or junit-noframes.xsl
todir The directory that files are written to. By default this is the current directory

Table 17: Report tag for <junitreport>

Infrastructure Tasks

There are a number of other core tasks related to file operations. The following is an overview of these tasks:

Task Description
attrib /chmod Changes permission of a file (attrib for Windows, chmod for Unix)
checksum Generates a checksum for files
concat Concatenates multiple files into one single file, or to the console
copy Copies a file, or collection of files, to another location
delete Deletes a file, directory or collection of files
exec Executes a system command
ftp Provides basic FTP functionality
get Gets a file from a URL
import /include Imports or includes another build file into the current Ant script
mail Sends mail over SMTP
mkdir Creates a new directory
move Moves a file, or collection of files, to another location
record Listens to the build process and outputs to a file
replace Replaces occurances of a string in file or collection of files
replaceregexp Replaces occurances of a string in file or collection of files using regular expressions
sql Executes SQL statements to a database using JDBC
sync Synchronizes a target directory with a list of files
zip / unzip tar / untar Creates a zip file / unzips an existing zip. Also provides functionality for tar files

Table 18: Overview of basic infrastructure tasks

SCM Related Tasks

ANT provides a number of tasks for connecting with different source control management systems. The core support deals with CVS.

Task Description
cvs Handles commands to be run against CVS, defaulting with checkout
cvschangelog Generates a report of change logs recorded in CVS
cvspass Adds entries to a .cvspass file
cvstagdiff Generates a report of the changes between two tags/dates from CVS
cvsversion Retrieves CVS client and server version
patch Applies a diff file to originals

Table 19: CVS task properties

There are also tasks available for interfacing with ClearCase, Visual Source Safe, Pvcs, Perforce and Continuus. Additional tasks can be found online for DCVS systems such as Git and Mercurial.

Property Tasks

Ant provides some tasks that deal with managing properties throughout your build process.

Task Description
available Sets property if file, directory or class in classpath is available at runtime
basename Sets property to last element of specified path
buildnumber Reads build number from a specified file
condition Set property if a condition is true
dirname Set property to the directory path of a specified file
echoproperties Display all properties to file or console
loadfile Loads a file into a property
loadproperties Load a property file contents as Ant properties
makeurl Converts filenames into URLs
pathconvert Converts a file list or path structure to a separated string for the target platform
property Set a property
propertyfile Creation and modification of property files
uptodate Set property if specified target file is newer than source files
whichresource Find class or resource
xmlproperty Loads properties from property file written in XML

Table 20: Ant Property Tasks

Hot Tip

Writing Your Own Tasks If Ant doesn't provide you with the functionality that you need, you can write your own Ant tasks in Java by extending org.apache.tools.ant.Task.

About The Authors

Photo of author James Sugrue

James Sugrue

has been editor at both Javalobby and EclipseZone for over two years, and loves every minute of it. By day, James is a software architect at Pilz Ireland, developing killer desktop software using Java and Eclipse all the way. While working on desktop technologies such as Eclipse RCP and Swing, James also likes meddling with up and coming technologies such as Eclipse e4. His current obsession is developing for the iPhone and iPad, having convinced himself that it's a turning point for the software industry.

Recommended Book

apacheant

A single application of increasing complexity, followed throughout the book, shows how an application evolves and how to handle the problems of building and testing. Reviewers have praised the book's coverage of largeprojects, Ant's advanced features, and the details and depth of the discussion-all unavailable elsewhere.


Share this Refcard with
your friends & followers...

DZone greatly appreciates your support.


Your download should begin immediately.
If it doesn't, click here.

Getting Started with Lean Software Development

Download Your Free Copy of DZone's Latest Refcard on Lean Software Development! 

0 replies - 23171 views - 04/05/10 by Lyndsey Clevesy in Announcements

Continuous Integration

Patterns and Anti-patterns

By Paul Duvall

25,665 Downloads · Refcard 84 of 151 (see them all)

Download
FREE PDF


The Essential CI Patterns Cheat Sheet

Continuous Integration is the process of building software with every change committed to a projects version control repository. CI can be explained via patterns (i.e., ineffective approaches used to “fix” the specific problem) and anti-patterns associated with the process. This DZone Refcard will walk you through 40 different Patterns and Anti-patterns associated with CI and expands the notion of CI to include concepts such as Deployment and Provisioning. The end result is learning whether you are capable of delivering working software with every source change.
HTML Preview
Continuous Integration: Patterns and Anti-Patterns

Continuous Integration: Patterns and Anti-Patterns

By Paul M. Duvall

ABOUT CONTINUOUS INTEGRATION

Continuous Integration (CI) is the process of building software with every change committed to a project's version control repository.

CI can be explained via patterns (i.e., a solution to a problem in a particular context) and anti-patterns (i.e., ineffective approaches sometimes used to "fix" the particular problem) associated with the process. Anti-patterns are solutions that appear to be beneficial, but, in the end, they tend to produce adverse effects. They are not necessarily bad practices, but can produce unintended results when compared to implementing the pattern.

Continuous Integration

While the conventional use of the term Continuous Integration generally refers to the "build and test" cycle, this Refcard expands on the notion of CI to include concepts such as Deployment and Provisioning. The end result is learning whether you are capable of delivering working software with every source change.

Pattern Run a software build with every change applied to the Repository
Anti-Patterns scheduled builds, nightly builds, building periodically, building exclusively on developer's machines, not building at all

BUILD SOFTWARE AT EVERY CHANGE

A CI scenario starts with the developer committing source code to the repository. There are four features required for CI.

  • A connection to a version control repository
  • An automated build script
  • Some sort of feedback mechanism (such as e-mail)
  • A process for integrating the source code changes (manual or CI server)

ci flow diagram

Pattern Description
Private Workspace Develop software in a Private Workspace to isolate changes
Repository Commit all files to a version-control repository
Mainline Develop on a mainline to minimize merging and to manage active code lines
Codeline Policy Developing software within a system that utilizes multiple codelines
Task-Level Commit Organize source code changes by task-oriented units of work and submit changes as a Task Level Commit
Label Build Label the build with unique name
Automated Build Automate all activities to build software from source without manual configuration
Minimal Dependencies Reduce pre-installed tool dependencies to the bare minimum
Binary Integrity For each tagged deployment, use the same deployment package (e.g. WAR or EAR) in each target environment
Dependency Management Centralize all dependent libraries
Template Verifier Create a single template file that all target environment properties are based on
Staged BuildsRun remote builds into different target environments Run remote builds into different target environments
Integration Build Perform an Integration Build periodically, continually, etc.
Continuous Feedback Send automated feedback from CI server to development team
Expeditious Fixes Fix build errors as soon as they occur
Developer Documentation Generate developer documentation with builds based on checked-in source code
Independent Build Separate build scripts from the IDE
Single Command Ensure all build and deployment processes can be run through a single command
Dedicated Machine Run builds on a separate dedicated machine
Externalize Configuration Externalize all variable values from the application configuration into build-time properties
Tokenize Configuration Token values are entered into configuration files and then replaced during the Scripted Deployment
Protected Configuration Files are shared by authorized team members only
Scripted Database Script all database actions
Database Sandbox Create a lightweight version of your database
Database Upgrade Use scripts and database to apply incremental changes in each target environment
Automated Tests Write an automated test for each unique path
Categorize Tests Categorize tests by type
Continuous Inspection Run automated code analysis to find common problems
Build Threshold Use thresholds to notify team members of code aberrations
Deployment Test Script self-testing capabilities into Scripted Deployments
Scripted Deployment All deployment processes are written in a script
Headless Execution Securely interface with multiple machines without typing a command
Unified Deployment Create a single deployment script capable of running on different platforms and target environments
Disposable Container Automate the installation and configuration of Web and database containers
Remote Deployment Use a centralized machine or cluster to deploy software to multiple target environments
Environment Rollback Provide an automated Single Command rollback of changes after an unsuccessful deployment
Continuous Deployment Deploy software with every change applied to the project's version control repository
Single-Command Provisioning Run a single command to provision target environment
Decouple Installation Separate the configuration from the installation

PATTERNS AND ANTI-PATTERNS

Version Control

The patterns in this section were originally described in the book Software Configuration Management Patterns (Addison-Wesley, 2003, Berczuk and Appleton), except for 'Label Build':

Pattern Description
Private Workspace Prevent integration issues from distracting you, and from your changes causing
Repository All files are committed to version-control repository - in the deployment context, all of the configuration files and tools.
Mainline Minimize merging and keep the number of active code lines manageable by developing on a Mainline
Codeline Policy The policy should be brief, and should spell out the "rules of the road" for the codeline

Task-Level Commit

Pattern Organize source code changes by task-oriented units of work and submit changes as a Task Level Commit. (from SCM Patterns)
Anti-Patterns Keeping changes local to developer for several days and stacking up changes until committing all changes. This often causes build failures or requires complex troubleshooting.

Label Build

Pattern Label the build with unique name so that you can run the same build at another time.
Anti-Patterns Not labeling builds, Using revisions or branches as "labels."

<path id="svn.classpath">
  <fileset dir="${lib.dir}">
   <include name="**/*.jar" />
  </fileset>
</path>
<taskdef name="svn" classpahref="/sites/all/modules/dzone/assets/refcardz/084/svn.classpath" classname="org.tigris.subversion.svnant.SvnTask"/>
<target name="create-tag-from-trunk">
	
<svn username="jhancock" password="S!gnhere">
  <copy srcUrl="https://brewery-ci.googlecode.com/svn/trunk"
   <destUrl="https://brewery-ci.googlecode.com/svn/tags/brewery-1.0.0"
    <message="Tag created by jhancock on ${TODAY}" />
 </svn>
</target>

Build Management

Automated Build

Pattern Automate all activities to build software from source without manual configuration. Create build scripts that are decoupled from IDEs. Later, these build scripts will be executed by a CI system so that software is built at every change.
Anti-Patterns Continually repeating the same processes with manual builds or partially automated builds requiring numerous manual configuration activities.

<?xml version="1.0" encoding="iso-8859-1"?>
<project name="brewery" default="all" basedir=".">
  <target name="clean" />
  <target name="svn-update" />
  <target name="all" depends="clean,svn-update"/>
  <target name="compile-src" />
  <target name="compile-tests" />
  <target name="integrate-database" />
  <target name="run-tests" />
  <target name="run-inspections" />
  <target name="package" />
  <target name="deploy" />
</project>

Minimal Dependencies

Pattern Reduce pre-installed tool dependencies to the bare minimum. Eliminate required environment variables from the Automated Build and Scripted Deployment.
Anti-Patterns Requiring developer to define and configure environment variables. Require developer to install numerous tools in order for the build/deployment to work.

install JADS diagram

Binary Integrity

Pattern For each tagged deployment, the same deployment package (e.g. WAR or EAR) is used in each target environment.
Anti-Patterns Separate compilation for each target environment on the same tag.

install JADS diagram

Dependency Management

Pattern Centralize all dependent libraries to reduce bloat, classpath problems, and repetition of the same dependent libraries and transitive dependencies from project to project.
Anti-Patterns Multiple copies of the same JAR dependencies in each and every project. Redefining the same information for each project. Classpath hell!

Tools such as Ivy and Maven can be used for managing dependencies.

projects diagram

Consistent Directories

Pattern Create a simple, yet well-defined directory structure to optimize software builds and increase cross-project knowledge transfer.
Anti-Patterns Putting code, documentation and large files in the same parent directory structure, leading to long-running builds.

Template Verifier

Pattern Create a single template file that all target environment properties are based on.
Anti-Patterns Use manual verification, trial and error (when deployment fails, check the logs),or keeping files "hidden" on a machine.

Template Verifier diagram

Staged Builds

Pattern Using the Remote Deployment pattern, run remote builds into different target environments
Anti-Patterns Deploying directly to production

Build Practices

Private Build

Pattern Verify your changes will not break the Integration Build by performing a Private Build prior to committing changes to the Repository.
Anti-Patterns Checking in changes to version-control repository with running a build on developer's workstation.
Build Configuration

Integration Build

Pattern Ensure that your code base always builds reliably by doing an Integration Build periodically
Anti-Patterns "Works on My Machine" (WOMM). Continuous Compilation.

Continuous Feedback

Pattern Sending automated feedback from CI server to development team.
Anti-Patterns Minimal feedback, which prevents action from occurring. Receiving spam feedback, which causes people to ignore messages.
Examples Email, RSS, SMS, X10, Monitors, Web Notifiers

Expeditious Fixes

Pattern Fix build errors as soon as they occur.
Anti-Patterns Build entropy - problems stack up causing more complex troubleshooting and some claim that "CI" is the problem.
Fix broken builds immediately Although it is the team's responsibility, the developer who recently committed code must be involved in fixing the failed build
Run private builds To prevent Integration failures, get changes from other developers by getting the latest changes from the repository and run a full integration build locally, known as a Private Build
Avoid getting broken code If the build has failed, you will lose time if you get code from the Repository. Wait for the change or help the developer(s) fix the build failure and then get the latest code

Developer Documentation

Pattern Generate developer documentation with builds (at appropriate intervals)based on checked-in source code.
Anti-Patterns Developer documentation is manually generated, periodically. This is both a burdensome process and one in which the information becomes useless quickly because it does not reflect the checked-in source code.

Automating your documentation's generation will help you keep it up to date and thereby make it more useful for your software's users.

SchemaSpy


<property name="reports.dir" value="${basedir}"/>
<java jar="schemaSpy_3.1.1.jar" output="${reports.dir}/output.log"
error="${reports.dir}/error.log" fork="true">
  <arg line="-t mysql"/>
  <arg line="-host localhost"/>
  <arg line="-port 3306"/>
  <arg line="-db brewery"/>
  <arg line="-u root"/>
  <arg line="-p sa"/>
  <arg line="-cp mysql-connector-java-5.0.5-bin.jar"/> <arg line="-o
${reports.dir}"/>


Note: 'Private Build' and 'Integration Build' are also from Berczuk and Appleton's book Software Configuration Management Patterns (Addison-Wesley, 2003, Berczuk Staged Builds and Appleton)

Build Configuration

Independent Build

Pattern Separate build scripts from the IDE. Create build scripts that are decoupled from IDEs. Later, these build scripts will be executed by a CI system so that software is built at every change.
Anti-Patterns Automated Build relies on IDE settings. Build cannot run from the command line.

Build Configuration diagram

Single Command

Pattern Ensure all build and deployment processes can be run through a single command. This makes it easier to use, reduces deployment complexities and ensures a Headless Execution of the deployment process. Deployers, or headless processes, can type a single command to generate working software for users.
Anti-Patterns Some deployment processes require people to enter multiple commands and procedures such as copying files, modifying configuration files, restarting a server, setting passwords, and other repetitive, error-prone actions.

Single-command deployment execution using Ant:


ant-Dproperties.file=$USERHOME/projects/petstore/properties/devinstall.
properties deploy:remote:install

Dedicated Machine

Pattern Run builds on a separate dedicated machine.
Anti-Patterns Existing environmental and configuration assumptions can lead to the “but it works on my machine problem.”

When creating an integration build machine consider the following:

Recommended system resources Increase hardware resources for an integration build machine rather than wasting time waiting for slow builds.
All software assets in the version control repository See the Repository pattern.
Clean environment CI process removes any code dependencies on the integration environment. Automated build must set test data and any other configuration elements to a known state.

Externalize Configuration

Pattern All variable values are externalized from the application configuration into build-time properties.
Anti-Patterns Some hardcode these values, manually, for each of the target environments, or they might use GUI tools to do the same.

Example properties that are external to application-specific files:


authentication.type=db
application.url=http://${tomcat.server.hostname}:${tomcat.server.port}/brewery-webapp
database.type=mysql
database.server=localhost
database.port=3306
database.name=mydb
database.user=myuser!
database.password=mypa$$!
database.url=jdbc:mysql://${database.server}:${database.port}/${database.name}
tomcat.server.hostname=localhost
tomcat.server.name=default
tomcat.web.password=pa$$123!
tomcat.cobraorb.port=12748

Tokenize Configuration

Pattern Token values are entered into configuration files and then replaced during the Scripted Deployment based on Externalized Configuration properties checked into Repository.
Anti-Patterns Target-specific data is entered into configuration files in each environment.

Protected Configuration

Pattern Using the repository, files are shared by authorized team members only.
Anti-Patterns Files are managed on team members' machines or stored on shared drives accessible by authorized team members.

Protected Configuration diagram

Database

Pattern Script all database actions.
Anti-Patterns Late and manual migration of a database in the development cycle is painful and expensive.

Script all DDL and DML so that database changes can be run from the command line. Use a version-control repository to manage all database-related changes. (i.e. refer to the pattern)


<target name="db:create" depends="filterSqlFiles" description="Create the database definition">
   <sql driver="com.mysql.jdbc.Driver"
   url="jdbc:mysql://localhost:3306/"
   userid="root"
   password="root"
   classpahref="/sites/all/modules/dzone/assets/refcardz/084/db.lib.path"
   src="/sites/all/modules/dzone/assets/refcardz/084/${filtered.sql.dir}/database-definition.sql" delimiter="//"/>
</target>

Database Sandbox

Pattern
  • Create a lightweight version of your database (only enough records to test functionality)
  • Use this lightweight DML to populate local database sandboxes for each developer
  • Use this data in development environments to expedite test execution
Anti-Patterns Shared development database.

Give each developer, tester or test user a separate database instance. Install a lightweight database server in each user's test environment (e.g., MySQL, Personal Oracle), which can be installed on the user's private workstation, on a shared test server, or on a dedicated “virtual server” running on a shared server.

Database Upgrade

Pattern Use scripts and database to apply incremental changes in each target environment, which provides a centrally managed and scripted process to applying incremental changes to the database.
Anti-Patterns Manually applying database and data changes in each target environment

Running a custom SQL file from a LiquiBase change set:


build.xml
<updateDatabase changeLogFile="db.change.xml"
driver="org.apache.derby.jdbc.EmbeddedDriver" url="jdbc:derby:brewery" username="" password="" dropFirst="true" classpahref="/sites/all/modules/dzone/assets/refcardz/084/project.class.path"/>
db.change.xml
<changeSet id="1" author="phenry">
  <sqlFile path="insert-data.sql"/>
</changeSet>

Testing and Code Quality

Automated Tests

Pattern Write an automated test for each unique path.
Anti-Patterns Not running tests, no regression tests, manual testing
Examples

A Simple Unit Test
public void setUp() {
beerService = new BeerDaoStub();
}
public void testUnitGetBeer() {
Collection beers = beerService.findAll();
assertTrue(beers != null && beers.size() > 0);
}
Running a Unit Test in Ant
<junit fork="yes" haltonfailure="true" dir="${basedir}" printsummary="yes">
   <classpath refid="test.class.path" />
   <classpath refid="project.class.path"/>
   <formatter type="plain" usefile="true" />
   <formatter type="xml" usefile="true" />
   <batchtest fork="yes" todir="${logs.junit.dir}">
     <fileset dir="${test.unit.dir}">
       <patternset refid="test.sources.pattern"/>
     </fileset>
   </batchtest>
</junit>

Categorize Tests

Pattern Categorize tests by type and your builds become more agile, tests can be run more frequently, and tests no longer take hours to complete.
Anti-Patterns Tests take hours to run, leading to excessive wait times and increased expense.

Continuous Inspection

Pattern Run automated code analysis to find common problems. Have these tools run as part of continuous integration or periodic builds.
Anti-Patterns Long, manual code reviews or no code reviews.

Examples:

CheckStyle


<taskdef resource="checkstyletask.properties" classpath="${checkstyle.jar}"/>
<checkstyle config="${basedir}/cs-rules.xml" failOnViolation="false">
  <formatter toFile="${checkstyle.data.file}" type="xml" />


    <fileset casesensitive="yes" dir="${src.dir}" includes="**/*.java" />
</checkstyle>
<xslt taskname="checkstyle"
in="${checkstyle.data.file}"
out="${checkstyle.report.file}"
style="${checkstyle.xsl.file}" />

Build Threshold

Pattern Notify team members of code aberrations such as low code coverage or high cyclomatic complexity. Fail a build when a project rule is violated. Use continuous feedback mechanisms to notify team members.
Anti-Patterns Manual code reviews. Learning of code quality issues later in the development cycle.

<module name="CyclomaticComplexity">
  <property name="max" value="10"/>
</module>


Deployment Test

Pattern Script self-testing capabilities into Scripted Deployments.
Anti-Patterns Deployments are verified by running through manual functional tests that do not focus on deployment-specific aspects. No deployment tests are run..

The table below describes examples of the types of test that might be run as part of a Deployment Test smoke suite.

Example Test Type Description
Database Write an automated functional test that inserts data into a database. Verify the data was entered in the database.
Simple Mail Transfer Protocol (SMTP) Write an automated functional test to send an e-mail message from the application.
Web service Use a tool like SoapAPI to submit a Web service and verify the output.
Web container(s) Verify all container services are operating correctly.
Lightweight Directory Access Protocol (LDAP) Using the application, authenticate via LDAP.
Logging Write a test that writes a log using the application's logging mechanism.

Deployment

Scripted Deployment

Pattern All deployment processes are written in a script.
Anti-Patterns Manually installing and configuring a Web container. Use of the GUI-based administration tool provided by the container to modify the container based on a specific environment.

<available file="@{tomcat.home}/server/@{tomcat.server.name}/bin"
   property="tomcat.bin.exists"/>
<if>
   <isset property="tomcat.bin.exists"/>
<then>
   <echo message="Starting tomcat instance at @{tomcat.home} with start_tomcat" />
<exec executable="@{tomcat.home}/server/@{tomcat.server.name}/bin/start_tomcat"
   osfamily="unix" />
 </then>
 <else>
   <echo message="Starting tomcat instance at @{tomcat.home} with startup.sh" />
<exec osfamily="unix" executable="chmod" spawn="true">
   <arg value="+x" />
   <arg file="@{tomcat.home}/bin/startup.sh" />
   <arg file="@{tomcat.home}/bin/shutdown.sh" />
  </exec>
  <exec executable="sh" osfamily="unix" dir="@{tomcat.home}/bin" spawn="true">
<env key="NOPAUSE" value="true" />
<arg line="startup.sh" />
</exec>
    <exec osfamily="windows" executable="cmd" dir="@{tomcat.home}/bin" spawn="true" >
     <env key="NOPAUSE" value="true" />
      <arg line="/c startup.sh" />
    </exec>
    <sleep seconds="15" />
    </else>
</if>

Headless Execution

Pattern Securely interface with multiple machines without typing a command.
Anti-Patterns People manually access machines by logging into each of the machines as different users; then they copy files, configure values, and so on.

Build invironment diagram

Unified Deployment

Pattern Create a single deployment script capable of running on different platforms and target environments.
Anti-Patterns Some may use a different deployment script for each target environment or even for a specific machine.

Unified Deployment diagram

Disposable Container

Pattern Automate the installation and configuration of Web and database containers by decoupling installation and configuration.
Anti-Patterns Manually install and configure containers into each target environment.

Unified Deployment diagram

Disposable Container

Pattern Automate the installation and configuration of Web and database containers by decoupling installation and configuration.
Anti-Patterns Manually install and configure containers into each target environment.

Disposable Container diagram

Remote Deployment

Pattern Use a centralized machine or cluster to deploy software to multiple target environments.
Anti-Patterns Manually applying deployments locally in each target environment.

Remote Deployment diagram

Environment Rollback

Pattern Provide an automated Single Command rollback of changes after an unsuccessful deployment.
Anti-Patterns Manually rolling back application and database changes.

Environment Rollback diagram

Continuous Deployment

Pattern Deploy software with every change applied to the project's version control repository.
Anti-Patterns Deploying periodically. Manual deployments. Manual configuration of target environments.

Single-Command Provisioning

Pattern Run a single command or click a button to provision target environment.
Anti-Patterns Numerous manual and error-prone steps, often performed by other teams, leading to delays and target environment inconsistencies making errors difficult to troubleshoot.

Decouple Installation

Pattern Separate the configuration from the installation.
Anti-Patterns Saving off preconfigured images whose configuration has not been automated.

About The Author

Photo of author Paul M. Duvall

Paul M. Duvall

Paul M. Duvall is the CEO of Stelligent, a firm that helps clients create production-ready software every day. A featured speaker at many leading software conferences, he has worked in virtually every role on software projects: developer, project manager, architect, and tester. He is the principal author of Continuous Integration: Improving Software Quality and Reducing Risk (Addison-Wesley, 2007) and a 2008 Jolt Award Winner. Paul contributed to the UML 2 Toolkit (Wiley, 2003), wrote a series for IBM developerWorks called "Automation for the People", and contributed a chapter to No Fluff Just Stuff Anthology: The 2007 Edition (Pragmatic Programmers, 2007). He is passionate about automating software development and release processes and actively blogs on IntegrateButton.com and TestEarly.com.

Some of the concepts and material in this Refcard were adapted from:

Recommended Book

Continuous Integration

For any software developer who has spent days in "integration hell," cobbling together myriad software components, Continuous Integration: Improving Software Quality and Reducing Risk illustrates how to transform integration from a necessary evil into an everyday part of the development process. The key, as the authors show, is to integrate regularly and often using continuous integration (CI) practices and techniques.


Share this Refcard with
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,195 Downloads · Refcard 74 of 151 (see them all)

Download
FREE PDF


The Essential Agile Adoption Cheat Sheet

Agile Adoption is a multi-part DZone Refcard series, and is a quick introduction to Agile practices. It will help you improve the quality of your software by reducing defects, improving design, sharing the theory of the code and building less. Many of the practices from the Agile world stop the degradation of design quality and turn the trend around. This Refcard includes an introduction of how to choose the practices for your organizational context, and much more. Most importantly, it provides a 50,000 foot view of what is involved to incrementally improve the quality of your software.
HTML Preview
Agile Adoption: Improving Software Quality

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.

Quality to market

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

Bug

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

Star

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

Theory

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

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.

Build split

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.

Strategy Dependencies

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

TDD to Refactoring

Test Driven Development Practices
Book 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.
Tests 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.
Automation 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.

TDD to Testing

Test Driven Requirements Practices
Book Test Driven Requirements call for the customer to provide requirements in an unambiguous format, usually an acceptance test, at the beginning of the iteration.
Tests 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.
Automation 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

Done State Bug
Book 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.
Tests 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.
Automation 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 Practices
Book 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.
Tests 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.
Automation 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 Practices
Book 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.
Tests 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.
Automation 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

Refactoring Refactoring
Book The practice of Refactoring code changes the structure (i.e., the design) of the code while maintaining its behavior.
Tests 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.
Automation 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

Pair Programming icons
Book 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.
Tests 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.
Automation 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
Bug
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
icons
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
Star
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
icons
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
icons
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
icons
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
icon
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:

Steps for Choosing and Implementing Practices

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.

Learning Curve

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:

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

  Evolutionary Design Simple Design Refactoring Automated Developer Tests Evocative Document Automated Acceptance Tests Backlog Iteration Done State Cross-Functional Team Self-Organized Team Retrospective Continuos Integration User Story
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
Share this Refcard with
your friends & followers...

DZone greatly appreciates your support.


Your download should begin immediately.
If it doesn't, click here.

Reduce Your Software Developement Costs Now!

Are your software development costs breaking the bank? Click here for a solution!

0 replies - 4760 views - 05/18/09 by Lyndsey Clevesy in Announcements

Scrum

By Michael James

38,763 Downloads · Refcard 50 of 151 (see them all)

Download
FREE PDF


The Essential Scrum Cheat Sheet

Scrum is an iterative, incremental software development framework commonly used with Agile software development. It uses one or more cross-functional, self-organizing 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 every iteration. This DZone Refcard provides a concise overview of the structure of roles, meetings, rules and artifacts within a Scrum organization – it is the definitive cheat sheet for any development manager or software team that is currently using or planning to use Scrum.
HTML Preview
Scrum

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.

Alternative to Waterfall

Figure 1: Traditional “waterfall” development assumes perfect understanding of requirements at outset.

figure2

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

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

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: Product Backlog

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

Figure 6:

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:

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:

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:

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:

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:

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:

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:

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:

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

  1. Agile Project Management with Scrum, Schwaber, Microsoft Press, 2004. See Appendix A “Rules.”
  2. http://danube.com/blog/michaeljames/a_scrummasters_checklist
  3. Agile Retrospectives: Making Good Teams Great, Derby/Larsen, Pragmatic Bookshelf, 2006
  4. Agile Estimating and Planning, Cohn, Prentice Hall PTR, 2005.
  5. Example generated by ScrumWorks® Basic, a free tool.
  6. Scaling Lean & Agile Development: Thinking and Organizational Tools for Large-Scale Scrum, Larman/Vodde, Addison-Wesley Professional, 2008.
  7. Graph inspired by Ron Jeffries lecture at http://www.infoq.com/news/2006/12/jeffries-running-tested-features
  8. Extensively modified version of a graph in Strategic Management and Organizational Dynamics, Stacey, 1993, referenced in Agile Software Development with Scrum, Schwaber/Beedle, 2001.
  9. Quote is from Process Dynamics, Modeling, and Control, Ogunnaike, Oxford University Press, 1992.
  10. “Developmental Sequence in Small Groups.” Psychological Bulletin, 63 (6): 384-99 Tuckman, referenced by Schwaber.
  11. Group Genius: The Creative Power of Collaboration, Sawyer, Basic Books, 2007.
  12. “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.
  13. Scrum training/coaching also available from http://danube.com/

About The Author

Photo of author Michael James

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

ScrumCORE CSM course.

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

Share this Refcard with
your friends & followers...

DZone greatly appreciates your support.


Your download should begin immediately.
If it doesn't, click here.