Bits 'n Widgets

Planning, Estimation, and Load Factor

2009-10-01T02:45:56.8791271-04:00

Sprint planning is the exercise of sizing up the work we think we can get done in an iteration. The recommended practice is to size the high-priority stories on the backlog in story points. Story points aren’t exactly well understood by most organizations, but those that do, more power to you.

We take stories off the backlog to package into a sprint not by how long we think they will take (we estimate that after we break down the tasks) but by the number of story points which indicate the complexity. On a team with at least two sprints completed, I always recommend not taking any more story points than were completely delivered in the last sprint – no matter what, even if they were really low due to some odd circumstance. We can always pull in another story if we finish early.

Now, there are teams out there that have a bit of a different mechanism. Stories are estimated in “ideal days” rather than story points. Then, each team member calculates the number of actual work days in the sprint for them (accounting for vacation and known absences etc). Then a more or less arbitrary “load factor” is applied to this number of days, a percentage of 100 (usually 66%) to find out how many “ideal days” worth of work time we have available each sprint.

There are a number of problems with this method as I see it. First, we have an issue of the remaining time – one third. A third of each day goes where? It gets spent doing what? Not counting for meetings (which almost always can be foreseen) there is a lot of time that is unaccounted. The spirit of scrum isn’t to account for each hour and track who does what when. However, there is almost certainly a lot of actual work that people are doing during this time that has no visibility in the iteration. Agile and Scrum DO require as much transparency and vision into the process of the organization, and this practice of “load factor” I think tends to hide some actual work that the team should be getting credit for doing.

My proposal was to use the ideal days estimates, but add sprint backlog tasks for the things that were being done “on the side” to make them visible, and get “credit” for the real work that was being done but not planned and estimated.

The flip side is that things like meetings, applying operating system patches, and answering email don’t have any real value they deliver. So in that sense, they should NOT be on the backlog. These things are accounted for in the number of available hours for “work” – actually developing the new software.

Leave the status reports and department meetings out of the backlog, but definitely put in that “extra report” for the boss or that batch script for the IT guy. Those are at the very least tasks, and they have customer value (to the customer who got them, not necessarily the end user). Estimate them with story points (even if it’s after the fact), and by all means include those points in the delivered stories at the end of the sprint.

This way there is complete transparency. Everyone can see the actual work that got done, nothing falls through the cracks. And later, when stories aren’t being delivered fast enough (according usually to the boss who got the extra report) then everyone can see that the extra half day spent on that report could have been used to deliver a story. The whole team can then really prioritize what the real features are.

Also – there are a couple of inherent problems in the scenario described above… a good scrum master would have blocked the addition of an “extra report” making the boss decide if he wanted to wait until next sprint or abnormally terminate this one… A second problem that is evident here is that perhaps the Product Owner isn’t perhaps taking into account the internal stakeholders and prioritizing accordingly. Either way, we still shouldn’t be randomizing the team by inserting unplanned work in the middle of a sprint. If it’s that important, stop and re-plan the sprint with the new priorities.

Scrum really does work, but only if we have a set of rules that keep everyone accountable for their contributions and the organizational structure in place to keep the team focused on completing and delivering the highest priority work first.

In Lean, how does Eliminate Waste apply to software?

2009-09-18T01:21:55.942-04:00

Lean is one of the three legs of the Agile stool (Scrum, XP being the other two). Lean is a concept originally used by Toyota in manufacturing, and it has been adapted to software development. Lean, Scrum, and XP have some overlap, but they dovetail nicely together, and complement each other's practices to build a strong foundation for software production.

The main tenets of Lean are as follows:

Eliminate waste.
Build integrity into the product.
Enhance and promote learning
Deliver as fast as possible.
Decide as late as is responsibly practical.
Empower the team.
See the overall big picture

The elimination of waste is a critical point in streamlining processes. Waste in this context is anything that does not deliver value (from the CUSTOMER'S perspective). Writing a status report does not add value for the customer, so it would be considered waste, even though it may have legitimate business value.

Waste in software development is most easily recognized as one of the following.

Undelivered or incomplete work
Excessive Process
Extra features
Randomization (switching tasks or projects)
Movement (physically moving from one position to another)
Bugs

Incomplete work isn't shippable, so it is of no value to the customer. It most likely contains bugs also which are lurking below the surface, as it isn't completed yet (fully tested). This concept is applicable on scrum teams directly, by having the team focus on the topmost few stories in a sprint, and complete them (to a shippable and demonstrable state) before opening the next story. This guarantees complete units of functionality that the customer can value.

Some process is necessary in software development, this is computer SCIENCE after all, an ENGINEERING - not art or the wild west. However, process that doesn't directly add value (in the customer's view) are waste. Performance reviews, status reports, departmental request forms, etc. are all waste in this view. Having a checklist to satisfy and having a code review before check-in are NOT waste, they directly add value that a customer can appreciate.

Extra features are complete waste. It has been long known (and widely and variously quoted) that the majority of features are not used in most software products today. It's basically been the 80/20 rule - 80% of the people use only 20% of the features, and that's enough for them to make use of the product and be effective. The other 80% of the features are probably waste, because of the tremendous time and effort that had to go into building, testing, and maintaining them for a minority (sometimes a very lonely few) users. This time and effort should probably have been better spent.

Switching tasks, contexts, randomizations, and interruptions are another source of waste. This includes meetings, phone calls, IM's, etc. Anything that causes members of the team to have to stop thinking about the software and focus on something else. There is a time cost not only for the interruption, but for re-adopting the context and thought processes again when they return to development. Ideas and real progress can be lost this way. Schedule meetings for the last half of the day only, turn off the phone (YES your CELL TOO), email, and IM when working - this will help streamline the focus and eliminate waste.

Movement or motion is a great cause of waste. Not only does it take time, but it can be physically tiring too. If that developer has to walk down the hall 6 offices to ask someone a question and talk face to face, that takes a minute each way. Also, it's the opportunity to be distracted by other things going on, colleagues, a new cup of coffee, etc. Not that these are bad things - they aren't. However, it blocks the focus on development. Starbucks recently applied this concept to its stores, when it studied how much motion it took a barista to make a latte. They discovered that there were extra motions each barista had to make in reaching for the beans, getting out the milk, etc. They moved the beans up from the cupboard to the counter, and some other minor movement-lessening optimizations and saved a few seconds for each cup of coffee made. Overall, they saved several man-hours of labor each day at each store, got the customers coffee even faster, and saved some work for the baristas. This really is a powerful concept.

Bugs and rework are entirely waste. It wasn't done correctly the first time, so it now has to be done again. Study the reasons why your bugs happen, and make sure to track down the root causes and catch the trends. Make fixes around the holes in the processes that allowed the bugs to fall through. It is far more expensive to the customer and to the software producer to fix things early (like when a test fails) rather than after shipping. Think about Windows XP patches, there have been hundreds. If only 10% of them could have been prevented by more extensive testing, the product might have shipped only a few months later, but how many billions of dollars of IT time, download bandwidth, reboot time, and lost progress with the millions and millions of installed users. Not to mention the growing mistrust of the user community for the company.

Elimination of waste may seem like a simple thought, but in a software development process it can be rather complex and sometimes a bit hidden as to where waste may lie, and how to eliminate it. However, once we get this efficiency, we can lower the cost and time it takes to deliver better quality software to our customers.

Pair Programming: Yer doin it wrong

2009-09-10T10:08:18.59375-04:00

This is a pair programming workstation at an undisclosed office near me... it has never been used. Note that there are no chairs...

The mere fact that it exists at all does give me hope however. Agile here is not dead, only frozen in carbonite...

This station also sits in a shared workspace that is always empty. It's so sad when there really is a better way but nobody wants to use it.

If there were only two chairs here, with two programmers working together, then, "yer doin it RIGHT." If there were three more of these workstations with six other team members in this shared space, perhaps working with a couple of whiteboards and a cork board with story cards on it, then THAT'S where I want to be.

This station with its dual monitors, keyboards, and mice is the ideal pairing workstation. Both monitors have the same image (clone mode), and both keyboards and mice are active at the same time. The only complaint I would lodge here is that the workstation is so underpowered it really couldn't be used for development. The pair would have to use remote desktop to get to a development machine. Perhaps that is the actual design, however having the local machine there I think is much better.

Making Differences Work on an Agile Team

2009-04-16T01:31:04.6881685-04:00

On an agile team, there are differences and dynamics at work that can help either make the team more successful or less successful. A good coach and/or scrum master should be able to see signs and patterns on the team where differences exist, and use dynamics as leverage to get the team moving in the right direction.

Differences
There are differences on all teams. Difference shows up in many forms and factors in an agile team. There are differences of opinion, differences in roles, even differences in genders. There are differences in seniority levels, differences in skill levels, and differences of understanding how best to serve the customer. Each of these and other differences can either drive a wedge between team members, or be used as a lever to help guide the focus.

Once we recognize that there are always inherent differences from many perspectives, we can choose to either amplify or dampen the effects of these differences. When teams have both introverts and extroverts, the behaviors of these team members can be quite different. These differences in behaviors for these two types of personalities can be quite disruptive. This is a difference we need to dampen. We can dampen this difference by choosing consciously to recognize the traits of these personality types as a team, understand how they operate and recognize behaviors. When the team understands what behaviors to expect, the behaviors become normal or expected, and people on the team can deal with them effectively. Dealing effectively with the behaviors can dampen the effect of this difference, and help guide the team towards better synergy.

There are other differences that also might be dampened. Level or seniority differences can be a big part of behaviors on a team. Because a person is a higher level in the organization than others, some people may tend to behave differently either consciously or subconsciously towards these people. These differences can and should be dampened by discussing the issue as a team, and everyone knowing what the role is and why they are there, in the context of that team. A working agreement can be struck such that within the team, everyone knows what to expect of everyone else there. The expectations and roles being agreed upon in advance can help dampen this difference.

There are other differences that perhaps should be amplified instead of dampened. Differences of opinion can be a hot topic in a team, but these differences in the end make a product and a team better. Differences of opinion should not be dampened, but encouraged. Not everyone should think alike. Different perspectives generate new ideas, and that drives innovation and discovery. Differences of opinion sometimes generate heated discussions, however the passion can be partly diffused or at least deferred. Team members may be passionate about a particular opinion, but if differences are encouraged, team members will grow to respect others with a different opinion, as they see these differences at times paying off with higher quality software. The difference in opinion can be not only healthy, but essential to the growth and well-being of a high-performance team.

Differences can be used as a tool to help guide a team, or can be its undoing as well, if left to chance. Great team leaders, coaches, and scrum masters can recognize where there are differences and use them as a lever to guide the team in the right direction.

Agile Developer Series - Continuous Integration

2009-02-10T15:19:56.1935-05:00

Here is an article in the Agile Developer series, about Continuous Integration or CI. Why is Continuous Integration is important? Here is some of the philosophy of how we think of CI and some discussion of practical applications. It is a short slide deck presentation in both PowerPoint and PDF formats.

http://testdrivendeveloper.com/2009/02/10/AgileDeveloperSeriesContinuousIntegration.aspx

Agile Developer Series - Video - What makes an agile developer?

2009-02-10T14:55:18.16225-05:00

Here is an article I posted a while back on what makes a successful agile developer. What makes a successful Agile developer? How are Agile developers different from regular developers? Here is the article with a short presentation and video on the topic.

http://testdrivendeveloper.com/2009/02/01/WhatMakesASuccessfulAgileDeveloper.aspx

Transparency

2009-01-26T14:07:49.75-05:00

One of the large benefits of agile teams should be the transparency to see how things are going at any given time. A team typically has a burn-down chart that shows daily (or more frequent) updates to tasks and stories. This chart is a key to seeing if the team is on-target for delivering what it committed to at the beginning of the sprint. Sometimes the estimated time remaining actually goes up, indicating that delivery will be delayed. This information is critical in trying to manage a project. Problems with delivery are part of the software development game, and should be visible so they can be mitigated.

If we see a trend either flat or upward in the burn-down chart (burn-up as it's called), we should be able to react to this information by talking with team members about what is preventing progress from being made. We can take a variety of actions to address impediments - cut stories, re-focus other team members to swarm on tasks, and other things to try to get back on track making progress toward delivery. However, if we don't have the rapid feedback of the burn-down chart, it's hard to see what the current status of the project is. This chart is the heartbeat of the project.

Team members should do their best to estimate stories and tasks, but as we all know, estimation is usually less accurate at the beginning of a task. When we know more, we should be updating the task estimates for time remaining. Using tools like Rally, Scrumworks, or other products, the work and time it takes each team member to add new tasks and change the time remaining estimates should be minimal and manageable. Make sure to remind team members how important it is to keep the tasks up to date on at least a daily basis.

As an agile team, we should be able to see where we are at all times. This information ideally should even be radiated real-time in the team space so everyone can see how things are going - even the casual passer-by. Problems should never be hidden. Problems always come up, and they get solved not by secrecy, but by publicity. The more minds we have on solution, the faster problems can be resolved. We should never look at problems or impediments as either personal or team failures, quite the opposite in fact.

The team should always be able to see how it is doing, and a good self-directing team will notice its own burn-down impediments and re-focus itself on solving the issue without outside help. Newer teams may need the assistance of a scrum master to call out impediments, but the team should still be responsible for addressing its own issues. Only in personnel or political issues should "management" be brought in to assist with solution. If there are roadblocks, the team should be able to call on the scrum master to assist in bringing in anything needed from outside the team.

Once a team really understands the real power of task breakdown and continuous update of time remaining, they can gauge themselves on their own progress and what needs to be done to address anomalies, avert crisis, and succeed at delivering their commitments.

Estimation, Wideband Delphi, and the Cone of Uncertainty

2008-12-10T23:13:41.6665006-05:00

After some training in the estimation technique of Wideband Delphi, I have tried it out in a real project/team environment. I think it was an interesting result, but as a single data point so far, I would hesitate to assess the tool as a success or failure. I will be curious to see how the estimate tracks to actuals for the feature... The use of Wideband Delphi in the initial stages of a project may be a good tool for rough sizing of features or whole feature areas. I am a bit leery of assigning "hours" [ideal hours] to estimates at this very high level of granularity though. Sometimes hours find their way to get turned in to schedules... and ideal hours are even more dangerous as they aren't fully loaded.

The cone of uncertainty is a nice principle that I think might perhaps need more airtime. (Not being a project manager, its a new one on me...) It states that at the beginning of a project, when the least is known, the estimation error can vary from .25X to 4X (not sure where these numbers came from). And as we move toward project completion, the estimation curve shrinks on both sides exponentially to approach 1 at project completion. For more information see the cone of uncertainty link.

However, as the "cone" narrows and we are a bit more certain of what it is we need to deliver, I still think the planning poker type of consensus estimation is more appropriate. It seems a bit lighter weight and much quicker for estimation. Granted, however that planning poker is a tool to be used at the story level (and estimates in points NOT hours), it might not do as well as the WD estimation at earlier stages. It is a similar process, but seems to be a faster implementation.

WD could be a useful tool for backlog prioritization and even perhaps story generation. I am not sure how valuable estimates from WD might be other than to help prioritize (in size and cost) less-well-known things in the product backlog. I still think that the planning poker is appropriate at the sprint and story level though, rather than WD. Another thing that strikes me as different is that WD doesn't necessarily engage the whole team doing the work - only "experts." I like to have the entire team exposed to the information and the planning, even if team members don't have much value to add to estimation at that phase. In my opinion, it helps with information sharing, project background, and overall depth of understanding.

Use the right tool for the right job I always say. I carry four screwdrivers in my toolbelt, two sizes of flat blades, and two sizes of phillips... Use a tool for its intended purpose. Watch out for trying to get too much out of estimation at an early phase, and definitely involve the team - they are going to be the ones who help the project actually come to fruition.

Scrumbut

2008-11-27T09:17:11.151875-05:00

Don't be a Scrumbut.

But is it really OK to be a Scrumbut? Can the scrum process work if every one of the pieces of the methodology is not followed exactly?

Perhaps...

Scrum works best when all of its pieces are used in the process. It is unlikely that the full benefit of the agile methodology will benefit from an incomplete process. However, in the real world it is sometimes very difficult to get an organization to adopt each and every piece. I think however, that even the teams using incomplete scrum might still be able to get some value out of the pieces that are adopted. Sometimes being a Scrumbut is still better than floating in the barrel as it goes over the waterfall...

It's not a perfect world.
If you happen to be on a scrum team that really gets the idea of scrum and is able to make each of the pieces of scrum work for you, then I say you are a very lucky person indeed. Personally I have been on several teams this way in my career and I can say that there is no better way I've ever seen to develop software. But while the world is round, it isn't a perfect sphere. Sometimes things are a little bit off. Yet, I believe that things can still spin around and everything can still work, if there is a clear plan.

Why?
As a consultant, my first instinct is to look at the process being used and question everything. I ask people why things are the way they are. Especially when I see something that doesn't seem right to me, coming from a perfect scrum background. Sometimes it takes time for an organization to be able to trust a new process. Some organizations have to bite into something new in pieces rather than adopting a completely new process all at once. I don't like it... it's not the best way... but sometimes it's the ONLY way. Something is better than nothing - as long as it is adding value. That is the real test I think: does it enhance the value of the software delivery process?

Yellow Light
Caution. That is the word I use when I see Scrumbut in action. I am looking for signs of devolving process rather than evolving process. If a team has adopted scrum's tenet of documenting what is actually delivered rather than big documentation up front, but then really isn't getting the concept or delivering the documentation as required by the stakeholders, the it really isn't working and someone is going to be dissapointed. Dissapointed stakeholders can then poison the entire organizations' view of the scrum process, and that can be the last nail in the coffin. Caution I say - we don't want to let this happen.

Perfection vs. Good Enough
I strive for perfection in the process but it's really a very lofty goal. As a consultant though I have to realize that I am there to help improve the process, not get it to perfection. I need to look for the warning signs that might dissapoint stakeholders, and advise course corrections for these things when they come up. Practiality is essential in software delivery, even if imperfect in process. The iterative model should give value, even if each of the pieces of the process isn't followed completely.

So, don't be a Scrumbut. Unless you have to. then if you have to - make it work, and watch for the warning signs...

When Sprint Burndown Becomes Burn-up

2008-10-12T10:19:16.101-04:00

There are times on a scrum team when things don't go quite as planned in a sprint. Sometimes things get in the way of accomplishing tasks and the estimated time remaining on tasks either stays the same or rises. It's not an uncommon circumstance on most teams. However, when burn-up happens, we need to understand what's going on with the team and how we can address it to make better forward progress.

Burn-up is usually an indication that task estimation is not as accurate as is desired. There are other issues that can cause it as well, but estimation is usually the biggest. The whole reason we do the Scrum process is so we can get feedback on a short interval and we can learn from our small mistakes. We then can get better at what we do, increasing our velocity and reducing the estimation errors as quickly as we can.

Here are some of the things to watch out for which I have found cause burn-up to occur - and what can be done about it.

Poor estimation - this is a big one. After all, estimation is one of the big reasons we do Scrum...

Estimates are too low, because tasks were not broken down into small enough pieces.

When sprint planning is cut short or not enough emphasis is put on analyzing the story by the team, some things can get missed. Encourage the team to take the time to think carefully through the story and do a bit of design and a bit of architecture for the story so it will be clear what needs to be done to complete the whole thing. Estimates for tasks should be in hours, and ALWAYS be SINGLE-DIGIT. If your team is taking a different approach - this could be a warning sign.

Unclear/Misunderstood story

If a story is vague or too complicated, it will be difficult to break down, and estimation will typically miss lots of things that will expand the estimates as they are discovered. I have seen the teams gloss over some complications just because they are scared to deal with it in sprint planning - fearing it will eat lots of planning time. Avoid the complicated stories - think in thinner "slices" of functionality. Make sure that everyone is clear on the terminology used, and that it's the customers vernacular. Everybody should be speaking the same language and one term should mean the same thing to each team member and customer alike.

Poor acceptance criteria

Acceptance criteria are critical to successful estimation. Spend at least 1/4 of the sprint planning time on discovering and documenting the acceptance criteria for stories - up to half the time if really needed. The acceptance criteria are really THAT important.

Leaving things out

Teams tend at first to see and estimate only the mainline development tasks. If a team is constantly missing estimates for stories, emphasize having a DONE list that enumerates what it takes to complete a story. Include tasks from the DONE criteria in the story tasks if they are being forgotten. There are those who might disagree, but I think there is nothing wrong with having lots of repeated sets of tasks for each story, if it accomplishes the goal of better estimation. Add test/qa tasks too if they seem to be getting left out of the estimates/

Work on items not in the sprint backlog. This is a big one also.

People are being randomized with tasks not on the backlog. This kind of thing is not supposed to happen, but it does. The world is not a perfect place - so be it. When these tasks happen, get them on the backlog! Don't slip them in under the covers. Even (and especially) if the tasks are not related to delivering the software - get them and their hours in the sprint backlog. At the very least they can be covered in the retrospective and they will be brought out into the light instead of being hidden.
Production problems. This is a tough one. It can't always be estimated or guessed at. But, most teams budget a bit of time each sprint for production support. Call it a spike, or time-box the estimate at a certain percentage of the sprint's total hours. This may not be accurate, but at least we can account for it with a place holder. Production problems are usually a process smell anyway, but that discussion will occur elsewhere...
Extra management-added tasks. A Scrum master should be insulating the team from these kinds of changes. Scrum master needs to better negotiate with the management that is adding tasks and explain to them why issues like this can derail a team.
unforeseen meetings. Sometimes meetings are important and required, and aren't known at sprint planning time. A Scrum master can negotiate for these not to be attended by the team or at least part of the team. The Scrum master can at least explain how these meetings stall progress on delivering software, and make the case for comparing the software delivery value for that time to the benefit of attending the meeting. In most cases software delivery wins...
Out of the office or illnesses. These can't be predicted. If they occur on a regular basis, a Scrum master can take an educated guess at what these absences might be and enter an actual story for it. While I don't particularly like this approach, when it is on the sprint backlog, it does get visibility for the issue.
Work items that weren't estimated in planning. Are things like extra features or enhancements being added to existing tasks? If it wasn't asked for specifically, it shouldn't be written. Good acceptance criteria here would be a great yard stick to determine if these work items are really relevant. Make sure as a Scrum master that you are keeping the team focused specifically on the exact functionality to be delivered.

Team members not updating the remaining hours

This is a relatively common but easy fix. I like to remind people just before stand-up to make sure to update the sprint backlog with today's estimates on time remaining for tasks that are in-progress or not yet started. Every day we know more, so we should be able to fine-tune estimates as we go along. We depend on these changes to make our sprint backlog burn-down as we work.

Scrum specifically states that we should not be working on anything that isn't specifically mentioned in this sprint's backlog. There are however, practical issues that come about which will almost certainly require us to be flexible on this point.

If we use these points as indicators and even as alarms, we may well be able to keep our teams on track and deliver more software functionality to our customers.