Implementing Done, In Process, and Ready Queues in LeanKit Kanban

Posted by indomitablehef | Filed under LeanKit, Lean, Kanban, Tools

In two blog posts, “A Variation on Queues - Pipelines for WIP and Done” from December 2008, and WIP Queues: Done vs Ready from September 2009, Derick Bailey, (with comments from Scott Bellware) examined ways to break down WIP queues into Ready, In Process, and Done queues. Ideas from these blog posts made it into our electronic Kanban implementation in LeanKit Kanban, and I’d like to show you how they can be implemented and analyzed using those features in LeanKit Kanban.

In “A Variation on Queues - Pipelines for WIP and Done” Derick describes how:

we can use the concept of a pipeline and split our existing queues into a WIP and Done step. For example, we want developers to pull work from the Analysis queue into the Development pipeline. We can show which cards are ready to move by splitting Analysis into sub-columns of WIP and Done.

I’m replacing his illustrations with mine, from LeanKit Kanban:

Then in September of 2009, in WIP Queues: Done vs Ready he took it a step further describing how the pipeline can be modeled to include a “Ready” state just before an “In Process”, _or_ a “Done” state just after the “In Process” state.

Like this, showing the LeanKit Kanban board in “edit mode”. (we’re proud of our “inline”, wysiwyg board editing features, too)

Notice the drop-down lists in each column/subcolumn header - these allow you to specify that a particular column is a “Ready” Queue, “In Process” queue, or “Completed” queue.

Or, in some cases, you might want both a “Ready” Queue and a “Completed/Done” Queue in your pipeline:

Notice the little Queue Type icons in each sublane header - shown in the call-out bubble. These allow you to see at a glance what kind of queue you’re looking at.

As Derick and Scott Bellware discussed in the WIP Queues: Done vs Ready post and comments, having a “Ready” queue may indicate a “Push” situation in your pipeline:

An important distinction of “Ready” is that it receives items via push rather than pull. It’s a thing that’s usually found and the seam between two process stages or two parts of an organization that aren’t easily reconciled by pull.

Before we move on to how you can use these distinctions in your analysis of process efficiency, here is one more illustration from LeanKit Kanban, showing a Ready/WIP pipeline modeled as a horizontal sublane, instead of a vertical one:

Efficiency Analysis Based on Queue Type

Now let’s look at how making these distinctions on the types of Queues in your process, along with the automatic statistics capture your get from an electronic tool, and the Efficiency Analysis chart in LeanKit Kanban can show you valuable information about the efficiency of your process, and how much “dead” time there might be in waiting for handoffs.

Let’s take, as an example, a more complex value stream, shown below (click to enlarge):

Notice how the parent “In Development” and “Testing” lanes are broken down horizontally into “Feature Groups”, each with a Ready Queue, In Process Queue and a Completed Queue. The Bugs section of the “In Process” lane is modeled with an In Process and a Completed queue, whereas the Bugs section of the Testing Lane is modeled using a Ready queue and an In Process Queue.

Using the Efficiency Diagram in LeanKit Kanban, and all the flexibility it provides to define the parameters used to analyze the data, we can take a closer look at

1. Just the “In Process” and “Testing” lanes and their children/sublanes
2. For the first 3 weeks in January
3. Taking Card Size into account

… in order to see

What percentage of the Cards on the board were “In Process”, as opposed to “Ready” or “Completed” at any given time over the course of those three weeks?

Check out the diagram below in detail, with annotations: (click to enlarge)

So, for this completely made-up data set I used to generate this chart, it looks like we’re running a fairly efficient process. What do those occasional spikes in “Completed” queues mean? Maybe those are Fridays, when people push to finish the work they currently have on their plate. Or maybe it’s no big deal - but noticing patterns like that, and asking the questions that they inevitably bring to mind, can be an important part of the “continuous improvement” of your Kanban system.

Thanks to Derick and Scott, for their contributions to the Lean Software Development and Kanban community and to my own learning process over the past couple of years. Thank You for reading this far down, and please do go and give LeanKit Kanban a spin. You can sign up for a fully functional free account, which includes all the advanced features and analytics described in this post, and allows you one Kanban board and up to 5 users for free.

NashDotNet Resources

Posted by indomitablehef | Filed under Continuous Integration, .Net, Tools

• Presentation Outline
• Martin Fowler’s seminal article on Continuous Integration
• An older post from me, with resources for automating your build with NAnt and using CruiseControl.Net for continuous integration
• JetBrains TeamCity
• Customizing your build script to interact directly with TeamCity’s simple API
• MSBuild Community Tasks
• PsExec
• Visual Studio Web Deployment Projects Download
• Ruby Programming Language
• Rake NUnit Task
• OMG, Rake! - Dave Laribee on using Rake to automate your builds, with links to helpful resources for learning Rake
• Rake documentation
• Example Project and Example Automated Build scripts from the presentation
  look under “source” /trunk/NashDotNet

Ludicrous speed? Sir, we’ve never gone that fast before!

Posted by indomitablehef | Filed under Visual Studio, Tools, Productivity

For those using ViEmu: A nifty registry hack that will turn your CAPS-Lock key into your Esc key…for even faster keyboarding. Or, use SharpKeys to get the same effect .

ViEmu

Posted by indomitablehef | Filed under Visual Studio, Tools, Productivity

Back when I was in college, my first computer science professor insisted that everyone learn to use the Unix text editor Vi. After my initial few weeks of frustration, I was hooked. I could really fly on the keyboard, without ever using the mouse or the arrow keys to move around. I got my degree, got a job, and I haven’t seen Vi since.

Until now. This nifty little Vi emulator (ViEmu) can emulate Vi in Visual Studio, SQL Server Management Studio, Outlook, and Word. I found it after reading about it from jpboodhoo, and these screencasts from Aaron Jensen at Eleutian (part1, part2, part3) helped me get started. I must say, it’s still painful…relearning all this stuff. I’m currently slower using ViEmu than I was a few days ago without it. But I’m beginning to see the productivity at the end of the tunnel. (I found myself hitting “hhhhhh” several times while writing this blog post.)

more ViEmu goodies:

• Graphical Cheat Sheet and Tutorial
• Tips on Effective Editing with Vim
• Why, oh WHY, do those #?@! nutheads use vi?

TeamCity is da bomb

Posted by indomitablehef | Filed under Continuous Integration, Tools

I’ve been working with TeamCity, JetBrains new Continuous Integration product, for a couple of weeks. I’m completely infatuated with it right now. It has a quirk or two to deal with when getting it set up, but configuring builds is much easier than with CruiseControl, and the amount of information it gives you back is fantastic. Logs of your changes, trends on how long your unit tests are running, statistics, it’s nearly overwhelming. The Professional Edition (up to 20 users, 3 agents, 20 build configurations) is just as free as Cruise Control, too.

I did have to make some changes to how I ran my NUnit tests, in order for TeamCity to pick up on them. I had been calling nunit-console.exe from within my NAnt build file, like so:

<exec basedir="toolsnunitbin">
		useruntimeengine="true"
		workingdir="build"
		program="nunit-console.exe"
		commandline="${project::get-name()}.Test.Unit.dll
			/xml=${project::get-name()}.Unit.Test-Result.xml" />
</exec>

While that ran my tests just fine, and output the results to the xml file, TeamCity didn’t pick up on that. CruiseControl.Net picks it up when you add this to the <project> node in your ccnet.config file:

 <publishers>
	<merge>
		<files>
			<file>C:checkoutsMyProjectbuild*test-result.xml</file>
		</files>
	</merge>
	<xmllogger>
</xmllogger>
</publishers>

But that’s beside the point…we’re talking about TeamCity here. For TeamCity to recognize my tests, I had to use the <nunit2> NAnt task, like so:

<target name="unit.test.nunit2" depends="unit.test.compile">
	<copy file="config\Web.Config"
		tofile="build\${project::get-name()}.Test.dll.config" />
	<nunit2 verbose="true" haltonfailure="false" failonerror="true">
		<formatter type="Plain" extension=".txt" usefile="true"
							outputdir="${project.root}\build"/>
		<test assemblyname="build\${project::get-name()}.Test.dll"
			appconfig="build\${project::get-name()}.Test.dll.config"
				haltonfailure="false" />
	</nunit2>
</target>

Continuous Integration

Posted by indomitablehef | Filed under CruiseControl.Net, NAnt, Continuous Integration, Tools

If I had to rank the things I’ve learned in the past year in order of importance, the undisputed #1 would be Continuous Integration. I’ve known about CI for some time, and I always thought it sounded like a good idea, but I hadn’t made time to try it out. Now that I have, I can hardly imagine working without it. I’m hardly an expert yet, but I’d like to pass on some of the resources that helped me when I was first learning how to set up Automated Build with NAnt and Continuous Integration with CruiseControl.Net.

1. John-Paul Boodhoo’s NAnt starter series
   You have to have an automated build in order to get continuous integration working. Even if that weren’t true, automating your build process would still be and incredibly valuable thing to do. I chose to use NAnt, partly because of the existence of good community content, and lots of examples on how to use it. There’s a medium-steep learning curve, but once you’ve figured it out, it’s really not that hard, and you can really harness the power of automated builds. You don’t have to use NAnt, of course…you could also use MSBuild. Compare the two here. And here. More on using MSBuild here.
2. Automating Your Builds With NAnt - Part 8 (Enter CruiseControl)
   Also from JP Boodhoo, this hour-long screencast will take you step-by-step through the process of setting up Continuous Integration using CruiseControl.Net and NAnt.
3. Martin Fowler’s seminal article on Continuous Integration
   Not convinced that CI is the best thing since Tivo? Read it and see if you feel the same way afterward.
4. ASP.Net Web Application builds using Nant
   If you’re using Web Application Projects, you’ll need this and maybe this, too.
5. NAnt task for creating IIS application pool mappings
   If you’re developing on Windows Vista, like me, and using IIS7, you’ll want to direct your .Net 3.5 apps to the default application pool, and your .Net 2.0 apps to the “Classic .Net 2.0″ Application pool.
6. How to handle embedded resources with NAnt
   I’m using the Wilson ORMapper, and ran into some trouble, initially, with the embedded mapping.config file. This cleared it up.
7. More good examples of using NAnt to build .Net applications
8. NAnt Contrib
   A bunch of additional NAnt tasks

I should note that CruiseControl.Net is not the only choice for continuous integration. Microsoft Team Foundation Server has continuous integration features, and JetBrains has just realeased TeamCity (there’s a free version), which this guy says is fantastic.

TDD: Learning NUnit

Posted by indomitablehef | Filed under TDD, Tools

While making the switch back to NUnit and learning to use version 2.4, I found some excellent resources I’d like to pass on…

• NUnit “Quick and Dirty” Tutorial [autotestguy]
• Qualities of a Good Unit Test - Jeremy Miller [codebetter]
• How NUnit Finds Config Files [http://nunit.com/blogs/]

Meet the new boss, same as the old boss

Posted by indomitablehef | Filed under TDD, Tools

So, let’s skip the “sorry I haven’t posted in awhile” stuff and just get on with it, shall we?

After five months of trying to get used to the Unit Testing framework in Visual Studio.Net, I’ve decided to go back to NUnit. This is my first experience with version 2.4.x, with the new constraint-based assert model. One of the benefits of unit tests is their self-documenting capacity for documenting your application’s code. Examine the Unit tests, and it should be clear how the application is supposed to work. With the new constraint-based model in NUnit 2.4.x, you can now write your assert statements in a way that reads almost like an English sentence. Here’s a simple example:

Assert.That( myString, Is.EqualTo("Hello") );

Sweet, huh? So, yeah, it’s nice that Microsoft is including Unit Testing with Visual Studio, as well as other tools like MSBuild, etc., but I’m back to believing that they just aren’t ready yet.

Coming up: More agile-enabling practices, like Automated Builds with NAnt and Continuous Integration with CruiseControl.net.

Learning some new skills

Posted by indomitablehef | Filed under Tools

I’ve never been good at drawing, painting, or anything of the sort. While not “color-blind”, I am nearly completely “color-incompetent.” Even so, I’m learning to be a better graphic artist these days. I bought the Adobe Web Bundle last year, with the intention of starting a web cartoon with my good friend, Dan (who performed the indomitableWedding). We haven’t gotten around to that yet, but I’ve been playing the graphic designer at work and on my own little side projects.

I’ve found several good resources along the way, as I struggle painstakingly though creating simple icons and backgrounds that a real graphic artist could probably do in minutes. Some of these are:

The Empire Dezign Photoshop Tutorials - fairly easy to follow, step by step tutorials on how to achieve various effects in Photoshop.

The Web 2.0 Design Kit from Photoshop Lab - how to use Photoshop to create those Web 2.0 design elements

How Web 2.0 Logos are drawn - includes a downloadable style palette for Photoshop

That, and a lot of trial and error. As you may have noticed, some of what’s been driving me to learn Photoshop has been been desire to create sexy-looking Web 2.0 designs for the web apps and blog I work on, both at home and at work. These design resources are more about Web 2.0, as a style unto itself:

The Current Style in Web Design - summing up the state of the art

The Logos and Fonts of Web 2.0

The Visual Design of Web 2.0

More Mind-Mapping

Posted by indomitablehef | Filed under Tools

I found a new mind-mapping application [via rev2] that I like. It’s called Mindomo, and it has an MS Office 2007 style interface, including some nifty formatting options, icons, etc. It’s free, and it allows you to share maps with others. Very nice.