InfoQ

InfoQ

Minibook

My Bookmarks

Login or Register to enable bookmarks for unlimited time.

The content has been bookmarked!

There was an error bookmarking this content! Please retry.

Priming Kanban

Posted by Jesper Boeg on Nov 11, 2011

Sections
Process & Practices
Topics
Release ,
Team Collaboration ,
Version Control ,
Collaboration ,
Distributed Team ,
Kanban ,
Quality ,
Source Control ,
Teamwork ,
Lean ,
Agile in the Enterprise ,
Agile Techniques ,
Software Craftsmanship ,
Project Management ,
Programming ,
Agile ,
WIP


Kanban represents a unique way of catalyzing the application of Lean product development principles to software development, maintenance and operations. Being a method for driving change Kanban does not prescribe specific roles, practices or ceremonies but instead offers a series of principles to optimize value and flow in your software delivery system. As such, Kanban’s focus on context and adaptability has made it increasingly popular for teams working in contexts where traditional Agile methods are not an easy fit and mature Agile teams looking for ways to further optimize their development process.

When first introduced to these concepts many teams are however left with the questions: “How do we get started”? “Are there common behaviors or strategies that can help us take the plunge”? This is natural and people familiar with the Dreyfus model of skill acquisition will recognize that novices need rules, plans and even practices.

Therefore this mini-book offers an easy to follow 10 step guide to taking the initial plunge and start using Lean principles to optimizing value and flow in your system. Each step consists of a section explaining “why” followed by examples of specific tools, practices and rules that have helped other teams better understand and optimize their system. The author's hope is that this will make it easier for teams to get started and quickly understand the importance of value and flow by experiencing it first hand.

Free download

Login to download this book FREE (PDF)

Table of Contents

Introduction
Background
When should I consider working with Kanban?
What is Kanban?
How do we get started with Kanban?
Where can Kanban be used?
Kanban Myths

Step 1: Visualize your workflow
Understanding your software delivery system
Visualizing your system

Step 2: Limit Work in Progress (WIP)
Understanding WIP
Visualizing WIP Limits
Finding the right WIP limits

Step 3: Set Up Quality Assurance Policies and Make Them Explicit
Understanding quality
Visualizing policies

Step 4: Adjust Cadences
Understanding Cadence
Finding the right cadences

Step 5: Measure Flow
Understanding Metrics
What to measure?
Cumulative flow diagrams (CFD)
Reading the CFD
Cycle time
Defect rate
Blocked Items

Step 6: Prioritize
Cost of Delay (COD)
Visualizing Priority

Step 7: Identify Classes of Service
Types of work
Define Classes of Service
Visualizing Classes of Service

Step 8: Manage Flow
Decision filters
Optimize flow not utilization
Relieve bottlenecks
Introduce buffers
Release planning
Experiment

Step 9: Establish Service Level Agreements (SLA)
Establishing the right Service Level Agreements

Step 10: Focus on Continuous Improvement

Good luck on your journey

About the Author

Jesper Boeg has worked as an Agile and Lean coach for more than 5 years and is now in charge of the department for ”Agile Excellence” at Trifork. He has a Masters degree from Aalborg University in the area of Information Systems and wrote his thesis on how to successfully manage distributed software teams. Jesper helps teams and organizations adopt Agile and Lean principles with a strong focus on understanding “why”. He has a reputation for being honest and straight forward, with a firm believe that change management is much more about people than process.

Jesper believes that trust is best established through an unrelenting focus on transparency in the entire organization.He has a strong passion for Lean Product Development and continuously emphasizes that one must look at the entire software delivery system to guide success. Context Based Strategically Aligned Agility are keywords in Jesper’s work. It is his experience that to create lasting change, organizations cannot rely on Best Practice rule sets but must put effort into understanding “why” and aligning Agile principles with the overall business strategy. Otherwise they will quickly revert to former practices when faced with difficulty and restrict themselves from great improvement opportunities.

Jesper regularly speaks at Agile and Lean conferences. He is member of the GOTO Aarhus Program Advisory Board and has served as trackhost on numerous GOTO and QCon conferences.

Educational Content

Eventually Consistent HTTP with Statebox and Riak

Bob Ippolito explains how to solve concurrent update conflicts with Statebox, an open source library for automatic conflict resolution, running on top of Riak.

Java.next

Erik Onnen attempts to demonstrate that Java is still the best programming language for the JVM if simplified idioms are used along with proper tooling.

Evolution in Data Integration From EII to Big Data

Approaches to integrating data are changing with emergence of cloud computing.

Winning Hearts and Minds: How to Embed UX from Scratch in a Large Organization

Michele Ide-Smith presents the lessons learned in the process of introducing UX principles and techniques into a large organization through a series of small steps.

LMAX Disruptor: 100K TPS at Less than 1ms Latency

Dave Farley and Martin Thompson discuss solutions for doing low-latency high throughput transactions based on the Disruptor concurrency pattern.

Thoughts on Test Automation in Agile

Rajneesh Namta shares his thoughts, experiences, and some of the critical lessons learned while implementing software test automation on a recent Agile project.

Actor Interaction Patterns

Dale Schumacher presents several patterns of actor interaction that can be used in collaborative programs written in any language.

Scalaz: Functional Programming in Scala

Rúnar Bjarnason discusses Scalaz, a Scala library of pure data structures, type classes, highly generalized functions, and concurrency abstractions to perform functional programming in Scala.