Thursday, October 06, 2011

Stand-up efficiency and effectiveness

I attended a user group meeting last week where a participant asked the question: “How do I keep my stand-ups from going so long?”. He cited greater-than 30-minute time for 10 people.

I didn’t get a chance to talk to him, but here is my advice.

First, discuss the topic with the team. Ensure that there is agreement that long stand-ups are negatively impacting the team. It may be (but it’s unlikely) that the content of the long stand-ups is important to everyone,

Determine root cause. I find a couple of causes that can be addressed in different ways.

Long-winded people offering irrelevant input or input that is relevant to only one other person: Record the contributions of each of the long-winded folks and review with them. Identify specific content that is not relevant to the team.

You’ll often find paycheck rationalization offerings (e.g. “I had my one-on-one with my manager yesterday”).

Or you may find someone simply regurgitating their calendar (managers are likely to be the offenders here).

Or it could be politically driven public thrashings that are more appropriate to share in private (“David – you seem to be checking code in without any tests. Remember, we agreed that we would write tests”).

I’ve seen stand-ups where multiple team members will regurgitate events in which the whole team participated. If the whole team attended the iteration planning meeting, there is no need to mention this in the stand-up.

Start timing folks. If anyone talks more than 2 minutes, make them stand on one leg, or ask them to extend their arm holding a heavy book while talking. Or use a timer (obnoxious alarms are best).

Conversations that are not relevant to the whole team: Institute a “parking lot” flip chart or white board where topics for further conversation can be captured for discussion after stand-up. Ask the whole team to help identify potential parking lot items when they occur; add them to the parking lot when identified and move on. Ensure that those follow-on conversations occur (else you run the risk that folks will continue to insist on in-stand-up dialog).

Use a speaking token and ask the team to be rigid about not talking when they don’t have the token. As conversations occur, the token passing will make it obvious that a conversation is occurring, which should help folks to self-identify opportunities to use the parking lot.

Explain to the team that the stand-up is not the only opportunity for conversation during the day.

Use a laser pointer to have folks point out the relevant stories/tasks on the physical card wall as they speak. They will be less likely to pontificate on irrelevant details if they have no card to point to.

I’ve attended stand-ups of over 40 people that have taken less than 10 minutes. That’s less than 15 seconds per person. Granted, these were teams that were pairing, so oftentimes the contribution of the second of the pair was of the form “ditto Joe”. Still – if a team of 40+ can get it done in 10 minutes, there’s no reason why your “2-pizza team” cannot.

Thursday, June 30, 2011

Prioritizing vs. Sequencing the Product Backlog

A primary tenet of agile software development is doing the highest business-value work earlier. The idea is that you achieve a minimal marketable feature set as early as possible so that a) you can issue releases earlier and b) if the money runs out, you have something more valuable than if you didn't sequence your work in that manner.

Another, less frequently cited agile tenet is to do the riskiest work earlier. The idea here is that you avoid late surprises when risky work turns out to be expensive. Better to discover this expense earlier.

When most folks talk about the backlog order, they refer exclusively to business priority.

I think ordering or sequencing the backlog must take more than just business priority into account. Yes, business priority is important, but so are a whole host of other factors, such as early exposure of risk. Balancing these factors is part of the art of project management.

Factors to incorporate into sequencing decisions:

  • Business Priority

  • Dependency Order: Despite our best efforts to decompose the backlog into independent stories, the fact is, the tension between the INVEST priorities sometimes cause us to define stories that are dependent on other stories.

  • Mixture: The Rock/Pebble/Sand metaphor is helpful here. Consider a bucket at the beach. If you fill it only with rocks, you have a great deal of wasted space in the bucket, due to the space between the rocks. Though it may be unable to accommodate another rock, you may be able to slip in a handful of pebbles, to fill the spaces. Following that, you may be able to slip in some sand, to fill the spaces that the pebbles were unable to occupy. So it goes with an iteration. You don't want to fill your iteration bucket with only large stories, because you're losing the opportunity to slip in smaller stories. For example - if a developer finishes a story at 3pm on a Friday afternoon, you'd probably rather have him knock off a small story in the next couple of hours rather than start a large story.

  • Crowding: Many advise that agile development teams define iteration themes. This is a good concept in theory, as it allows the team to focus on accomplishing a larger goal in the iteration. The risk here is that you have your whole development team working in the same parts of the code base. This can merge issues as the team commits code to the code repository. Consider the source-code crowding problem when sequencing the work.

  • Risk: As mentioned above, the earlier you schedule the risky elements of the project, the more insight you have into your completion date. One element of risk is embedded in non-functional requirements. For example - if you have performance or scalability requirements that are risky, it's better to implement the stories that are sensitive to those requirements earlier.

  • User Feedback: If you have elements of the software for which user feedback is critical to making the right decisions, schedule this work earlier. If you delay these features towards the end, the need to change the system in response to the feedback becomes a schedule surprise. Worse, if you decide not to incorporate the feedback in order to make your date, your users are not just unhappy; they'll feel that their input has been ignored.

  • Exercise the architecture: Scheduling the highest business value work first may avoid elements of the architecture into later in the development cycle. For example, perhaps the "happy path" of execution is deemed the higher business value. This might delay consideration of elements of exception handling to the end of the release. First pass implementations within an architecture are always riskier, and could introduce schedule surprise. It is wise to exercise all elements of the architecture as early as possible.

As I mentioned, these factors are often competing. The context of your project defines which of these dimensions are more or less important. Yes, do the highest business value work earlier, but don't forget to consider these other factors as well.

Tuesday, June 28, 2011

Feedback Manifesto

I have come to value

Verbal, constructive feedback over written evaluations
Measuring output over measuring input
Frank feedback from colleagues over speculative management judgment
Real-time, frequent feedback over periodic high-ceremony assessments

Though the things on the right are commonplace and often dictated by antiquated HR policies, I value the things on the left more. Much more.


Giving feedback

My highest priority in giving feedback is to help my colleagues improve - to benefit them individually and the organization collectively. I always preface my feedback with this sentiment.

I understand that not all recipients are comfortable with feedback. I choose the time and place of delivery to respect this sensitivity.

I always ask the recipient if he/she is willing and receptive to feedback at that time/place and graciously accept "not now" for an answer.

My feedback focuses on behavior and outcomes - not the person.

When providing critical feedback, I consider the constraints and challenges in play at the time of the performance for which I am providing feedback.

I acknowledge intelligent risk-taking as a necessary component of creativity and delivery of value and incorporate my appreciation for it in my feedback.

I ask for feedback on my delivery in order to continually improve my ability to give constructive, valuable feedback.

Receiving feedback

I welcome critical feedback about my performance as a gift, and express my appreciation accordingly, regardless of whether I agree.

If I am not in a good place to receive feedback, I respectfully request an opportunity to reschedule.

I refrain from defensiveness or questioning the motives of the person giving me feedback in order that I can absorb the essence of the feedback.

Monday, June 20, 2011

The case against iteration based re-estimation

Many agile practitioners recommend re-estimating stories at the beginning of each iteration. I disagree with this practice.

For one thing, I believe it's a waste of time. Any value that you might get (which I doubt - see below) from the practice is lost on the time spent.

It's worse than that though. By re-estimating the iteration's stories, you are almost always estimating with a greater level of detail than what you had originally. With this increased level of detail, in my experience, estimates tend to grow.

Why is this a big deal?

Let's try an example.

I come in to my iteration planning meeting with 30 points worth of stories from the backlog. The team commits to those stories, but in re-estimating, the 30 points inflates to 40. In fact, this always seems to happen, as the team gets a little nervous about hitting their historical velocity and they know management is paying attention. Let's assume the team gets them all done. This increases the observed velocity by a third (40 points is a third more than 30). Now, let's say I have 120 more points left in the product backlog to get to the minimal marketable feature set for release. How many more iterations are left?

If you said 3 more iterations (i.e. 40 points per iteration gets you to 120), you are ignoring your team's tendency to inflate estimates. Assuming your estimate inflation rate is consistent (a third), you really don't have 120 points remaining, you have 160 points, or 4 more iterations remaining. Or, calculated another way, if you consider only the initial estimates to calculate your velocity (30), then you can determine that you have 4 iterations of 30 remaining. In both cases, you end up correctly predicting 4 more iterations. Then again - if you use the initial estimates, what value did your re-estimation from 30 to 40 provide you ? I say none.

If you regularly re-estimate at iteration planning meetings, make a note of the original vs. the updated estimates. See if they grow. Consider what impact this is having on the accuracy of your release planning.

OK, I can hear you now. "My team's estimates don't inflate ... some go up; some go down". I haven't seen this, but let's say you do. Let's revisit the example from above with this assumption. You go into the iteration planning meeting with 30 points and walk out with 29. Your velocity is not materially impacted. You are still on track with 3 remaining iterations (roughly). So the question is this: what value did that re-estimation provide? I say none.

When *do* you re-estimate then?

I believe in updating estimates when information arises from experience that pertains to some shared aspect of a subset of stories. For example, let's say that your retrospectives have shown that every time you have a story that hits a certain database, it ends up being much more effort than expected. In a case like this, it makes sense to revist those database stories to ensure that this knowledge is incorporated into those estimates. I call this aspect-oriented re-estimation (adapted from the term "aspect-oriented programming").

Saturday, June 18, 2011

The case against Chickens and Pigs

Schwaber and Beedle's Scrum book introduces the pig and chicken fable to illustrate a point. It goes something like this:

Let's start a restaurant!

What would we call it?

Ham n' Eggs!

Pig: No thanks. I'd be committed, but you'd only be involved!

The story is used to illustrate a difference between
a) the core team members - the "pigs" who are committed to the success of the project (blood sweat and tears maybe?) and
b) outside contributors - the "chickens" who contribute but are presumably not "sacrificing" for the cause

First - I think the analogy is confusing. I always have a hard time explaining it and I haven't heard a coherent verbal description of the concept. There's got to be a better way to make the point.

My higher purpose here, however, is to extinguish the point.

A commonly cited rule is that "only pigs can talk in the stand-up". There is an underlying premise here that anything a "chicken" or non-core team member has to say is wasteful of the team's time. A corollary perhaps: anything a core team member has to say is important.

I have participated in stand-ups where chicken "contributions" have been extremely valuable. Example:

pig: "My computer monitor froze last night; I need to order a new one"
chicken: "Stop by my desk after stand-up. I have a spare"

pig: "Today, I'm meeting with the product owner to review stories for the next iteration"
chicken: "Product owner is out sick today. Let's talk after stand-up about rescheduling or doing it remotely"

Or how 'bout a chicken who participates in the stand-up and shares relevant information. Maybe the normal contribution is "pass" (meaning - there's nothing of import to the team to share). But maybe she's got something important to say:

chicken: "Yesterday, I met with a group of 6 customers to review the prototype. Feedback was overwhelmingly positive. They had some good suggestions. Today, I'd like to sit down with Joe to review some of them and get stories added to the backlog".

What a great contribution to the stand-up! The team gets a valuable shot in the arm (positive feedback) and Joe gets a heads up on some work for later that day.

I've also witnessed many examples of core team members' verbosity and sharing unimportant information.

pig: "Yesterday I had a one-on-one with my manager and worked on my mid-year performance review"

Huh? It seems that this information is being shared not for the benefit of the team, but to justify someone's paycheck for the time they spent in the office.

pig: "I ran into an issue when creating the xyz service. When I compiled the code, I got an Exception in the compiler. I stepped through the compiler assembler logic, but couldn't figure anything out. I then spent about an hour on Google looking for the cause. I finally found this bizarre reference in a Japanese website - thank goodness for Google translation - but it's kind of funny how they botch the translation, I mean, it's not exactly the King's English. Anyway, I translated it, and found someone had this issue because they were running service pack 1 of the IDE without the next two patches on a MacBook Pro running Boot Camp. I installed the patches and still had the problem. I tried a bunch of other things after that and finally got things working. I think clearing the cache did the trick. I thought I'd be done yesterday, but that issue set me back a bit. Barring any other bizarre issues today, I expect to be done with the story by end of day.

OK, I made all that stuff up. This guy needs some coaching on being more succinct. There's some valuable info in there ("hey everyone - make sure you have those two patches", and "I should be done today") but it's buried in irrelevant detail.

My general point is this: I think the chickens/pigs designation is more harmful than helpful. Common sense - about what's valuable to share - should carry the day. Open and honest conversations with *all* participants about expected behavior in stand-ups and beyond should trump this arbitrary dividing line about whose voice should be heard when.

Agile talent market

Do you have agile/lean running through your veins?

I know of a couple of great companies seeking agile/lean talent.

If you're not into travel - perhaps you've been on the road and are looking to settle down, Lab49 has opportunities in New York and London for agile UX, development (.Net/Java/other), and project management talent. Travel is minimal. Smart people. Finance domain.

If you're thinking of moving from a captive arrangement (employee of a company that owns everything you produce) into a more independent contractor arrangement, LeanDog might be the place for you. Their office is on a boat in Cleveland. A big boat. Great management team. Organizational transformation, coaching, training, delivery, multiple technologies, craftsmanship. Business is booming.

Contact me for an introduction to either of these great companies. Warning: both firms are extremely selective.

Monday, January 31, 2011

Agile within a non-agile ecosystem

Agile, like Texas Hold 'Em poker, is pretty simple. The agile manifesto is straightforward. Some agile practices are more difficult than others. Stand-ups are probably the simplest agile technique (though it confounds me how difficult it is sometimes to get people to make them short and sweet, relevant, and focused). Test-driven development is one of the harder concepts to grasp. Estimation with abstract units is sometimes hard to grasp. These are all localized challenges that can be addressed fairly easily with team members that have the attitude and aptitude to change.

These team-based challenges are dwarfed in complexity, in my experience, by the immense challenges of adapting an agile team's relationship to the non-agile ecosystem in which these teams/organizations typically exist. These ecosystems often foist irrational demands on software projects in general (not just those of agile teams). An example: the budgeting process requires you to commit to your scope, schedule and resources up front. You're then damned when you ask for more time, money or request to reduce scope. This isn't just a bad practice for agile teams; it's bad practice for most software development projects.

Cultures that reward individuals based on heroics are another example of ecosystem conflicts with agile philosophy.

Leaders and executives who desire to nurture the agile teams in their organizations would be well-advised to help their agile teams address these "impedance mismatches" between agile and the ecosystem - and to stand up and defend the team's approach against the "that's the way we've always done it" mentality that oftentimes exists within the culture.

Tuesday, November 09, 2010

Simple UX plea

Dear UX designers,

If I'm not authorized to perform a specific function in the application, please show me a grayed-out button or disabled select list, rather than not showing anything to me.

This way, I know that I'm not authorized, and I won't waste hours scanning the application looking in other corners of your app for the functionality you have simply hidden.