Tag Archive: agile


Backlog Refinement Meeting

Note:  This post was originally published on January 15. 2014, on AgileAtlas.org, a site of Scrum Alliance.  This site is now defunct.  Re-posting the article here.

Authors: Aashish Vaidya & Dorothy Murray

In Agile development, we engage in adaptive planning based on two of the 12 Agile Manifesto principles of “Welcome changing requirements, even late in development”; and “Regular adaptation to changing circumstance”.

Product Backlog Refinement is a core adaptive planning activity in Scrum.  Agile Planning is an ongoing activity throughout the project, not just one-time upfront activity done at the start of the project.  It is generally assumed that most team will have a Product Backlog that is not well defined, large and not finely grained.  The Product Backlog also doesn?t remain static, as new ideas flow in, as existing product needs are refined, new discoveries are made, and as priorities and business need change throughout the project timeframe.

Inadequately refined Product Backlog can result into many team issues such as:

  • Performing refinement during Sprint Planning leads to long, contentious meeting that blows past meeting time-box.
  • Sprinting on stories with great deal of ambiguity leads to unfinished stories and results into volatile team velocity
  • Work  is done on stories that have lesser business value, or are of lower priority
  • Delivery of user stories fails to meet desired functionality or fulfill stakeholder needs
  • Change of scope or priority during in-progress Sprint

Constant and incremental Backlog Refinement becomes a highly desired activity that a team must master to become more productive.  For newer and maturing Scrum teams, one effective way of perform Backlog Refinement is to conduct regular Product Backlog Refinement meetings outside of the Sprint Planning meeting.  Many Agilists recommend spending up to 5-10% of team?s time in planning future Sprints and Releases.   Over time, the need for formal meetings recedes as the team matures and is able to refine its backlog constantly and incrementally.

Generally, teams whose Sprint durations are from 2-4 weeks can benefit from conducting weekly meetings during non-Sprint Planning week(s).  For teams with 1-week Sprint duration, it may be more efficient to conduct refinement during Sprint Planning meeting itself.

The attendees to these meetings are those from the Development Team, but other subject matter experts, whose input is required or desired, should be invited as well.  Here are some additional pointers to consider in organizing Backlog Refinement Meetings:

  • ScrumMaster, in consultation with the Product Owner, organizes and facilitates the Refinement Meeting during non-Sprint Planning weeks.  We recommend the Refinement Meeting should be 1-2 hours per session.
  • Teams that don?t regularly refine their Backlogs should consider additional meeting time and higher meeting frequency.
  • Product Owner brings an ordered list of prospective stories for an upcoming Sprint.  Team reviews the list of stories, asks the product owner clarifying questions, refines the stories, acceptance criteria, and estimates un-estimated stories.  The goal is to have an ordered list of stories that are examined with the INVEST criteria and can be set to Ready to be worked on during the upcoming Sprint.

Outside of the regularly scheduled weekly Refinement meetings, a Team may also decide to have special, extended sessions to plan for subsequent Release or for some other type of mid planning horizon that extends beyond a single Sprint.  The rationale here is that it allows the Team and the Product Owner to refine a larger portion of their Product Backlog, and set up a workable Release roadmap.

A team can spend their time engaged in these activities:

  • Revising larger or coarsely defined stories into finer grain, well-defined stories for subsequent Sprints.  Consider merging other Product items together for better delivery preparation.
  • The Product Owner and the team engage in pruning and removing Backlog items that are no longer needed.
  • The Product Owner and the team add items that are newly identified and refine them and determine whether those are needed during upcoming Sprint or can be road-mapped into future Sprints.

The Scrum Core framework only asks that Backlog Refinement activity takes place.  But engaging in planned refinement meetings between Sprint and Release Planning sessions is one practical way for agile teams to achieve adaptive planning, and deliver on Sprint and Release objectives.

Note:  This post was originally published on November 22. 2013, on AgileAtlas.org, a site of Scrum Alliance.  This site is now defunct.

Authors: Aashish Vaidya & Dorothy Murray

Agile development is all about adapting to change. It is explicitly called out in the second principle behind the Agile Manifesto, “Welcome changing requirements, even late in development.  Agile processes harness change for the customer’s competitive advantage.” This is why, in Scrum, the Product Owner is responsible and accountable for maintaining the Product Backlog. The Product Owner has the final say over the ordering the list of ideas for a product. This includes selecting a smaller chunk of the Product Backlog as a Sprint Backlog. This gives the Product Owner, the lever on adapting to changing conditions.

The Sprint Backlog is the team’s forecast on completing work for the Sprint duration. It is expected that a team commits to reasonable amount of work based on its velocity and does everything within its power to deliver on these commitments. It is also expected that for the duration of the Sprint, the Product Owner or any other stakeholder is asked to maintain the Sprint Backlog constant. A team also is required to maintain its sprint duration constant so that it can deliver a product increment on a regular cadence.

However, under rare and extenuating circumstances, when a Product Owner or the team realizes that they cannot deliver on their stated Sprint goal, a Sprint has to be canceled or an Abnormal Termination of a Sprint is required.

Reasons for an Abnormal Sprint Termination may include, but are not limited to:

  • The company changes direction
  • Market forces render the work obsolete
  • A major technology change occurs
  • A better technical solution is found that makes the current Sprint’s activity throwaway work
  • Fundamental and urgent external changes that invalidate the Sprint Goal or the bulk of the functionality
  • Urgent bug fix or feature development request that cannot wait until the normal completion of the Sprint

Often times, Product Owners or other stakeholders interrupt teams and redirect them to new goals and priorities while a Sprint is underway. In many cases, this redirection isn’t due to critical needs that cannot wait, but it is because a Product Owner failed to think ahead. If redirection happens on a regular basis, a team will not develop cadence and produce high quality working product increment – the goal of every Sprint.

The act of formally canceling a Sprint makes visible the cost to all stakeholders, as there are overheads associated with stopping a in progress Sprint and in conducting another Sprint Planning meeting. Terminating the Sprint is a good way to ensure that the benefits of changing a Sprint backlog mid-Sprint really outweighs the cost.

The practice follows these general steps:

  1. Certainty by the agile team and product owner that the Sprint goal cannot be met or has changed significantly. The benefit of stopping work mid-Sprint outweighs the costs.
  2. Product Owner calls for Sprint to be abnormally terminated and makes this decision visible to all stakeholders.
  3. If there is critical emergency (such as production down), the agile team attends to the emergency.
  4. The team reflects on the reasons for the termination of Sprint, and plans on taking corrective action, if any are required, during next sprint.
  5. The Agile team and the Product Owner conduct a new Sprint Planning meeting.

Apart from legitimate but rare reasons, Abnormal Termination of Sprint is also a reminder, especially for transitioning organizations new to Agile practices, that every new request shouldn’t always be treated as an emergency.

Too Much Work in Process?

credit: Richard Smith via Flickr

Creative Commons  Credit: Richard Smith via Flickr

Does your team’s burndown chart look like one below, where a small number of stories accepted during the first part of the Sprint and then acceptance rate hockey sticks towards the end of the Sprint?  In the graph, you can see that acceptance rate is less than 10 story points (the green bar) for the first 14 days of a 21 days Sprint.  And then it gradually rises to 20 and rockets up in the last 3 days.  This graph  is for a Scrum team that follows a 3-week Sprint duration.

 

Iteration Burndown Chart

Iteration Burndown Chart

 

 

Or represented a different way, here is team’s cumulative flow diagram from the same Sprint.  Note, the team, within first 3 days of a 3-week Sprint, has put 46 out of 66 story points in play?

Cumulative Flow

Cumulative Flow

Does your team see any ill-effects with taking on too much work in process?  Does the testers on the team get squeezed trying to jam through 40-60 hours work effort into the last 1-2  Sprint days?  Are they compelled to make risk-based testing decisions?  Does your team, despite its best intention end up cutting corners by writing crappy code, carrying over defects and accumulating technical debt?

Does your team put in overtime to complete all the in-flight stories during the end of the Sprint?  During your story demonstrations, does your team leave your Product Owner disappointed, because it can’t accomodate simplest changes and force her to write new stories in the backlog to cover minor changes?

If your team activity resembles these charts, or encounters some of these symptoms, it is possible that it is taking on too much work in process (WiP).

 

Little’s Law and Queuing Theory

Let’s do a quick review of queuing theory and something called Little’s Law as formulated by John Little.  Little’s Law is expressed using a simple formula:

L = λW

Here,

L =average number of items in the queuing system,

W = average waiting time in the system for an item, and

λ =average number of items arriving per unit time

 

Sometimes, Little’s Law is also restated as: CT = WIP/TH.

Where, CT = λ = cycle time, for the average time when an item enters a system to the time it exists a system; WIP = L = work in process, the number of items in a queue and TH = W = throughput or the average output of a process.

It follows from this that the size of your queue is directly proportional to your throughput.

So, if you are trying to improve your cycle time, like how fast a story is accepted, then you have two options:

a)     Improve the throughput of your process/system

b)    Decrease the average number of stories you work on simultaneously (the WIP in the equation – the queue)

Typically, throughput is a measure of productivity and may largely depend on a team’s skillset or on the system the team operates in.  To make productivity or structural changes take time.  For example, a team might realize they can get more efficient by putting in place test automation and save time as compared to manual testing.  However, a team may not have anyone on the team with test automation skills.  So, it will need to acquire those skills, which means, a team member will need training, and then learn to implement test automation.  These activities take time.

Or say, your team needs to promote code to the staging environment as a part of your story acceptance criteria.  But, to promote code you need a deployment resource from the release team.  And if this resource is shared between few teams, as is typical, it would mean systemic wait time, till the resoruce is available to complete the task.  You can decrease this wait time by: 1) get a deployment resource dedicated to your team, who can do code promotion; 2) have a team member acquire those skills; or, 3) if you have someone with those skills on the team, lobby for changes to department policy that requires that only a deployment engineer can do deployments to staging environment.  To implement any of these  options will take some time to put in place.

So the best lever a team has, to decrease cycle time, is to decrease the average number of stories they work on at any given time.

 

 Why is Less WiP Better?

Queues are all around us: traffic during morning and evening commute, waiting for a restroom at a ballpark during half-time, a doctor’s office, waiting at a grocery checkout counter, and many more.  In lean terms, queues are considered inventory and inventory represents waste.  And I am sure when impateintly wait in a line, we can attest that it is a waste of time.

With Scrum, you are already working in delivering working software more frequently compared to traditional methods.  So, many Scrum teams may not even care that within the Sprint boundary, there is too much WiP.  Besides, Agile principle only states, “deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale”.  But, nowhere does it say, reduce your WiP even further.

Or it could also be that teams prefer higher WiP to provide them with that extra impetus to complete their work as the  Sprint-end deadline approaches.  Or a team doesn’t mind putting in extra overtime during the last week or last few days of the Sprint.

But, I suspect many teams and team members want to achieve realistic and sustainable pace in meeting their Sprint goals.  They are motivated in getting constant feedback with their business partners or POa by showing working software, early and often.  And they don’t want to systematically sucuumb to bad quality or crappy code.

As a matter of fact, Rally Software (Disclosure: I am Rally user), which conducted empirical analysis on teams and summarized their findings in The Impact of Agile Quantified (Note the paper is behind an free access wall).  They found that teams that aggressively control WiP, cut their time in process in half.  And those that control their WiP, have 4 times better quality compare to teams with the highest WiP.  So if faster feedback (or faster time to market) or higher quality is desired, it pays to lower your WiP.

But, note that there is an optimal WiP for your team.  If you push your WiP too low, you can lower your productivity.  It was found that teams with very low WiP (0-2 WiP) had lower throughput.  So there is certainly a balance that needs to be struck between too much and too little WiP.

 

Ways to Decrease WiP.

Generally, if your team uses some Agile Management software, they probably have a built in report that can show your team’s Cycle/Lead Time.  Once you know the Cycle/Lead time, you can start setting up targets to decrease the WiP.  So for example, if your team’s cycle time is 10 days, and your Sprint backlog is 10 stories.  Your team might decide to set a target of starting with only 5 stories, get them designed, analyzed, developed and tested.  Review the stories with the PO, get feedback, and get them accepted and move on to next set of stories.  This is the basic concept of Scrumban, melding the Kanban practice of controlling WiP within the Scrum framework.

In order to lower your WiP, each team will have to experiment to see what works best.  Here are some potential things to try:

  • Work with the PO to de-construct features into smaller stories during Backlog Refinement meetings so that they can be potentially completed within a week.
  • Set a team agreement on having only X number of stories in-progress.
  • Set general guidelines on how to “swarm” when team WiP limit is met.  For example, if WiP limits are met, an idle team member could: 1) help take up task on existing WiP story 2) pair up with someone to learn skills of a constraint skillset 3) Refactor code or test automation code 4) Swat down defects, 5) improve autoamted test coverage.  Have team members “swarm” on a few stories, instead of trying to put all work in play.

As you try to limit WiP, even with the above swarming guidelines, you will find that some team members might idle.  And it will feel counter-intutive.  But, you are not trying to achieve optimal efficiency at an individual level, but at a team level.  If you manage to lower WiP, the team will see that it cycle time is improved, quality is better, feedback loops are tighther,  there is less risk in meeting Sprint goals, and potentially a team will acheive more sustainable pace, experience less volatile team velocity.

Reduced to soundbites the lower WiP mantras are:

Don’t WiP it, Ship it.

Stop Starting, Start Finishing.

 

References:

Paper on Little’s Law with few examples:  http://web.mit.edu/sgraves/www/papers/Little’s%20Law-Published.pdf

Poppendieck, Tom and Mary, 2007, Implementing Lean Software Development: From Concept to Cash,  Addison-Wesley Professional.

 

US National Archives - Creative Commons image

Workers assembling radios. Photographer Lewis Hine. US National Archives – Creative Commons image

Typically in plan driven model, scope is fixed and the cost and schedule are variables.  Many large scale software projects were and continued to be implemented this way.  In many instances, when a particular scope is desired within a giving time-frame (fixing the schedule), plan driven projects add resources.  But as we know simply adding resources to a project doesn’t always bring about the desired goals.  As a matter of fact, if resources are added late on a software project, it actually has an adverse effect.  This was indeed observed by Fred Brooks in his book The Mythical Man Month, also known as Brooks’ Law: “adding manpower to a late software project makes it later”. 

With Agile software development, the triangle gets  inverted – where cost and schedules are fixed and the scope is variable.

Waterfall-Agile Triangle

Even for Agile projects, there could be instances when a fixed scope is desired within a given time period.  For example, when an external entity drives a compliance or mandated project.  In those instances, the only lever stakeholders may have is adding resources for a delivery with fix scope and schedule.  But, are there better ways to add resources or capacity to an Agile project without falling in the same traps of experienced with plan driven methods?

Before we answer that, lets briefly consider teams on Agile projects.  Agilists  have generally made 2 recommendations for effective teams:

  • Keep team intact or stable for a long periods of time
  • Keep team size between 5-9

A recent paper called The Impact of Agile Quantified seems to support these two recommendations out through empirical data.

Stable teams, defined as having less than 10% membership change in a 3 months period vs Unstable teams defined as 40% variance in their membership tend to:

  • Have more throughput (volume or work)
  • Have less variance in their  throughput (they are more predictable)
  • Have less defect density (higher quality)
  • Have less time in process (better time to market)

From the same research findings, teams of 5-9 team members have the most balanced performance when it comes to predictability, productivity, quality and responsiveness.   Generally, smaller teams (of 1-3 people) are 40% less predictable and have 17% lower quality; however, they do have 17% more productivity.

Instability in Agile teams can happen sometimes which may not be in direct control of the resource managers.  Like, for example, a team member gets promoted or changes positions or leaves the company altogether.  In some instances, a resource manager may also have to move team members due to skills match, team dynamics or performance considerations.

So given these findings, what would be the best options in adding resources to an Agile project or a release?  Creating a whole new cross-functional team of 5-9 team members during early to mid part of the project along with a Product Owner and a ScrumMaster (presuming you are following Scrum) would be the best option.  This will allow added capacity without running foul of the Brooks’ Law.

But if the budget add doesn’t allow addition of an entire new Agile team, then other viable options becomes little less ideal.  One option would be to add team members to an existing team to make them more cross-functional or remove a crucial skills constraint, so the team becomes more self-sufficient.  The other option is to shore up smaller teams that have less than 5 team members.

Alternatively, you can level-off a larger team and form 2 teams.  Take for example, there is additional funding for 4 team members and Original Team A makeup: 9 team members + PO + SM.  Form Team B: 5 team members – 3 new team members + 2 team members from Team A (presumably a team member can initially serve as SM initially) and  a PO.  Now New Team A would be: 7 team members + PO + SM.  Since, both teams would be within the ideal size range, and assuming you are able to maintain the cross-functional nature of both teams, you can still reap the benefits of higher throughput, better quality, more predictability and better time to market.  Again, these aren’t the best options because affecting existing well performing teams will inevitably create an initial setback as new teams re-form and then re-norm.

Ideally, if short term results are desired, say within a quarter, scope reduction is probably still the best option instead of disrupting Agile teams.

Recently, an article that I co-wrote with my colleague, Dorothy Murray, on Abnormal Termination of a Sprint got published on the Agile Atlas.

The site is managed and curated by Ron Jeffries and Chet Hendrickson.  The site’s purpose is to become an encyclopedia of information about Agile and related methods.  Currently, the site is supported by Scrum Alliance.  So has more Scrum-centric information.  It is organized into Core Scrum, Common Practices and Commentaries.  The Core Scrum has Scrum Alliance sanctioned description of Scrum.

Our article got published as part of Common Practices, which are considered generally consistent with Scrum, and useful in many cases, but those that haven’t risen to Core status, yet.

(image from geograph.org.uk)

In one of my previous post titled You Might Not Be Agile If , I outlined some agile anti-patterns.  Recently, I come across couple of anti-patterns that make good fodder for discussion.  Both these patterns are something a Scrum Master should be able to avoid, corrrect.

Anti-Pattern: Only using partial team to size the backlog

 
The first one is where a team used only developers in sizing stories.  Well, is it any wonder then, that the team discovered itself in bind? Testing tasks turned out to be too large.  Surprised? The sprint committments got  jeopardized?  And is it suprising that team members ended up putting in extra hours to try and salvage the sprint?  In this particular instance, the reason was:  some team member felt the sprint planning sessions were getting too long.  So a select few team members pre-sized the backlog and tasked out the stories ahead of the planning meeting.
 
Now, there is a reason why we strive to construct cross-functional teams.  And we prefer using a consensus based estimation process such as planning poker.  We want to avoid, what some quant-driven companies have started calling –  HiPPOs hijacking and monopolizing the decision making process.  HiPPO stands for highly paid person’s opinion or alternatively, a highly positional person’s opinion. 
 
If a team lead, a Scrum Master, a Product Owner, a single team member, or a functional group “Hippos” the team, then that stunts the team from self-organizing.  You are back to command-and-control decision making structure and you miss out on the wisdom of the team – not very agile!  The planning poker or similar agile estimation process involves all team members, and it expects that all views and perspectives are allowed to be expressed, shared and discussed.  Two good things come out of the process, one is that you get a team members’ committment, not just compliance.  The other is that you get a much better and realistic view of your work, and you have intrinsically motivated agile team that owns the estimate and will do everything in its power to deliver on it.
 
But aren’t agile teams suppose to move fast?  Time-boxes are of course very important, but so is discipline.  If you don’t involved all team members, or if you short-change the consensus building process, you get uneven results.  What’s more involving the team allows it to gain tacit knowledge through meetings and conversations, which makes them better at getting things done.   
 
At the same time, agile teams are not deliberating, debating bodies.  They exist to produce great working software.  Reason given here was that the team wanted to have a shorter planning meeting.  So let’s talk about that.
 
The general rule of thumb that has worked for many teams is to allocate 1-2 hours per sprint week for the planning meeting.  Say you have a 3-week sprint, then normally your team should allocate anywhere from 4-6 hours of planning.  To make sprint planning go faster, there are few practices you can follow:
  • PO has already communicated her priority stories for the upcoming sprint during grooming sessions, which are taking place during off-planning weeks.  All prioritized stories are well understood and sized by all team members.
  • Most agile planning software allow you to copy a story.  So a good time saving practice is to create a “template” story which contained often encountered tasks.  The Scrum Master as part of his sprint planning session preparation can then copy this story, overlay the actual story card and the acceptance criteria.  This approach has another benefit too.  You can embed tasks associated with your story done criteria, which then serves as a good checklist for the team.  For example, if  your team forgets peer code review task on every story, then having an explicit task  as part of the template serves as a good reminder for the team to include for every story.
By the way, the team size matters too when it comes to having an efficient sprint planning meeting.  Having a goldilock-sized team of 7 (plus or minus 2), allows consensus building to occur without a huge time sink and makes for faster sprint planning.  I recall, a team that chose to go with 15 team members, their planning meetings used to drag out to almost two full days (14-16 hours) for a two week sprint!  How productive is that?!
 
Anit-Pattern # 2: Committing on more work than what can be delivered.
But is there maybe another deeper anti-pattern as a cause for this team that chose expediency over allocating “right” amount of time for sprint planning.  Could be that, they are trying to shove a whole lot more work than they can realistically take on during a sprint?.  (No time to waste, can’t you see, I have more code to shovel over to production, every day, so I will take any and all shortcuts possible, especially if I can avoid having uncomfortable conversation with my stakeholders!)
 
If that is really the issue, than there are good practices you can follow.  I have found that when doing capacity planning, it is better to start the team’s capacity at 80%.  So, if you have 14 working days (counting 1 sprint day towards demo, retrospective and planning meetings for a 3-week sprint), each team member will have , roughly, 90 working hours (14x8x0.8).  Using 80% capacity means that you do not have to account for tracking all the overhead minutiae such as company or team meetings, emails, water cooler chats, birthday celebrations, or just team members taking time to be helpful, or honing their own skills.  (An aside: this is also another reason, why I think it is a bad idea to use agile lifecycle management software for project time tracking.  It distracts from delivering good software and makes accountants out of team members).
 
Then, you subtract any “planned” PTO time.  Next comes any production support work that your team generally has to respond to.  The percentage varies from team to team.  Using a rolling 3 sprint average to even out the spikes as your starting point and adjusting according to your circumstances, works.  It is also a good practice to task out 1 or 2 more stories, over and above your team velocity.  So in case, you end up using less than your allocated production support capacity, you have a ready story to work on.
 
And finally, subtract any earmarks from your capacity.  For instance, many teams negotiate with their Product Owner and stakeholder, part of their capacity towards fixing defects, or doing test automation, or for code refactoring. 
 
If your team doesn’t account for all these things up front, you are probably operating on an illusion that you are going faster.  In reality, you are probably spending more and more time in remediating code and responding to production emergencies.  If you want to read more on this anti-pattern, check out Mark Lawler’s recent post called Sprint Planning Like It’s 1999
 
You say,  if I do all these things, there is no way, we are going to converge towards our project goals?  Maybe.  But, equipped with data, you may have a difficult, but an honest conversation with your stakeholders.  Should quality and delighting customers be sacrificed to meet the deadline, or should other creative solutions be explored?  Should we invest some time in building good software, or should we pay a whole lot more later?

Mark Lawler in his post about story points, says he wants to “raise a glass of Champagne to toast the folks who came up with the concepts of ‘story points’.  You know that way of estimating work without actually saying anything useful or making any commitment to your business customers?”

I can certainly see how the whole idea of stories and story points can be confusing, especially to new teams and certainly to business customers.  But, I would like to offer a counterpoint and say story point estimation is a very useful, and efficient technique. 

Teams are asked to make a binding estimate, generally, at the beginning of a project, when they have the least amount of familiarity and information about a project.  Here is how Scott Adams illustrates this point through Dilbert:
 
 
Let’s look at what a story is.  A story is a bite-sized, digestible “requirement” that can be completed in a time-boxed interval.  It is stated from a perspective of a real user.  A story is just enough information written down and a promise between the product owner and the delivery team to have a future conversation about the rest.  Both the product owner and the team understand that there is some amount of uncertainty involved.  The product owner is not expected to know every detail of the story upfront, and the team doesn’t always know how they are going to produce that work.
The alternative used to be a detailed business requirements document or a product requirements document.  The PM and the business stakeholder then use these documents to obtain an estimate from the delivery team.  Or many times, engineering managers or leads arrive at these estimates, even though, they might not actually do this work themselves.  Teams are then held to this estimate, no matter what new information the team learns about themselves and about their project as it unfolds.
So how good are humans at estimating in absolute terms?  See if the following conversation sounds familiar to you:
An engineer’s significant other is preparing tacos for dinner.
Significant Other: How many tacos should I prepare for you, 3 or 4?
Propeller-head Engineer:  Well, let me see, I am a little hungry.
Significant Other: So 4?
Propeller-head Engineer:  I am not sure.  I had a smaller breakfast than usual.
Significant Other: So you are really hungry?  Make 5?
Propeller-head Engineer:  But, then I had this big lunch when I went out with my friends.
Significant Other: So then…3?
Propeller-head Engineer:  But, see I then went to the gym in the evening?
Exasperated Significant Other: So you’re hungry again?
Propeller-head engineer:  But, see my workout was really “light”.
Angry Significant Other: Then you are not that hungry?  Darn it, Propeller-head, will you just tell me how many tacos do you want to eat?
Propeller-head Engineer:  Tell me what kind of beans are you using?  Are you using sour cream, or guacamole?  How caloric is the salsa?
So when it comes to estimating and committing, we tend to over-analyze and take too much time to arrive at a precise answer.  On the other hand, we are actually good at comparing.  Back to the Significant Other and Propeller-head Engineer:
Significant Other: Damn it. Propeller-head, why do you always have to be so difficult?  Tell me, are you hungrier compare to last Friday, when we had tacos?
Propeller-head Engineer:  Yes I am.
Significant Other: You ate 3 tacos then.  How much hungrier are you compare to then?
Propeller-head Engineer:  I am little more hungrier than that, so let’s go with 4.
Bam, having a reference point helped speed things along (that or it must have been the wrath of the Significant Other)!  Estimating is relative sizing, so a team compares one story to others and arranges in generally like-sized groupings.  The story points are just a numeric values we assign to these piles.  Three considerations go into sizing a story:  effort, complexity and doubt.  So along with effort and complexity, uncertainty is built into these estimation.  What was the alternative in the past?  As other agilists have pointed out – the delivery teams were trained  in stating precise inaccuracies.  At the inception of a project, when the agile team and the business partners have the least amount of information for their projects, if we ask them to be prescient and produce accurate estimates; they will produce estimates, and precise ones, at that.  Just not accurate ones!
 
For example, I was just reminded, at a recent training, regarding the concept of accuracy and precision.  If I state that the value of Pi is 3.7909430, it is very precise, but it isn’t very accurate.  If I say 3, I am accurate, but not very precise.  When we are doing newer things, we are not always so good at them at first.  We, in the software business, to use an analogy, are more like chefs, and less like short-order cooks.  Chefs concoct new recipes, so it is hard in beginning to accurately and precisely figure out how long it will take to come up with a winning recipe.  A short order cook on the other hand, is handed a recipe and has a pretty good idea of how much time it will take to cook up the recipe.  Software engineers, if they are more familiar with their problem domain, can become more accurate as well as precise.
Picture a conversation between a PM and a delivery team:
PM: We need to produce an estimate to develop an integration with our business partner.
Delivery Team: Ok, do you have the integration specs? Do you have API Specs from the partner?
PM: No we don’t, but assume that we will communicate via FTP.
Delivery Team: And how many “functions” do you think we are going to need.
PM: Assume about 10 functions.
The delivery team talks amongst themselves.
A Dev Type: Let me look at our existing code for an hour – and I will tell you.  He returns two hours later.
Dev Type: Look, we already have done this type of work.  The existing sFTP protocol we  developed has about 15 functions, which took us about 6 weeks to develop and test,  So I think, we can turn this around in 2 weeks.
A test type:  And it will take me 2 weeks to test.
Delivery Team to the PM: We can do it in 4 weeks.
PM: Well guys, sorry to break this to you, but we need this within 3.5 weeks, otherwise, we will be off our critical path.
Two weeks later.
PM: Hi guys, the specs came in, our communication is via a web service.
A stunned Delivery Team: But, we haven’t done any web services development, and certainly not with this partner.  What’s more, the infrastructure folks alone are going to need a week to open up the firewall and communicate with our partners.
PM: I know guys, this is tough.  Oh and one other thing – since we got the specs a little later than expected, we will need you to get this done within next 3 weeks.  Sound good?  Thank you guys, you are the best team I have worked with.  I know you will come through.
 
The PM, in the above example shorten the duration, but did not take into consideration the effort involved.  This generally happens when stories are express in ideal days – effort or duration get enmeshed.  Or at least, effort gets overlooked.  in which case earth days, become just as arbitrary as story points.  Comparing one team’s estimate against another becomes just as problematic as with story points.
Extending Mark Lawler’s airlines example, if say you were giving an estimate of 30 minutes delay, both times.  But say, by two different airlines – Southwest Airlines and United Airlines, which one would you trust?  Most people would probably pick Southwest as they have a stellar on-time record.  With United, who knows?  Unit of measurement is still hours, but Southwest and United Airlines estimates aren’t comparable as United doesn’t have a comparable on-time record.
 
With story point, if our customers have another key piece of data – the team’s velocity, they can also start getting better predictability.  Even when plans change, which we know, they inevitably, do.  Let’s say for example, an agile team estimates its release backlog contains stories worth 100 story points.  After sprinting for 3 sprints, they establish their average rolling velocity to be 10 story points per sprint.  Now based on this, the product owner will know that it will take another 7 sprints to exhaust the backlog (70 remaining points).  But, let’s say if the product owner estimates her “must have” story cut line is at 60 points.  She can now see that her team can achieve this with 3 more sprints (30 story points achieved and 30 more expected).  If she thinks of adding 5 more story points of “must have” scope.  She can also predict that it will take 4 more sprints (65 total must have story points).  Or say, if she wants to de-scope 10 must have story points, she can predict that the team can deliver this in 2 more sprints (20 remaining must have points).  What’s more, she doesn’t need to go back and worry about the fact that Ralph is taking a 3-week vacation or that Sally has a series of 2-hours doctor’s appointment.
 
Credit Clark and Vizdos
 
Story points, combined with team velocity, can produce fairly accurate estimates, faster.  In order to get better at estimating, more often than not, the contributing factors are that a delivery team stays constant, understands their problem domain, establishes a rhythm, and constantly inspects and adapts.  They can get better at estimation, irrespective of whether they use points, “gummy bears”, earth or martian days!  But, estimating in story points, has an advantage of not spending a whole lot of time in arriving at precise but inaccurate estimates, and avoid the trap of confusing effort and duration when contrasted with estimating in days.
 
And one last thing, just the other day, the cable guy promised he’ll be there to repair cable service, some time between 8-12pm (not very precise) and showed up at 130pm (not very accurate, either)!

Resistance is Futile…

The Rider Spins his Wheel (photo credit rykerstribe on flickr)

In my last post: Willpower to Change is Exhaustive Resource, I explored some ideas about change management. This topic is relevant for me and my team members, as we are going through major changes at work: reorganization, wider adoption of the agile practices, scaling the methodology outside of IT and in much larger context the market-place that we operate in. It helps to have some mental models to provide us with a framework to understand and adapt to these major changes.

Change Models

The model developed by Elizabeth Kubler-Ross and adopted to change management show that when change is introduced, we go through distinct reactions to it: shock, denial, frustration, depression, experiments, decisions and finally integration. It is important to know where we, and our team mates, are along this change curve.

Chip Heath and Dan Heath’s book Switch which uses the analogy of the Rider- the rational side of our brain, and the Elephant – the emotional side, as a short-hand to understand the dynamics of change efforts.  Behavioral economists Richard Thaler and H. M. Shefrin use a similar analogy – the farsighted Planner and the myopic Doer.

The Heath brothers explain that when we are looking to change, we are going up against “behaviors that have become automatic, and changing those behaviors requires careful supervision”, by our rational side. And depending on the size of the change we are making, the rational side simply gets overwhelmed and exhausts its willpower.

Many of us, have experienced this first hand. With good intentions, we embark on writing effective user stories, story tests, acceptance criteria, stories that fit a single sprint, have periodic retrospectives, write automated tests, demonstrate working software to our users, and so on. But under stress and schedule pressures, we abandon these good practices. We revert to writing technical user stories, coding only stories and testing only stories.  Sometimes, we resort to having an architecture-only sprint, data modeling sprint, analysis sprint, and then lots of coding sprints and in the end stabilization or “defects fixes” only sprints. We keep committing to stories, even though, we know we will barely finish coding, and then split stories across sprints. Automated unit tests or UI functional tests end up on the cutting floor. We cancel our demos and retrospectives, because we really need to use those 2 hours to do some more work on the stories we didn’t finish during the sprint. Sometimes, it gets so reductive, like this one candidate I was interviewing, who told me that on his agile team, the only practice they performed consistently was the daily scrum. The Heath brothers say, “anytime the six-ton Elephant and the Rider disagree about which direction to go, the Rider is going to lose. He’s completely overmatched.”  The Elephant will always seek out path of least resistance.

The Rider spins his wheels

If the elephant is hard to motivate and overwhelms the Rider, then the Rider has his own problems, too. In IT, we frequently succumb to analysis paralysis, or as one of my colleague calls it, “excessive navel-gazing”.

Jonah Lehrer, a journalist, was inspired to write a book How We Decide, precisely to understand why the Rider spins his wheels. Here is what he said during an interview on Amazon.com:

Q:Why did you want to write a book about decision-making?

A: It all began with Cheerios. I’m an incredibly indecisive person. There I was, aimlessly wandering the cereal aisle of the supermarket, trying to choose between the apple-cinnamon and honey-nut varieties. It was an embarrassing waste of time and yet it happened to me all the time. Eventually, I decided that enough was enough: I needed to understand what was happening inside my brain as I contemplated my breakfast options. I soon realized, of course, that this new science of decision-making had implications far grander than Cheerios.

Here are some examples of our own Rider. Which agile methodology should we use – Scrum, Lean, Kanban, DSDM, XP, FDD?  What agile techniques should we try first TDD, BDD, ATDD, CI, Pair Programming, Pair Testing.  What should we spend our energies automating – at the unit, component, integration, system level? What should we emphasis first, writing effective story cards, doing better demos, running honest and open retrospectives, fix bad team dynamics, and on and on.

The Heath brothers recount a story of two professors at West Virginia University. They are health researchers who were “contemplating ways to persuade people to eat a healthier diet?”  For something like that, where do you even began?

Which foods should people stop (or start) eating? Should they change their eating behavior at breakfast, lunch or dinner? At home or in restaurants? The number of ways to “eat healthier” is limitless, especially given the starting place of the average American diet. This is exactly the kind of situation in which the Rider will spin his wheels, analyzing and agonizing and never moving forward.

After much brainstorming, the two researchers arrived at this insight:

Most Americans drink milk, and we all know that milk is a great source of calcium. But milk is also the single largest source of saturated fat in the typical American’s diet. In fact, calculations showed something remarkable: If Americans switched from whole milk to skim or 1% milk, the average diet would immediately attain the USA recommended levels of saturated fat.

But, the next question was, how do you get people to drink low-fat milk and how do you get them to stock it in their refrigerators? After all, people will drink whatever’s available in the house (path of least resistance, no one’s going to run out to the store to buy whole milk – the Elephant is lazy).  Researchers figured out, “you don’t need to change drinking behavior. You need to change purchasing behavior.”

After an effective ad campaign, the two researchers were able to increase the market share of low-fat milk from 18% to 41% and it held steady after six months at 35%.  What we learn from this is:

If you want people to change, you don’t ask them to “act healthier.” You say, “Next time you’re in the dairy aisle of the grocery store, reach for a jug of 1% milk instead of whole milk.”

Many times, our reaction to change efforts is similar, for example, we might think, why can’t everyone just fall in line and just follow agile practices.  But contrary to what the trekkie-referenced title suggest it is isn’t even a question of resistance, because “what looks like resistance is often a lack of clarity.”

Oh and what happened to Mr Lehrer and his cheerios? Well, here is what he said in the same interview:

Q: What do you do in the cereal aisle now?

A: I was about halfway through writing the book when I got some great advice from a scientist. I was telling him about my Cheerios dilemma when he abruptly interrupted me: “The secret to happiness,” he said,”is not wasting time on irrelevant decisions.” Of course, this sage advice didn’t help me figure out what kind of cereal I actually wanted to eat for breakfast. So I did the only logical thing: I bought my three favorite Cheerios varieties and combined them all in my cereal bowl. Problem solved.

Sometimes, as our CIO says, it is better to “Ready, Fire, Aim”, instead of getting ready and deliberating endlessly on where to aim.  And then never getting around to firing.

So far, we have looked at 2 concepts from the Switch framework – direct the Rider and motivate the Elephant. In the next post, I will at look at the third concept – shape the Path.

Recently, at work, we have gone through some major organizational changes.  We have moved away from an IT organization that was a collection of functional silos – Architecture, Design and Analysis, Application Delivery, Release and QA, and so on –  to more integrated groups aligned with our business units.  As we move towards more cross-functional, self-organizing agile teams, colleagues have noticed that many of us feel a bit disoriented.  Many don’t know what to do, many have a negative reaction to the changes and then there are some who have already accepted the changes, and are impatient that there team mates are too slow to change.

Reactions to Change

As we experience change, Elizabeth Kubler-Ross defined and categorized our psychological reactions to it:

We find  that people react to change differently and they might be anywhere along this change spectrum, including in the “pit of despair”.  And each need different type of support.  For those in shock and denial need information and communication.  Those who have self-doubt and inching towards acceptance, need emotional support.  And those who are exploring and understanding, need direction and guidance.

The Rider and The Elephant

The Elephant and the Rider (credit aashish vaidya)

Another framework to understand and initiate change is developed by Chip Heath and Dan Heath in their book Switch.  They note that our brains have two independent systems at work:

First, there’s what we called the emotional side.  It’s the part of you that is instinctive, that feels pain and pleasure.  Second, there’s the rational side, also known as the reflective or conscious system.  It’s the part of you that deliberates and analyzes and looks into the future.

The Heath brothers adopt the terminology of the Elephant (the emotional side) and the Rider (the rational side) introduced by University of Virginia psychologist Jonathan Haidt in his book The Happiness Hypothesis.  This isn’t necessarily a new concept, as you find variations articulated by Plato, Freud and many others.

When we are in midst of change, like moving our software development from waterfall to agile methods, or getting better at adopting and refining agile methodology; or for that matter any other type of change effort, we need to understand both these aspects of our brains – The Rider and The Elephant.  This is how the Heath brothers define it:

The Rider provides the planning and direction, and the Elephant provides the energy.  So if you reach the Riders of your team but not the Elephants, team members will have understanding without motivation.  If you reach their Elephants but not their Riders, they’ll have passion without direction.  In both cases, the flaws can be paralyzing.  A reluctant Elephant and a wheel-spinning Rider can both ensure that nothing changes.  But when Elephants and Riders move together, change can come easily.

It is possible to get our rational side to exert control over our emotional side, but that can prove exhausting for the Rider.  To illustrate this point, Dan Heath in this FastCompany video and article, and also in the book, recount a study about radishes and cookies.

Will to Change is Finite

College students (the usual guinea pigs in these types of studies) were asked to fast for 3 hours and report to a study about food taste perception.  They were then led to a lab that smelled amazing from freshly baked chocolate chip cookies.  In the middle of the room were 2 bowls – one filled with cookies and another with radishes.  Half the participants were asked to sample the cookies but not radishes and another half to eat radishes only.  Then the researchers left the room.  The cookie eaters probably had no issues resisting the urge to eat the radishes!  However, despite the temptation, the radish-eaters showed amazing willpower and did not eat any of the cookies.  Here is where another set of wily researchers came in and declared that the taste perception study was over.  But, they were doing another study about problem solving.  At that point, they asked the participants to solve a puzzle.  Unbeknownst to the participants, the puzzle had no real solution.

What the researchers were trying to find out was whether there was difference in a way the cookie-eaters and the radish – eaters approached the puzzle?  Well, it turns out there was.  The cookie-eaters made 34 attempts at the puzzle and persisted for 19 minutes.  The radish-eaters made only 19 attempts and gave up in half the time.  Why is this?  Well, study shows that the radish-eaters who were tempted to eat cookies but did not, simply ran out of self-control.  So when another challenging task – solving an impossible puzzle was giving to them – they were simply exhausted.  Of course, your takeaway from study shouldn’t be , eat more cookies and not radishes.  But, it should be that the will to change is indeed finite.  The Heath brothers say, “what looks like laziness is often exhaustion.”

IT organizations, when they decide to change from traditional waterfall software development, or initiate any other major changes, find many team members, managers and business partners show reluctance to these change efforts.  In many instances, it is because their Elephants are genuinely spooked at the spectre of losing the clout they have built in an organization or potentially losing their jobs, or myriad of other real and imagined fears.  Change induces a fight or flight response.

Many times, we share information about changes, appealing to the rational brain, but we don’t really address “what is in it for me” part of the equation.  That is, we don’t engage the emotional side.  And so the changes simply don’t stick.  Our rational side tries hard, but in the end, the willpower dissipates. This is due to skittishness of  our emotional side, which is “often looking for the quick payoff”, at the expense of long-term gains.  Change management saps our willpower, if we don’t find a way to motivate our emotional sides.

In my next post, I will continue to explore more on the change management theme.

I have been revisiting the Popendiecks’ 2003 book: Lean Software Development: An Agile Toolkit.  One of the tools in the book is Set-Based Versus Point-Based approach.  This tool is based on Lean principle of amplifying learning. 

Point-Based approach is based on choices.  The authors represent this via the following an illustration:

 

 

Whereas, Set-Based approach is described as one about “constraints, not choices” and that it requires “significantly less data to convey far more information.”

I inadvertently stumbled on an opportunity to try out this tool, exactly in the way it is described in the book.  While facilitating a community of practice which has 9 team members, I had a need to schedule a meeting.  But, since we all work on different teams, coordinating simple schedules for this part-time effort is usually a challenge.  It would be simple to see everyone’s calendars and schedule a meeting.  However, many people don’t keep their calendars up to date.  Or they have blocked off time, but are actually available.

Even during face-to-face meeting, since people don’t have their schedules in front of them, they are reluctant to commit.  So it becomes hard to converge on a time.

My initial instinct was to use the point-based approach by letting everyone know the best time that worked for me.  But I decided to try the set-based approach.

Here is how I communicated the constraints via email to all the team members:

  • Apart from me, one particular team member needed to be present, as she had the key information on the topic
  • Additionally we needed 2-3 more team members
  • I provided 2 blocks of 2 hours each that I could meet for an hour long meeting

And lo and behold, within few minutes, I got the needed response.  What had in similar circumstances took a flurry of emails, and still no convergence; with this approach, we converged on time with just 1 email each from the team members.  Few let me know which time worked, others let me know they weren’t available.  And I was able to quickly pick a common hour that worked for half the team to meet.

It was great to see the tool in action.  Next, I am keeping my eyes open to use this on a development project.

%d bloggers like this: