Context is King: Why I stopped blogging

A lot of the articles I read about agile don't describe the context in which their advice applies. The authors don't take the time. Many authors aren't even aware of their context. They haven't seen enough different kinds of agile implementations to understand that their advice doesn't apply outside of their context.

Writing was easy for me when I worked for Leading Agile because we had a well documented and limited context. Grossly oversimplified, companies who wanted predictability in their software development efforts were attracted to our offering. We had one message, one services offering, and one target market.

Everything on our blog and everything on our website and every talk given at a conference adhered to this single context. That context was explained so much that it didn't have to be explained every time. Yet every blog post pointed back to that context in some way. It all dovetailed together.

Every aspect of agile, of teams, of org structure, of metrics, of forecasting, of planning, of funding, of portfolio management, of roadmapping, of prioritization, and on and on needed to be explained in terms of that context, so there was lots of fodder.

I stopped blogging when I left Leading Agile because of this need for the applicable context to be explained. When I left the firm I left the context. I've seen agile done many different (valid and effective) ways before my time at the firm and in many ways after. For which context should I write? How should I explain the applicability of my opinions? 

I don't run my agile programs now the way we did at Leading Agile. It's not because I didn't believe in that approach, didn't find value in it, or can't do it. In fact, I like that approach a great deal. But it doesn't apply to my context now. Predictability isn't my driver. 

This isn't anything new. People have been arguing over agile since the 90s, with much disagreement stemming from the unique and unstated context in the mind of each author and consultant.

What triggered me to write this was some things John Cutler wrote. "…the key to putting bets in motion is to tailor your working approach to the bet." How you develop the idea of the bet and how you implement the bet should vary based on the nature of the bet, the uncertainty of the opportunity, the uncertainty of the solution, urgency, size, allowance for failure, level of collaboration needed, and etc. There's no single agile prescription that's best for every kind of bet. John explains the anti-pattern of when companies "lack any sense that the things they are doing have different characteristics. They try to use a mono-process for everything." "Impact: picking less-than-optimal ways of working." And "Mono-process kills companies." 

Don't bother trying to do agile "right" and don't fret over other people's advice when it doesn't match your context.

What do you estimate and when do you do it?

Pick up most any book on agile or Scrum and see what it says about planning a product backlog or planning a release or about computing an end date for a project. It will say to identify the stories, estimate them in points, add up all the points, and compare the backlog point total with your velocity to figure out how many sprints it will take to implement all those stories. Then reserve some room for unknowns and for changes (agility).

So, that implies identifying and estimating stories far enough in advance to match whatever your planning and commitment horizon is. This implies that estimating story points in sprint planning or just before sprint planning or even one sprint in advance is likely not far enough in advance unless you are ultra-agile and aren't making commitments or setting date expectations more than a couple weeks out.

Most companies I work with have a planning horizon that is 3 to 6 months out. So, we put together a 4 or 6 month plan. That plan is going to be based on what we can know in advance, namely, user stories. (Sometimes we do this at the feature level, but that's another blog post.) We won't know research stories or spikes or defects or production support in advance. Whatever goes into the plan is what should go into the velocity metric. Stated differently, you shouldn't put anything into your velocity metric that you can't plan for 4 to 6 months in advance. Which means you shouldn't bother putting points on defect or on research stories. If you are going to compare apples to apples, your velocity must exclude unplannable stuff.

That's why I put points only on real user stories. Here is a series of blog posts I did on each of these topics:

Don't Estimate Defects

Don't Estimate Spikes

Don't Estimate in Sprint Planning

Estimating Placeholder Stories is a Bad Practice

Now, some people try to estimate this unplannable stuff. They try to quantify it in points and include it in placeholders in their plan. You absolutely should track this unplannable stuff, and you should reason about whether it will be more or less in the future, but trying to back it into points or plan it using points is folly. 

Don't Spike Defects

I've recently seen a small number of teams create Spikes for defects. That seems strange to me. If you have a good reason for doing this, please let me know.

It should be rare that we’d have a spike to research a defect. Defects almost always have some amount of unknown research and debugging to them. It would seem strange to me to have a SPIKE to debug a problem which would then be fixed under a Defect.

The exception case may be if we want a triage/debugging step where we figure out what’s wrong and estimate the effort to fix before agreeing to fix it. But typically with defects, once you know how to fix it, actually fixing may be faster than all the debugging. By the time you’ve got it debugged, you know exactly how to fix it. I rarely find that approval step necessary these days.

I haven't heard of spiking defects discussed in the agile community so I assume it's generally accepted that this is not a recommended or common practice.

How Many Stories per Sprint? Rules of Thumb

I'm often asked how many stories you should have in a sprint. People are looking for guidance.

I've heard some coaches recommend “3-6 stories per iteration per developer”. That's a bad rule of thumb. For a team of 7 developers you would have over 20-40 stories which is likely way too many. That kind rule of thumb also subtly takes the focus off of swarming and puts attention toward a developer per story, a story per developer.

My rules of thumb:

5 to 15 stories per sprint are about the right number, particularly for the clients I often work with in which there are maintenance teams knocking down a backlog of small defects and teams doing Web work with lots of small changes to do. 4 stories in a sprint may be okay on the low end from time to time, and 20 is an upper limit for me.

Most stories shouldn't take more than half the sprint to develop and test. Having 1 story each sprint that takes more than half the sprint is about all I would advise, and in that case all the other stories should be very small. For a 2 week sprint, it's better if every story can be completed in 1 to 3 days. (Adjust that for longer sprints.)

I need to elaborate on my comment that it's better if every story can be completed in 1 to 3 days. After stating that I'm often asked whether that's the developers working independently or all together. The answer is "whatever you are doing today." It is best if the team can swarm stories such that multiple developers can work on a story at the same time. If  2 or 3 devs can work on a story at the same time, then you can have larger stories finished within that 1 to 3 day rule of thumb. But if the team isn't there yet, if that's not the way they work today, then having stories that are too big given the way they are working is counter productive.

What's the maximum number of points for a story? How big is too big? How many points is too big for a story varies according to the team's pointing scale. I've known teams that start with 5 (5, 10, 20, 30, 50, 80). For them, 50 and 80 were too big. I've also known teams where a 1 point story would take less than half a day. For them, a 13 might not be too big. If a 1 takes more than a day, then 13 is probably too big. Generally, too big is an order of magnitude larger than the typical small story.

Here's an example: Assume my 1 point story takes a day or two and once in a while we have something that is truly tiny and we call those half a point. The 1 pointer is my typical low end of the range. I have something smaller, but it's not typical. A 13 is an order of magnitude larger that 1 point story. It's very difficult to keep the scale linear when there is that much diversity in your story sizes.

Story Splitting: Where do I start?

I don't always follow the same story splitting approach when I need to split a story. It has become intuitive for me so I might not be able to write about everything I do or what goes through my mind or how I know. But I can put here what comes to mind at the moment:

Look at your acceptance criteria. There is often some aspect of business value in each acceptance criteria that can be split out into a separate story that is valuable to the ProductOwner.

Consider the tasks that need to be done. Can any of them be deferred (to a later sprint)? If so, then consider whether any of them are separately valuable to the ProductOwner. If so, perhaps that would be a good story to split out.

If there are lots of unknowns, if it's a 13 because of unanswered questions, make a list of the questions and uncertainties. For each, ask whether it's a Business Analyst (BA) to-do or a Tech to-do. Also ask for each whether it's easy and should be considered "grooming". If it's significant enough and technical, maybe you should split that out as a ResearchSpike. Then make an assumption about the likely outcome of the spike, or the desired outcome of the spike, note the assumption in the original story, and reestimate the original story given the assumption.

Look in the story description for conjunctions since and's and or's are a clue that the story may be doing too much. Consider whether you can split the story along the lines of the conjunctions.

Other ideas:

• Workflow steps: Identify specific steps that a user takes to accomplish the specific workflow, and then implement the work flow in incremental stages
• Business Rule Variations
• Happy path versus error paths
• Simple approach versus more and more complex approaches
• Variations in data entry methods or sources
• Support simple data 1st, then more complex data later
• Variations in output formatting, simple first, then complex
• Defer some system quality (an "ility"). Estimate or interpolate first, do real-time later. Support a speedier response later.
• Split out parts of CRUD. Do you really really really need to be able to Delete if you can Update or Deactivate? Do you really really really need to Update if you can Create and Delete? Sure, you may need those functions, but you don't have to have them all in the same sprint or in the same story.

Some of the phrases in the above list may have been inadvertently recited from Dean Leffingwell's book "Agile Software Requirements".

My Recent Posts on LeadingAgile

I started working with LeadingAgile in 11/2012 on some complex enterprise agile transformations and other lean management consulting. Related to that, I've done most of my recent blogging over there on LeadingAgile's blog. Here are some of those posts:

I Don’t Estimate Software Defects, but it's not as simple as just that. If you follow my advice, you'll also have a zero-defect mentality and you'll fix defects as soon as you find them. In general, I want a conservative measure of velocity, so I don't record in my velocity anything that was unplanned. Therefore, I likewise Don't Estimate Spikes.

I'm fond of The Theory of Constraints and Brooks’ Law. In that post I evaluated Brooks' Law in light of the Theory of Constraints in a way that I hope helps the reader understand both concepts.

Lack of Predictability is Your Biggest Problem. The senior leadership in most organizations I work with seem to agree. They aren't very interested in agile's agility. They want their design-build-test teams and their program teams to be able to make and meet commitments so they can make appropriate capacity constrained commitments across the portfolio and to external stakeholders.

Agile Health Metrics for Predictability was perhaps my most popular post on LeadingAgile's blog.

In Bottom-Up Implementation & Top-Down Intent, I discuss my recommended approach to agile transformations.

Related to that, I wrote a post arguing that you should fix your Structure 1st: Why You Should Not Start With Practices

Part of your structure involves your design-build-test teams, also known as your Scrum teams. In Use Feature Teams. Yes, Use Component Teams I explaining these approaches and why I recommend using both.

What do Scrum teams do during the Release Sprint? Good question. This post has the answer. In short, many things, but not developing code that can't be tested immediately.

Oh, I also published an article in Agile Journal entitled Identifying and Improving Bad User Stories along with my friend and co-author Chuck Suscheck. We put another article up on sticky-minds: The Problems with Overachievers on Agile Teams.

Spike Solutions

I like James Shore's explanation of Spike Solutions. His focus seems to be on very short impromptu experiments (on the order of minutes). One thing about spikes that could use some more words are larger spikes. Sometimes I need to figure something out that may take more than a day. An example might be to experiment with one particular API for some new service I need to consume.

I recommend each team come to agreement on what's an acceptable maximum size for a spike. I recommend a day, or maybe two. If it will take more time than that, split it, just like you would for a story. Spikes need to have a clear acceptance criteria, a very specific question to answer. When the time-box is over, share the results with the team.

Often, such larger spikes are related to a user story and typically must be resolved before the story can be estimated. But for the spikes themselves, I recommend NOT estimating them. We want velocity to represent value added stories -- we want to measure the rate at which we add value. Either way, when using your velocity, when making release plans, you must understand your system and take into consideration when and how you come up with spikes and when you solve them. Do you find them late? Do you know about them but implement them late? If so, that represents unknown schedule risk.

I used to say that a consistent stream of day-sized spikes is good, but when I said that I would often forget to explain my context and assumptions. Having a continuous stream of new spikes that you solve almost as you create them makes sense if you are also doing continuous planning (without batching into large releases or without release commitments). Solving small spikes regularly keeps this activity from making velocity unstable.

Conversely, if you batch requirements into releases greater than, say, a couple months and if your organization is making release commitments, then in that case spikes represent risk in your backlog. Might want to knock out all spikes for the release right off the bat.

------------------

Wow, this is just my first post this year. I've been very busy with my LeadingAgile clients. It's time to get back to my writing!

Sketchnotes of Agile Immersion

Here are the sketchnotes from my November Agile Immersion workshop.

These sketchnotes were done by a business partner of mine, Jenny Trautman of evenview. Sketchnotes aren't the main thing evenview does -- sketchnotes are an artifact. What evenview does is help people bring innovative strategies into focus. They lead fun, high-energy meetings using interactive visuals that draw a team together. With their support, groups collaborate to develop a shared vision, create a plan for action, and implement their ideas. Use them for your next strategy meeting or kickoff.

By the way, this workshop is designed for everyone. No agile experience or programming skills required. All types of roles have found it benefical: product managers, marketers, managers, office managers, business development executives, developers, testers, CFOs, and etc. Check out this interesting blog post from a recent non-developer attendee.

Sprint "Commitments" are an Amortized Death March

Matt's tweet is provocative: Sprint "commitments" are an amortized death march.

If sprint commitments lead to a death march, something is wrong in your organization. Sprint commitments could be used by poor managers to browbeat the team.

Hey, you guys committed to this. I expect it to be done!

Not good.

The risk of a death march, however, is not the reason to not have a strong sprint commitment. You can (possibly) fix that problem. You can (possibly) have good, enlightened managers. Besides, there are many ways to use Scrum poorly. Should we throw out every misused practice?

No. But sprint commitments are dubious.

It's not the sprint commitment we are after. It's not what we really want in the end. It has no value on its own. What we're after is that thing we hope to get from having the sprint commitment. What we hope to get is a team that is committed to each other, working together to finish what they set out to do. We hope everyone works on what we agree to work on rather than whatever darn thing anyone wants to do. We hope to not have unfinished work at the end of the sprint.

Sprint commitments → no unfinished work at the end

Too bad this is a fallacy. The fallacy is that for each desired outcome B there must exist a cause A.

A → B

In complex adaptive systems it doesn't always work out that way. I might even say it rarely works that way. Whether the sprint goes well or poorly, there are side effects of such policies. But this post isn't about the side effects. For the manager, though, when the sprint goes poorly the best possible outcome is...

Darn, this is harder than anticipated. But I committed to getting it done. Guess I'll put in some overtime.

If what is committed to is generally kept low (appropriate), pace should be sustainable over the long run even with some rare overtime. When appropriate overtime does happen:

That stunk! Not doing that again. Let's commit to less and plan better.

In this way, sprint commitment should drive careful planning.

But is careful planning in batch necessary or is it waste? It can be useful in some contexts, but bogus in others. What's the point of a sprint commitment if you are committing to something very small, knowing that you are going to add more work to the sprint? If we plan less work to meet a strong sprint commitment, and also plan to add more work to the sprint later, then we are approaching continuous planning and might as well make the jump to iteration-less flow (e.g. and use Kanban).

We want a stable velocity. We want teams to be predictable. But requiring a strong sprint commitment is neither necessary nor sufficient. It's other stuff that makes us predictable, namely: finishing sprints cleanly every time; good backlog grooming practices; good story estimation practices (if using Scrum); limiting WIP; not starting work you can't finish in time; the "keep it working" principle; refactoring and SOLID design principles; good release planning and intelligent use of spikes; and so forth.

Just work directly on that stuff.

Truthfully, I've used sprint commitments and have also gone without them. They are useful in certain context, and dangerous in others. I consider the leadership, the managers and scrum masters, the team's agile experience, and how much time I'll have to coach the team before making the call on sprint commitments.

Related Articles:

Matt Barcomb wrote a nice article on good and bad commitments. Go read that and the very thoughtful comments posted in reply.

I briefly touched on sprint commitments in my post on unstable velocity.

Space Theories

I once created an agile space that my teams could choose to use. They had decent cubes they could also use. (Decent cubes -- an oxymoron?) Anyway, when the space was created it got used lots. Over time, it got used less. Late one night I pondered why and came up these thoughts. I'm posting it just for fun. Consider your space in light of these thoughts.

The Distance Theory

The likelihood of a team voluntarily using an agile space...

• is indirectly proportional to their proximity to each other.

Teammates are unlikely to use the shared space if their cubes are only three steps apart.

• is directly proportional to the sum of the distances between the cubes of the team members.

The more scattered the members are, the more likely they are to meet in a common location. Therefore, the likelihood of a team using the space may be proportional to the team size. This rule holds as long as that aforementioned sum of the distances is greater than the sum of the distances from the cubes to the agile space.

• is directly proportional to their proximity to it relative to their proximity to each other.

No one will use an agile space that is much further away than whichever cube is most central.

The Equipment Theory

The likelihood of an individual voluntarily using an agile space...

• is directly proportional to the computer speed and display size of the team computers relative to that of the computers in their cubes.

Equip the agile space with the most powerful PCs and beautiful monitors, and keep it that way.

The People Theory

The likelihood of a team voluntarily using an agile space...

• is directly proportional to likelihood that the team-lead (or some core, key individual(s)) can usually be found the lab.

Social aspects and the exchange of info/ideas matter.

• is directly proportional to the cohesiveness of their tasks.

Programmers working on disjoint tasks are less likely to use a shared space.

• is indirectly proportional to the number of teams using that space.

I can easily listen in or tune out discussions between my team members. Discussions between members of other teams are not easily tuned out. (Cognitive dissonance.)

The Environment Theory

The likelihood of an individual voluntarily using an agile space...

• is directly proportional to the positiveness of daylight.

Daylight is a positive and negative factor.

• Daylight good.
• Glare bad.
• Looking at distant objects good. Reduces eye strain.
• Heat bad.
• Working shades are good.
• Dysfunctional shades are bad.

Standup Around Innovative BVCs -- The CNN Agile Tour

At the CNN Agile Tour put on last week through Agile Atlanta I noticed a couple Big Visible Charts (BVCs) of a sort I don't think I had ever seen before. One of them is a list of tasks that need to be done pertaining to delegating some responsibility and moving some permissions to other people. Multiple teams have a standup around this board. It looks nothing like a card wall. Other than the fact that it doesn't look like a card wall, what it looks like doesn't matter. So I'm not including a picture. No one should try to do what they did.

The point here is that they were innovative in coming up with a BVC that radiates status and helps them communicate. Too many teams get stuck in a rut, using the same old ineffective ways of doing their standup. And often abandon the practice altogether.

The Tours

It was neat to see the Kanban being used by one of the teams and to talk about how they were using it and what they were getting out of it. It was cool to talk about their facilities and compromises they made and how the layout impacts pairing and team size. And we had good discussions about estimating tasks and stories. And other stuff too.

We've had prior tours as well and in each the host has had surprising candor, discussing the honest state of their agile practice including their current struggles.

Alex Kell wrote a nice post about the earlier Agile Tour @ Allure.

And the RedPrairie Agile Tour was neat because we got to sit in on an end of iteration innovation demo, a kind of a technical show and tell across several teams of some neat new technologies they've experimented with or put into place.

I'm planning other tours as well. Follow me on twitter and subscribe to the Agile Atlanta yahoo group to make sure you don't miss the next one.

Each company that has hosted a tour has gotten something out of these tours as well. Let's set one up at your company. Give me a call or drop me an email today.

Backlog Completion Date a Kanban Hazard

I've attempted to write this article in the inverted pyramid style common in newspaper articles. (Most important info first. Least important last. Quit reading wherever you wish.) Don't know if I succeeded. What do you think? How badly does this stink?

A mistake I've seen is to use lead time metrics, derived from the development of small, well-split stories, to figure out how long it will take to complete a backlog full of raw unsplit stories. Apples and oranges. Don't do that.

Writings about the Kanban Method eschew story estimation as being both waste and inaccurate. Even relative estimation. So instead, they recommend understanding your system well and gathering the metrics on average lead time. With that data you can compute how long it would take to complete a backlog of work. Even some Scrum teams are beginning to use this approach. I like this method.

But to use this approach you must truly understand your system. I'm talking about understanding the behavior of the system and in particular the actors in the system.

For example, it's common to split stories once they get higher in priority and closer to development. That's a good thing and it happens in Scrum and in Kanban. This refinement may happen many times to a story during it's lifetime. I guess that most teams are completely unaware of just how many times stories are split along the way. Often I see stories indirectly split; Setting out to rewrite a set of stories, the set will be thrown away and a new set written, with no one noticing that there are more, and finer grained, stories in the new set.

A similar effect happens in Scrum when teams estimate defects and include those points in their velocity. They most often have no estimate for defects that have yet to be discovered (neither in quantity nor magnitude of effort). If a significant number of new defects are coming in all the time, then such teams are inflating their velocity and underestimating the magnitude of their backlog. This is a recipe for disaster. Such teams wonder why they never hit their dates. Others blame it on a quality problem.

As an aside, any commitments regarding the completion of the backlog have to be in concert with the stability of the backlog. You need to compute a new end date whenever the backlog changes. But that's the same whether you are using lead time or relative estimates with velocity.

Use Physical Story Cards

Sometimes you want to use an electronic Agile Application Life Cycle Management (ALM) tool for managing your user stories. There are benefits to using a tool. They have some really nice features, some of which can't be done in the physical realm. And sometimes you've just got to go electronic; you have no choice. But even if you've gone virtual, there are still benefits for having physical cards as well.

I like having my user stories on physical cards. Conversations are richer, and shorter, when you can point and ask "What's the difference between these two stories?" and the answer is "THIS story is about… but THAT story is for…".

Planning poker is great, but the Team Estimation approach is often better, especially if you have a dozen stories or more. I love it when someone can tell the team "I think THIS story is smaller than THAT one and larger than THIS one" and everyone immediately understand which stories he's talking about.

Relative prioritization is easier when you can slide around some physical cards, especially if you need to prioritize collaboratively. "I'm okay with what we've laid out here, but if you think THAT story is THAT high a priority, you are nuts!"

I recommend having a pre-planning meeting to help make iteration planning will go well. That first pre-planning before a team's first iteration planning meeting is particularly difficult. You don't know what your velocity is. You don't know how much you can get done. You may be unsure of dependencies. All this agile stuff is new. And you need to get several people to feel confident that the 1st sprint planning will go well. You have this large backlog of stories and you want to be sure everyone understands what we're sure we're putting in, what we're considering to put in, and what we're not putting in. So lay it out on the table. I love being able to slide cards around on a table and to be able to literally put something aside for now if it's giving us grief. It's not off the table, it's not out of sight, it doesn't look like it's still in the list, but it won't be forgotten. "Let's come back to THIS one later."

Story mapping just has to be physical until we get inexpensive wall-size touch-screen monitors and story mapping software.

I've worked with clients that were very happy with their ALM tool and large monitors. I was impressed with their dedication to making agile work, their open space, and these monitors for each team. But as big as the monitors were, it still just seemed easier to me to manipulate and read fat sharpie on index card. And I can write SPLIT on a card faster than I can tag it as too big in an ALM tool.

Sketches are interesting. A picture is worth a thousand words. Would be harder to do this on anything other than paper.

But using an ALM tool doesn't mean you can't have physical cards too. It's pretty easy to write the story title and estimate on an index card. You can write the story's ID number from the ALM tool on the card. You can also print story cards from some of the tools. VersionOne has always had a printing solution, but the version coming out in August 2012 will have the ability to print directly from the tool.

I've heard of other tools that make it easy to print, but I can't name them off hand. If you'd like to mention your tool in the comments, please do.

Lots could be written about keeping physical cards and an ALM tool in sync. I'm going to ignore keeping a Scrum card wall in sync in order to keep this post on the short-side, but I will add the following. If you are using physical cards for a prioritization or sizing exercise then just enter the updates back into the ALM tool and discard the cards -- or hang on to them for some other purpose if you want. The point is, the cards served their purpose, they are transient, update the tool and you are done. I could also approve of doing a story map at the start of a small release, then leave it on the wall as is as a historical vision document while the ALM tool becomes the plan of record. I also recommend sticking with physical cards through Iteration Zero and Iteration One. What's cool in I0 and I1 is using the same cards for socializing, estimating, prioritization, pre-planning, and finally planning and the daily standup, then seeing a gold star put on that sucker once it's done.

Bottom line: Keep using physical cards. I promise it will be worth it.

Consider Stories at Multiple Levels

I often work with teams adding new large features to existing applications. It is common for teams like this who are new to agile to go into too much detail too soon. It seems that those accustomed to waterfall believe you've only got one shot to discuss any requirement, so they must discuss it in detail.

In agile you get many looks at each user story (requirement), preferably from many different angles and ultimately getting progressively more detailed as you go. I like to explain it with these four levels.

VISUALIZE -- The Concept

We typically start with a project name or enhancement name, don't we? It's the handle by which we call this thing. From there we hope to have the vision, a short narrative for what we're after. Perhaps we have the name of a few super-epics. Refine that into some epics. Begin to understand the minimal marketable features (MMFs). Metaphorically, this may be an aerial view of the forest, or maybe the planet. Keep the vision in front of the team throughout the project.

PRIORITIZE, ORGANIZE and SOCIALIZE -- The Forest

By prioritize and organize, I mean use any approach to help the team see how the stories fit into the vision and understand the minimal marketable feature set. An example technique is Story Mapping. Understand your epics. Metaphorically, this is understanding what the forest full of trees looks like.

None of these are a one shot deal. Iteratively refine your prioritization. Tune the MMF and re-socialize stories as you learn and get feedback. You aren't done socializing just because sprint zero is over. For anything of size, you don't get done socializing in just one meeting. Nor does all the socializing happen in meetings.

SIZE -- The Trees

When sizing (with abstract relative points), look at your stories in a little more depth, but not to the level of detail described below. Look at it just enough to give an estimate relative to the other stories. You don't need as much detail for a relative estimate as you would for an hours/days/weeks estimate. You quickly get to a point of diminishing returns. Consider that we use a Fibonacci series or something similar -- we use a diminishing level of precision as the stories get larger. Once you are pretty confident that it's a 21 point story, you don't need to spend more time to make sure it isn't really a 13 pointer.

As with the above, you may look at a story for sizing multiple times. If you've sized a bunch of stories at the start of a release, you should re-size the remaining work after 3 to 5 iterations. By then you've learned more. You will have become more familiar with the project, subject matter and the affected code.

Sizing also shouldn't be expected to be static. How big a 3 point story is will shift over time, especially but not only because of changes in the team. Hopefully the individuals are getting better, smarter, and the code is getting cleaner. Also, the work that we're comparing stories to changes. Point-drift happens. Old estimates are like milk -- they don't get better with time.

PLAN -- The Details

In iteration planning we break stories down into tasks. We estimate tasks in hours or half-days or maybe in pomodoros. We think in terms of detailed design and code and test cases.


Understanding that we're going to see each story multiple times with progressive levels of detail helps overcome the desire to go too deep too soon.

What approaches have you used to help people think about stories at the appropriate level?

3 arguments against BLOCKED and a bonus on IMPEDIMENT

Why I don’t like "blocked" –

In some companies, people don’t want to say they are blocked.

(1) Being blocked gives you a sense of blaming others. Not wanting to offend coworkers...

Yes, I'm waiting on Joe, but he's not blocking me!

But we want honesty and need safety. I need a safe environment so that Joe and I can agree that Joe's blocking me. It's not Joe's fault. It just is. And it needs to be a safe environment especially if it is Joe's fault.

(2) Being blocked gives you lots of scrutiny.

No! I’m not blocked! Don’t help me!

But that’s exactly what we want – attention on the problem, but in a servant leadership collaborative way. Too often, blockers attract the wrong kind of attention.

(3) Being blocked sounds so absolute.

...and I'm not totally blocked anyway. There's some other stuff I can do.

Yeah, less important stuff. Probably stuff we shouldn't be doing anyway, unless it's taking advantage of slack to sharpen your saw.

(4) Having an impediment sounds like a medical problem.

No, unh-uh, no impediments here.

Impediment is such a funny word. Who introduced that into the agile vernacular anyway? Nobody uses that in normal speech. People new to agile likely don't even know what that means.


That's why I like to ask "what's slowing you down?"

"Oh, yeah, my PC's a few years old. I don't have very good test data. The A/C shuts off at 5:30p each day. I have to make two hops to remote into the test-lab because of security reasons. The build server builds once per day instead of on check-in. The unit tests are taking a few minutes to run; I think someone put something bad in there. We should find it and move the offender over to the regression suite or make it faster. Why can't we get some stickier stickies? I'm waiting for Joe to give me access to the production server. And I keep getting interrupted by customers bypassing the support desk… Sure. Lots of stuff is slowing me down."

Ah. Great. Now that I know, we can go work on that.

Constellations and Deep Democracy

Constellations can be used as effectively with just one or two statements as well as with dozen, making it an effective tool for Deep Democracy.

One of the tools I picked up from Lyssa Adkins' book, Coaching Agile Teams, is called Constellation. (It really should be plural, Lyssa.) Briefly, the purpose of Constellations is to gain a better understanding of your team and their individual preferences, values, interests, or opinions.

Mechanically Constellations works like this: Put something in the middle of a big open room. Have everyone stand in a big circle around this object. Explain that you are going to read some statements. (Such as: "I like Scrum." "I get value out of our retros." "We should TDD more." "I think Agile will work for us." Etc.) Instruct the team to orient themselves closer or further away from this object after each statement is read to represent the extent to which they agree with that statement. If they agree, move in. If not, move out. Tell them to not over think it. Tell them to stand where their heart and head tells them to stand, not where they think they should stand. Then have the team observe the Constellation of people and discuss what it means. There are some considerations for how that discussion is facilitated, but that's a topic for another post.

The way it's described in the book is that the facilitator might want to read numerous statements. This is a great way for a team to get to know each other. I've done this exercise with about a dozen different teams. Now, I'm no longer surprised by what I find. A common surprise to the team is when they discover that their Product Owner doesn't like to run the demo but that someone else one the team has been dying to do it. Another: There's often an ah-ha moment when the team begins to understand that the quiet person just needs time to think before he speaks.

Anyway, I've done this lots and lots and have used 20 to 40 statements each time. Some of the resulting Constellations aren't interesting. I move on quickly and don't have discussion for those. Some are very revealing. I have a short discussion on the spot for those. Even the teams that are well established have interesting revelations using this technique. The number of questions and amount of discussion is bounded only by the team's willingness to continue standing.

Building on Michael Spayd's talk on Deep Democracy at Agile 2009, during the Atlanta Scrum Gathering in 2012, Lyssa Adkins and Michael Spayd led a Constellations exercise and only asked 2 questions.

They used the technique for Deep Democracy (Arnold Mindell). They were working with a large random group of people from the conference; I usually work with a team that has at least a little work history, and often a long history with each other. They facilitated the discussion carefully, more carefully than I would with a known group. Lyssa started with the inner ring and encouraged all voices to be heard, one ring at a time, an important aspect of Deep Democracy. Lyssa was careful to give voice to each ring in the Constellation and to set the ground rules: don't state that someone else's opinion is wrong or challenge someone else, use "I think" or "I feel" or "my opinion is", all opinions are valid, I will step in if you violate these rules, etc.

What I learned directly from Lyssa that I didn't get out of the book is that the Constellations technique can be useful with just one or two questions. In particular, it's useful when you have a specific narrow topic, even a controversial one -- when Deep Democracy is needed. This can provide a safe environment in which to speak and allows the facilitator to manage diverse opinions in a logical progression. It's also useful to reduce the number of questions as the size of the team grows (since it takes more time to allow more people to voice their opinion).

I would love to hear about your experiences with Constellations and Deep Democracy, together or separately. Are there other variations on this theme? Other ways to use this technique?

For the Sake of a Productive Retrospective

Even good, competent, and valued people sometimes have an off day, make an ill-advised or selfish choice, or are just plain mindless.¹

Like many others, I'm not quite satisfied with the Retrospective Prime Directive as it's written. I understand and appreciate Dinwiddie's explanation of it, but as a useful tool, the directive doesn't strike any chords for me. What I think the directive is trying to say is:

Retrospectives are not about blame. They are about moving forward.

So why not just say that? I'm fond of Tobias' take on it (with another phrase² inserted):

We are emotional and vulnerable beings, subject to a continuous flow of influences from a myriad of sources. Sometimes we perform magnificently, other times we mess up. Mostly we are somewhere between these extremes. In this last period of work everyone did what they did, and likely had reasons for doing so.
     Bearing in mind that there are many factors of which I am unaware.²
Accept what is. And now, what can we learn from our past actions and thinking that will inform and guide our future ones?

Whenever I'm working with a team that is still struggling to create a safe environment, I also suggest "quietly considering" this:

I will ensure that we have a safe environment
in which we can each own up to our own mistakes own our own
and endeavor to not be defensive if someone else points out my mistakes.
If someone gets defensive, we'll assume that the environment is not safe
rather than assume a personality flaw.

1. Stone, Patton, Heen, Fisher, Difficult Conversations: How to Discuss What Matters Most, Penguin, 2010, page 287.

2. Wallace C. Ellerbroek, MD, “Language, Thought, & Disease”, The CoEvolution Quarterly, No. 17, Spring 1978, page 33.

Management at the Solstice

The winter solstice is upon us here in the Northern Hemisphere. The earth is tilted on its axis, making the days shorter as the earth goes about it's elliptical orbit around the sun, reaching the shortest day on the winter solstice. This doesn't coincide with the dead of winter, however, because of seasonal lag caused by us having lots of water around, giving off stored heat. (A little something to look forward to -- three more months of cold weather.) Speaking of colds, our solstice does, however, occur right after the start of cold and flu season. Lower relative humidity indoors and us being indoors more makes us more susceptible to viruses. The shortening days and more time spent indoors gives us the winter blues. Depression, more prevalence of illness, compounded by the dreaded annual performance review and holiday stress makes a nasty combination. All of this ultimately leads to poor productivity and unhappy people.

So what? What's that to do with me?

The manager's job is to create an environment in which people can be productive, even healthy. Help your team attack the winter blues and defeat viruses. Help them find their happy hat.

But how?

You've got to come up with your own ideas for your own environment, but here are some examples.

Improve lighting for a better mood. We might be saving energy, but we're killing productivity with those glare and headache inducing, flickering fluorescent lights. Indirect non-fluorescent lamps are easier on the eyes. Or set up a light therapy room in some meeting room or office. Why not?

And sunlight is great. Open the blinds and schedule some outdoor activities, maybe a team lunch that you can walk to or at least drive to. In other words, get out of the building during the middle of the day.

Stock the break rooms with fresh fruit, nuts, and disinfectant wipes. Oranges are great to have around, being good for overall health. The smell of a fresh orange around the office makes people smile inside, doesn't it? Apples are easy to wash and eat and some say provide a pick-me-up as good as coffee. But please, get a good eating apple like a Pink Lady. Shoot, do something unique -- buy and peel a pomegranate for each person in your group. Most folks have probably never seen a pomegranate. You'll be expanding their horizons.

As for nuts, we grow tired of peanuts and who likes cashews anyway? Try pecans, the healthy nut with the highest amount of anti-oxidants. Almonds and walnuts work too.

While you are passing out the hand sanitizer and disinfectant wipes, encourage hand washing.

Do this and you'll create a happy, healthy work environment. Happy people are productive people. For more bright ideas, check out last December's post.

Yet Another Agile Reading List

(Updated October 2018)

I'm often asked for an agile reading list and each time I wish that I had already blogged it. What's kept me from doing it so far is that I tend to write a somewhat new list each time depending on the requester's level of experience, unique situation, and context. Such a list is also likely to change over time, but that shouldn't stop me from posting it -- this post is my thoughts at this point in time. My thoughts are likely to change.

That said, and without further ado or proof reading, here is an agile reading list.

Getting Started
Just go read the Scrum Guide. If you've never read it, you really should. It's short. But you might need something beyond that to gain a better understanding of how and why agile works, so don't stop there...

I could make this easy for me and just say read Cohn's signature series plus the Beck signature series. That'd keep you busy for a while and cover the topic pretty well.

But I can put a little more effort into this. Don't let this long list scare you. Start with this 1st block, then supplement with some of the others. I'm writing this from the point of view of helping a total agile novice get started.

Most importantly, you need to understand the agile values: http://agilemanifesto.org/ and http://pmdoi.org/ and either http://www.extremeprogramming.org/values.html or http://www.softwarereality.com/lifecycle/xp/four_values.jsp or http://xp123.com/xplor/xp0209b/index.shtml.

Here are some links about agile in general and two specific agile processes, XP and Scrum, and one lean/agile approach called Kanban. Just read as little or as much of these as you desire to get the gist of what it's all about:
http://en.wikipedia.org/wiki/Agile_development
http://en.wikipedia.org/wiki/Extreme_Programming
http://en.wikipedia.org/wiki/Scrum_%28development%29
http://en.wikipedia.org/wiki/Kanban_%28development%29

You need a good understanding of the Scrum process since it's the market share leader right now. I really really like Kenny Rubin's way with words and his Essential Scrum book is excellent. This is good: Succeeding with Agile: Software Development Using Scrum by Mike Cohn. Subscribe to Mike's blog.

Here's a good short, quick, easy to read intro to Scrum: "The Elements of Scrum" by Sims and Johnson. It includes some extra stuff that you really should do if you are using Scrum. I liked that. Well written.

I think I'll throw in http://scrumpocketguide.com/# from my friend Peter Saddington. I haven't read it, but it sounds short. :-)

Alternatives or Slightly More Advanced Items
Subscribe to my blog and LeadingAgile's blog :-).

These next few are a bit old, but you need to have read something by "Uncle Bob" and Alistair. You could substitute some other book by them if you wish:
Agile Software Development, Principles, Patterns, and Practices by Robert C. Martin.
Agile Software Development by Alistair Cockburn.

These eXtreme Programming books are great and short and solidly apply to Scrum:
Planning XP by Beck.
XP Installed by Jeffries.
XP Explored by Wake.
Don't get the original white XP Explained book by Beck. It's talks about Load Factors and Ideal Engineering Days which I don't recommend.

If you want to broaden beyond Scrum and XP, read about Crystal Clear and the other Crystal methods by Alistair Cockburn.

Product Owner
Now we move beyond the basics into some specifics. First, let's take a look at the Product Owner related literature:

http://www.agilemodeling.com/artifacts/userStory.htm

Agile Estimating and Planning by Mike Cohn.

User Stories Applied: For Agile Software Development by Mike Cohn.

Here are some great posts from my colleague on The Product Owner:
http://www.leadingagile.com/2011/03/why-a-product-owner-team/
http://www.leadingagile.com/2011/03/product-owner-team-who-needs-to-play/
http://www.leadingagile.com/2011/03/one-real-life-product-owner-team/
http://www.leadingagile.com/2011/03/product-owner-team-design-considerations/

Scrum Product Ownership by Robert Galen. It's not an intro to agile. It's a good, thorough book on product ownership. It's full of good advice and tips and warnings against certain dysfunctional behaviors. The book contains some typos and passive voice that will annoy some people.

The Product Owner role in agile is a big job. And very important. Many say it can't be filled by just one person because no one has all the necessary skills. They say you often need a team of people with diverse skills and responsibilities to do the job well. I tend to agree. Here is some food for thought:
http://blog.xebia.com/2008/05/22/scrum-the-mythical-product-owner-role/

Scrum Master
Next, someone on your team needs to understand retrospectives in depth. If you don't get what you need to know out of the above books, this one is wonderful: Agile Retrospectives: Making Good Teams Great by Esther Derby. Subscribe to Esther's blog.

I highly recommend Scrum Mastery by Geoff Watts. This is an excellent book filled with very practical and though provoking advice.

Lyssa's book, Coaching Agile Teams, is very useful, but the novice should read the others first.

Technical
Here are some more assorted topics:

Agile Testing: A Practical Guide for Testers and Agile Teams by Lisa Crispin. And check out her sequel also: More Agile Testing.

Read Beck's TDD book, Fowler's Refactoring book, Evans' Domain Driven Design book, and Williams' Pair Programming book.

Specification By Example by Gojko Adzic should be in this list as should The Cucumber Book by Wynne and Hellesoy.

Lean
At some point, you might need to know what people mean by Lean as it applies to software. Poppendieck wrote the books on it:

Implementing Lean Software Development: From Concept to Cash by Mary Poppendieck

Leading Lean Software Development: Results Are not the Point by Mary Poppendieck.

To really understand lean, really and truly, read Toyota Kata by Mike Rother. This is about getting everyone in the org to make process improvement part of their daily job, to be very intentional about understanding the current and target condition, and to be very intentional about mentoring everyone about everything I just mentioned. This text will help you have a proper understanding about everything else you read about lean, all the techniques, all the metrics, all the approaches. 

Then read The Goal: A Process of Ongoing Improvement by Eliyahu M. Goldratt, a delightful book. We also have his Theory of Constraints (ToC) text. Goldratt is becoming a very important person to have read, at least for lean/agile consultants.

However, if you read Goldratt, you must also read The Principles of Product Development Flow by Reinertsen. Reinertsen takes exception with the over simplified or at least naïve implementations of ToC (et. al.).

ToC brings us to the kanban process which is gaining popularity. Kanban by David J Anderson is a wonderful book,but lacks specifics on how to do the metrics when the rubber meets the road. Subscribe to the kanbandev yahoo group. Anderson's Agile Management I would say is more advanced and should be read by serious agile managers or coaches. It's a good cross section of lean, pre-kanban, ToC, etc.

Rother's book Learning To See is about value stream mapping from a manufacturing perspective. I enjoyed working through it, but i'm weird that way. Most people in software development organizations won't need this.

Scale
There are books on scaling agile: Practices for Scaling Lean & Agile Development by Larman and Vodde. And Scaling Software Agility, Leffingwell.

Manage
Management 3.0 by Jurgen Appelo is the most important book for anyone leading or managing IT knowledge workers.

Dan Pink's Drive: understand autonomy, mastery and purpose.

Not sure whether to put DeMarco's Slack, Getting Past Burnout, Busywork and the Myth of Total Efficiency here or up under Lean. I have a blog post on slack.

Fin
Sadly, I cannot recommend this book, even thought I have a chapter in it: XP 2003 Proceedings.

Finally, find a local agile/lean/scrum user group to attend and make connections. I can tell you all about the ones in Atlanta and can connect you to people who know all about the ones in Ohio and Chicago and RTP, NC.

There are probably a thousand other folks with their own agile reading list. I wouldn't mind it at all if you were to post your list here or link from here to your site.

Slack and the Manager's Role in Scrum

photo credit: flikr dcwriterdawn

In his book Slack, Tom DeMarco makes the point is that you can't be creative when you are overworked or overburdened. Stress kills innovation as does busyness. To be creative, your mind needs to feel free and unallocated, uncluttered even.

In a waterfall shop, slack abounds. There's the project fuzzy front end where some are idle. There's the test and fix or stabilization cycle at the end of the project where some folks are slammed, and others are trying to not look as idle as they are. And there are times in the middle where this person or that one doesn't have enough work to do. Or maybe they are blocked. If you can put that slack time to good use improving the product, the work environment, your skills, or your process, then good for you.

The problem with Scrum and eXtreme Programming in particular and with iterative development in general is that they wring all the slack out of an organization. There is no unaccounted for time on a Scrum team. You must deliver value in every story. Every sprint must deliver valuable working software. You must help your teammates finish their work for the sprint if they get in a bind. Or add another small story to the sprint if possible. "If ya ain't working on the sprint backlog, ya ain't getting paid!" Little slack leads to little time to look around leads to little improvement.

Thankfully, we have a solution.

We have more than one, in fact. Let me first tell you about the solution that this article is not about. You can introduce slack into your organization with regular slack time. There are numerous well known examples of companies that do things like Fed-Ex days, time set aside for self-directed work, not allocated to Prioritized Product Backlog Items. Dan Pink recently endorsed this approach. As an aside, I like what Dan has to say about what motivates knowledge workers.

But there's another solution to the lack of slack that we should entertain first. In fact, you are less likely to do the FedEx day if you aren't first doing the following. But to introduce this I must first point out something that Scrum says about managers. Scrum doesn't say a whole lot about managers, but it does say at least this: mangers must stop assigning tasks. Too bad that many managers get their power and sense of self-worth from this activity. Deciding how to get the work done in Scrum is left up to the self-organizing cross-functional team. The people who can best decide how the work should be done are those closest to the work.

Just to be clear, managers in Scrum and eXtreme Programming should not:

• make assignments
• hand out work
• direct people or tell them what to do
• make the hiring decision solo
• SW architecture (in my opinion - debatable)
• do work
• be an individual contributor
• be a hero

Well, gosh, then shat should a manager do? Well, I'll tell ya! You could manage more people. You can still step in when the team needs help (but not too quickly). You are still an agent of the company, handling legal stuff, signing off on expenditures, etc. You can still manage risks, especially if you are a skilled Project Manager.

But you could also do something else.





Be the Slack.

Move up to a higher level of value to the organization. Be the slack that has been wrung out of the team. Here are some specific suggestions:

• Keep an eye on the system, looking for improvements
• Ensure cross-training is happening (not by making assignments, but making the team handle it)
• Understand the dynamics of the organization
• Understand how value is created
• Protect the team from interference
• Make the organization effective; learn to look at it as a system
• Support the team
• Clear roadblocks
• Provide good facilities -- fight the facilities police (better: teach facilities how value is created and how better facilities helps you guys create value)
• Ditto with more powerful computers, sufficient build machines and test machines (the people on the team are far more expensive than a PC)
• Use Derby's 13 essential questions for managers or the book on this topic she is working on
• Read Deming
• Watch interpersonal interaction -- watch when one team member pulls back, withdraws in a brainstorm (for example)
• Help the team learn TDD by making room for them to learn (time - remove the schedule pressure while they learn)
• Understand the capacity of the team (also a team and scrummaster job)
• Think through policies, procedures and reward/review systems and improve them (what messages do they send?)
• Understand what motivates knowledge workers (see the previous reference to Pink) and let creating that kind of environment be an imperative

I contend that we should focus on continuous improvement of process, of people’s skills and knowledge, with a strong focus on empowerment and self-organization. And work on open, honest feedback. You’ll have better results if you do all that and just completely scrap the individual annual review.* I love quoting Drucker here: "“the average person takes 6 months recovering from a performance review.”

I'm really straying off the point of the article there. Let me bring it back together by saying you can't do a good job with this other higher value stuff if you are down in the weeds assigning tasks to people. Delegate more. In fact, delegate everything, freeing yourself up to be the ultimate in valuable slack.


----------------------------------------------------------------
* Not sure if that sentence is in my words or whether I've co-opted someone else's way of saying that. I think I've read a similar sentiment in either Management 3.0 or in Coaching Agile Teams. I don't think I've plagiarized there, but will gladly give due credit if I have.