Search This Blog

Monday, January 23, 2012

Prioritization Method - MoSCoW prioritization or MoSCoW analysis

This technique is commonly used to reach a common understanding with stakeholders on the importance they place on the delivery of each requirement


MoSCoW is often used with timeboxing, where a deadline is fixed so that the focus can be on the most important requirements (the two ‘o’s are there just to make the acronym work)


Must have
Requirements labeled as MUST have to be included in the current delivery timebox in order for it to be a success. If even one MUST requirement is not included, the project delivery should be considered a failure (note: requirements can be downgraded from MUST, by agreement with all relevant stakeholders; for example, when new requirements are deemed more important). MUST can also be considered as Minimum Usable SubseT.


Should have
SHOULD requirements are also critical to the success of the project, but are not necessary for delivery in the current delivery timebox. SHOULD requirements are as important as MUST, although SHOULD requirements are often not as time-critical or have workarounds, allowing another way of satisfying the requirement, so can be held back until a future delivery timebox.


Could have
Requirements labeled as COULD are less critical and often seen as nice to have. A few easily satisfied COULD requirements in a delivery can increase customer satisfaction for little development cost.


Won't have (but Would like)
WON'T requirements are either the least-critical, lowest-payback items, or not appropriate at that time. As a result, WON'T requirements are not planned into the schedule for the delivery timebox. WON'T requirements are either dropped or reconsidered for inclusion in later timeboxes. This however doesn't make them any less important.
Sometimes this is described simply as "Would like to have" in the future, this however leaves some ambiguity in the minds of the users as to its priority compared to the other marks.


This technique is good to be used during the release planning so that the entire team will be getting to know what is expected of them. Also this technique is an iterative and ongoing one.


If new "Must Have" requirements discovered during project then we need to renegotiate scope i.e. transfer equivalent effort of Should and Could Haves to Won’t Haves and renegotiate what are now Must Haves to maintain agreed percentage of effort for remaining time


And If it becomes clear that all agreed "Must Haves" cannot be completed then immediately STOP THE TIMEBOX then Re-estimate, Re-negotiate and Re-schedule the time and scope. Also make sure that you will never extend a timebox in order to achieve the Must Haves. Because time and budget are fixed, the only remaining variables are the requirements. So if a project is running out of time or money the requirements with the lowest priority are omitted. This does not mean that an unfinished product is delivered, because of the Pareto principle that 80% of the project comes from 20% of the system requirements, so as long as those most important 20% of requirements are implemented into the system, the system therefore meets the business needs and that no system is built perfectly in the first try.


Thursday, January 19, 2012

Story pointing to Bugs – Is it needed?

Story pointing is generally done to have a good idea for our release planning and see how much we can commit to the customer
Bugs can fall into one of the following category


• Category 1: Bugs in the current sprint

• Category 2: Bugs from the previous sprints

• Category 3: Bugs from the field.

So should we story point the bugs which fall in any of these categories? Not really
We can strategize in different ways to handle the bugs.

Case 1
Let’s say we have a feature and its story pointed also our definition of DONE means: Feature should be completed without any bugs in it. In this case the bugs that are falling in the Category 1 (i.e. Bugs in the current sprint) should be completed in the current sprint itself and we should not story point the bugs separately since we have already story pointed the feature. Again story pointing the bug will give a false velocity of the team.

Case 2
For example we have a feature that is already completed in the previous sprints let’s say SPRINT 1 and we have marked it as DONE. Say we are in SPRINT 3 and found any issue with the feature that was marked as DONE in SPRINT 1. How are we going to handle that?

These types of scenario falls under the Category 2(: Bugs from the previous sprints)

We can use the following strategies.

a) We can ask the PO to review the bug and see how important that is .Accordingly can request him to prioritize and take that up in the next sprint depending on the priority. If it’s a high priority issue , team can story point the bug or we can follow the next approach i.e.

b) During our sprint planning we can allocate some amount of time from our actual velocity for handling Category 2 bugs so that we need not story point for them.

For example our total velocity for the sprint is 100hrs; we can allocate say 10% for bugs from the previous sprint so 10hrs will be blocked for any issues coming from the previous sprint.

Note that these hours should not be fixed, if there are no bugs coming from the previous sprints then it should be used for feature development.

Case 3:

There might be issues coming from the field. This issue should be routed through PO.

PO will be deciding how important the bug is and he will decide whether it should it be taken as a bug or should it come as a new feature.

If we are taking it as a bug then what every point mentioned in Case 2 will be applicable.

And if it is coming as a feature then we will story point them.

The bottom line is PO and Team should discuss, agree and come up with a strategy that can be best used to tackle any type of bugs.




Monday, January 16, 2012

Estimation the agile way


"The primary purpose of software estimation is not to predict a project’s outcome; it is to determine whether a project’s targets are realistic enough to allow the project to be controlled to meet them."—Steve McConnell, Software Estimation: Demystifying the BlackArt


Estimate means
• To calculate approximately the amount of work
• To form an option about.

But people often treat estimation as the actual figures and commit to some work. This often leads most projects into trouble.

In agile, it is accepted that the initial estimations aren't to be trusted but at the same time it also understands that some expectations need to be set and budgets need to be created.


To make this happen we use the Stories and a concept of Relative Sizing.


User Stories are short descriptions of features our customer would like to see in their software.


Estimating relatively is something we are good at. Let’s say we have two balls in front of us we can easily say how much big one ball is than other. But we might be in a soup if asked to tell exactly how much bigger it is.


Relative sizing can be achieved by using point-based system. Using this approach our measure is always relative not absolute. Here units of measure don’t matter.


All we are trying to do is to capture the size of the task.


Let’s say we some category as follows

Now want we do in relative sizing is as a team we take each story discuss about it and each person in the team will rate some point against that story. If all persons in the team rate the same point they finalize it and move ahead. If there are some dissimilarities they will talk among themselves and justify and try to convince others why the point were given and finally after discussion all will be coming to once conclusion and arriving at a point.


Planning poker is one good example of doing the relative estimation. For more details about planning poker check out this link http://en.wikipedia.org/wiki/Planning_poker


Some advantages of using relative sizing is


• It reminds us that our estimates are guesses.


• It is a measure of pure size. They are more accurate and have less variation.


• It’s fast, better, and cheap

For more information how story point is better than hours check this out


Story Points: Why are they better than hours?


Basic documentation for scrum for beginners

The scrum guide on Scrum.org is probably one of the better places to start with . Please refer to http://www.scrum.org/scrumguides/


Sunday, January 15, 2012

Agile management

Agile management is an iterative method with the aim to satisfy the customer with early and continuous delivery of working software


There are different flavors of agile











For agile manifesto please refer to
http://agilemanifesto.org/


For agile principles please refer to
http://agilemanifesto.org/principles.html