Friday, November 27, 2009

Threshold Anxiety

"Kierkegaard, the nineteenth-century Danish philosopher, first described what has come to be known as 'threshold anxiety'. He describes the feelings of a young man who is about to leave home to go out into the world to seek his fortune. As he stands on the threshold of the house, about to leave, he feels that he's turning his back on everything that is warm, familiar, and secure -- what he has known all his life. Beyond the threshold lies the world, filled with all that is unknown and strange. If the young man turns back at this point, he is lost. If, however, he can take the fear of the unknown and turn it into the excitement of the unlimited possibilities which are open before him, he grows in the moment and is alive, as never before."

- Mildred Newmand and Dr. Bernard Berkowitz
How to Take Charge of Your Life

Saturday, November 21, 2009

Squirrel Agile

A client shared this term a few weeks ago that I really liked: Squirrel Agile. Thanks Steve.

I'm sure you've seen a squirrel trying to cross a street. The squirrel starts off on one side of the street, looks, darts out, then sees something scary and retreats. Sometimes he retreats all the way... sometimes he just stops in his tracks. When he starts again, he may continue trying to cross, or may high-tail it back to the original side of the street.

In agile adoption, we sometimes see fits and starts... and retreats - just like the squirrel.

One aspect of agile adoption - self directed teams - seem to me to suffer a great deal from this behavior. Management agrees to self-directed teams in principle, but as soon as the manager fears loss of control, or loses confidence in the team's ability to deliver, the agile squirrel darts back towards the original side of the street. The command-and-control tendencies return.

Other fits and starts occur when you start taking shortcuts in your approach. "We don't need to do a showcase this iteration; we don't have much to show". Or "We're 98% complete with this story - let's take credit for the story in our burn-up, since we'll finish it quickly at the beginning of the next sprint." I'm sure you can come up with other examples.

These behaviors mirror the squirrel's fear. These short-cuts and adaptations are typically not to improve effectiveness or efficiency, but reactions to fear of judgment. My suggestion: rather than darting back and forth as you cross the road, take a deliberate approach with courage.


I just recently discovered this StackOverflow implementation focused on Agile issues: Seems to be low traffic at the moment, but perhaps my agile friends can find some value there.

I'm not quite sure why it's necessary to have a separate site from StackOverflow, since the tagging mechanism in StackOverflow permits differentiation of topics (e.g. "agile") and cross tagging of topics (e.g. "agile" and "BI") that might not otherwise find a specific home on a specific site.

Wednesday, November 18, 2009

Task breakdown - To do or not to do

I've had this conversation with agile folks over the years. It's about task breakdown. This is not entirely fair, but I'll say it anyway: I consider it one of the "thou shalt" approaches of agile by the numbers... or by the tools.

Assume a master story list with estimates based on points.

The iteration planning meeting (IPM) looks like this:

Foreach Story in Candidate list:
  • Product owner: Describe the story
  • Team: break the story down into tasks
  • Team: estimate the effort for each task in hours
  • Iteration Manager: Increment the task hours counter by the amount of the task hours for this new story
  • Iteration Manager: Measure the task hours against the team's ideal capacity and report how full
  • Team: If iteration is full (based on ideal/actual capacity) leave foreach

As the iteration progresses, we see this:

Foreach Day in iteration:
  • Team member: update the remaining task hours for each of his/her tasks
  • Iteration manager: udpate/publish burn-down
  • Iteration manager: interrogate team members whose tasks are moving "slowly"
There are some benefits to breaking work down into tasks:
  • Intra-story progress can be measured by the iteration manager who can address slowness ("John: you reported 2 hours left yesterday morning and today you're still not done... what's up?"
  • The aggregate burn-down should show you how close you are to your target on a daily basis
My issues with this approach:
  • Tasks become the center of the reporting universe within the sprint and so progress against task completion may mask poor progress against story completion (e.g. due to undiscovered tasks)
  • Team "feels" progress based on completed tasks, rather than on the real objective: completed stories
  • Weird reward structures get created ("John - yesterday you said you had 12 hours remaining on the task, yet you finished it. Great job!")
  • Weird negative feedback is inferred ("John - yesterday you said you had 2 hours left and you're not done yet": inference - you're not working hard enough)
  • Daily reporting requirements implies distrust of the team to raise issues or problem: "If I don't keep an eye on the task level reporting, I can't hold them responsible on a daily basis"
  • Estimating iteration capacity based on ideal task hours may conflict with iteration capacity planning based on historical velocity. What happens if my hour capacity is reached in the IPM, yet my booked story point total is below my historical velocity? (I'll save the tendency for re-estimation for another blog entry). Reminds me of the old adage - experienced sailors never go to sea with two compasses. They go with one or with three, because if the two disagree, you have no idea which one is right.
I feel that task breakdown should be done only in limited circumstances and only to the degree where the benefit outweighs the admin cost:
  • if the team feels that the benefit outweighs the cost
  • if a developer or pair needs to break the story down into tasks in order to understand the work to be done, go for it (but don't worry about tracking all the details in a tool)
  • Perhaps if your team is not mature enough to understand how to break down a story into tasks, and so you must spoon feed them with tasks (even then, I think it better to have them pair with experienced developers to learn how to become self-sufficient.)
  • If the tasks to implement a story can be parallelized (different developers or pairs can be working on different tasks for the same story in parallel)
  • If your team has "silo dysfunction" that requires choosing stories that don't overload a skill or domain area on the team
Example: let's say you have a project with equal parts C++, Java, and Fortran code and you have C++, Java, and Fortran programmers who can't span technologies. In order to keep from overloading one technology group, you must choose stories that balance the work across those silos. Sometimes, the only way to create this balance is to task out the work across technologies, to ensure you're not overloading one camp.
By the way - removal of this dysfunction over time is recommended.
My feeling: Using the whole team's time in the IPM doing task breakdown and estimating tasks is usually wasteful. I recommend that task breakdown be undertaken, if necessary, at the last responsible moment... when the story moves from "ready" to "in development", rather than at the IPM. The developer or pair picking up the story should do the breakdown.

Task breakdown smells (and yes, I've seen them all):
  • The tasks look like this:
Design the code
Write the code
Write the unit tests
QA the code
Why is this an issue? You're probably doing mini-waterfalls, not simple, evolutionary design
  • The "remaining work" for a given task is reduced by 8 hours (or perhaps 6) each day
Why is this an issue? Team members are not providing real data, they're telling the iteration manager what he/she wants to hear
  • The hour-based iteration burn-down (or, as I prefer, burn-up) is practically a straight line.
Why is this an issue? In reality, many things take more or less time than imagined. Straight lines are an indicator of "cooking the books"
  • The iteration manager asks people throughout the day... "How many hours do you have left on this task? When will you be done?"
Why is this an issue? It's command and control leadership and dilutes the power of the self-directed team.
  • Iteration Planning Meetings (IPM's) take more than an hour and are more about numbers than about story understanding
Why is this an issue? You spend more time taking swags at hour estimates than you do actually thinking about the functionality to deliver
  • The iteration manager applauds the team for accomplishing "400 hours" when their calculated capacity was only "350".
Why is this an issue? It's focused on task hour accounting and doesn't imply anything about how successful the team was at completing stories
I've worked on projects with both approaches - task breakdown with hour-based burn charts and no-breakdown with point-based burn charts. My suggestion is to avoid speculation about the superiority of doing it the only way you've ever done it and at least give each approach a fair shot.

I remember my elevated caffeine intake as a developer at interminable IPM's where I just wanted to get on with the work.

I remember debating minutia about whether a task belongs or not, and whether it's 8 hours (by Kurman) or 16 hours (by someone else). Yes - all those issues that the point-level estimating deigns to abstract by using relative estimates can rear their ugly heads in hour-based estimating. (By the way - if your solution is to assign the tasks at IPM time, you'll suffer from other problems).

I remember being the first to pick up a story as a developer and finding a better approach that implied a totally different task breakdown. Yes, I used the new approach, and yes I had to fix the accounting (XPlanner) to reflect my new approach. (Umm... on second thought - I just left the existing task list in place and fudged the actual hours into the old list. You might think this was wrong. I knew, however, in my heart of hearts, that the micro-accounting really didn't matter).

I've also worked with teams that have eliminated task breakdown/estimates and felt freed by the defenestration of the bureaucracy.

This tends to become a heated topic of conversation. In the end, the best answer, I think, is to let the team choose the approach that's right for them. Mandating task breakdown or mandating against it is almost always wrong. Drive the questioning to determine if task breakdown adds value or not, and try it both ways. If you have an agile management tool that requires tasks in order to do reporting, and you want to avoid defining tasks, just create one task per story that says "Do it". (In parallel, find a different tool that provides more flexibility).

scrum terminology decoder:
iteration = sprint
iteration planning meeting or IPM = sprint planning meeting
iteration manager = scrum master
iteration showcase = sprint review = sprint demo
master story list = product backlog (or possibly release backlog)