Blog

Everything you need to know about tinyPM. Everything we want to tell you about agile.

Archive for the ‘agile’ Category

Shall I split my stories? Yes… I mean No!

September 3rd, 2010 by Marcin Niebudek

There is a story card on our wall estimated to 8 points. It’s so easy to tear it down and put two new 3- and 5-point cards instead of that big one. Cool, we can even move one of them to the next sprint. No, no, no…

But wait there is another story in our backlog. This one is big… No problem – lets split it into smaller functionalities. Yes… and yes!

So what’s the point? Is there a problem in splitting stories anyway? The short answer is “yes and no”. It’s because the problem lies not in splitting stories, but in the moment when we do it. There are usually to points in time when we think about dividing stories into smaller parts: release/sprint planning and the end of current sprint.

Plannig

This is the moment when we think about stories before we start implementing them. We choose what is possible to do within the planned period of time. We gather detailed information about stories that should be implemented first. This is the moment when we try to plan the work that fits into our capacity usually driven by some observations of our recent velocity and other factors.

At this point we may find some stories to be too big to fit into the sprint, but we realize that we can split them into smaller independent parts that are still able to bring value to our clients. We choose more valuable stories and leave the other for a better time or even get rid of them. This is where I say YES to splitting stories.

End of sprint

Next time we tend to think about splitting stories at the end of our sprints. This is caused by one reason – we just can’t finish the story by the end of the sprint. We thought we will, but (again) it wast one story too much. Actually we have it almost done. And this “almost done” tempts us to split the story, leave the finished part in the current sprint while moving just the unfinished chunk into the next timebox. Hurray! Our velocity, charts and metrics have been saved once again!

This is the moment what I say NO to splitting stories. Story should be either fully completed or moved to next sprint. And yes, velocity should drop this time. This is the only way to spot the problem in the long term. Ok, it’s not a problem when it happens once. But if we will break down stories at the end of the sprint regularly to keep our velocity untouched then we may miss the root problem (there will be no sign of it, except for a not so happy face of our PM/SM who needed to tell our client about yet another unfinished story).

The root problem of unfinished stories may be:

  • (most likely) wishful thinking – we keep thinking that we can do more this time and load our sprints with too much stories
  • too short iterations – the amount of features for the increment is good (less of them would not give any usable product) but we try to implement them in to short iterations, so maybe one week is to little and we should switch to two weeks
  • inaccurate estimations – if we have lots of unfinished stories every sprint this means that those stories tend to take more time than we thought and if it keeps happening then we should rather reestimate some of them and try better understand what they are about

So think about when you usually split your stories? Maybe it’s time to look deeper into your process.

Getting the Most From tinyPM’s Project Tracking

June 28th, 2010 by Marcin Niebudek

tinyPM provides at the moment several ways to track project’s progress using different types of charts:

  • project scope burndown chart (3 types)
  • project budget tracking chart
  • iteration scope burndown chart (based on story estimates)
  • iteration scope burndown chart (based on task estimates)
  • iteration scope burndown chart (based on reported time left on tasks)

Those charts are driven by four types of data available in tinyPM:

  • effort, on the user story
  • effort, on the task
  • time spent, on the timesheet activity
  • time left, on the timesheet activity

All those elements are optional to use and every user can choose for herself if she wants to use only some of them or all. You will find a cheat sheet with a summary on all tinyPM charts in our documentation at:

http://documentation.tinypm.com/display/DOC/Charts

Entering each one of those elements provides different level of insight into project state, so let’s have a look at what can we see in tinyPM by providing each of that data.

User story estimated effort

You can enter estimated effort for every user story. This is the most important and most commonly used number in tinyPM. Story estimates allow planning, are used to calculate average velocity that tinyPM suggests as capacity for newly created iterations (planned velocity field). Finally story points drive all project scope charts, iteration burndown based on user stories. Story points are also used for drawing scope series on budget tracking chart.

tinyPM Backlog

We’ve been posting some information about types of project scope charts available in tinyPM in the article Burning Down, Climbing Up, but let’s recap some key points from the tinyPM user’s perspective.

Project scope chart based on total effort. This chart start with the value of total estimated effort entered for all stories in the backlog. Every completed story (all tasks completed) burns this chart down (blue line). This type of chart contains also the green line calculated from planned velocity entered for each iteration. This type of chart never goes up.

tinyPM - Project scope chart based on total estimated effort

Project scope chart based on initial effort. This chart starts with the sum of estimated effort entered for stories created before any iteration is created. For each iteration we calculate currently estimated effort for all user stories. This means that if any story is removed during some iteration then the chart will fall down faster, but if some stories are created during such iteration (after the start of the project) then the chart may even go up (if stories added are worth more points than stories completed during that iteration). Effort completed for each iteration on this type of chart is calculated using the following formula:

effort left (real) for iteration N = estimated effort of stories created until iteration N – effort completed by iteration N

tinyPM - Project scope burndown based on initial estimated effort

Project burnup chart. This type of chart is the easiest one to use as it starts with zero and every story completed during each iteration pulls the effort completed line (blue one) up by the number of story estimated effort. All changes in total scope of project (stories added or removed during project) are represented by the additional series of total scope (gray line). If all stories are created before initial planning of iterations then the gray line goes up at the beginning and and stays constant during all iterations. However if any user story is added later in the project (and has estimated effort defined) then this line goes up and the whole point is that both blue and gray lines meet at the top right corner of the chart at the end of the project.

tinyPM - Project burnup chart

Iteration burndown (“User stories”). This chart is similar to the project burndown based on total effort. It starts with the total estimated effort for all stories added to the iteration. On the day when user story is completed (all it’s tasks are completed), the chart is burned down. This means that this chart works well for projects where stories are relatively small within the iteration and are quickly completed. Otherwise this chart may stay unchanged until the very end of the iteration when all the stories are finally completed within one or two days.

tinyPM - Iteration burndown ("User stories")

Effort on the task

You don’t need the tasks estimation if you have small stories that can be completed within one or two days. In this case estimates on stories and iteration burndown based on those estimates are totally enough to track project and iteration progress with a proper level of detail.

tinyPM - Taskboard

However if you stories get bigger and you like to define more tasks for each story, then you may want to start tracking tasks instead of stories. In this case tasks can use different scale of estimates than stories (defined in project settings page). This gives a possibility to:

  • estimate tasks using relative scale like story points
  • estimate tasks using time units

If you only want to escape the trap of big stories completed mostly at the end of iteration then the only thing you need is to have more detailed tasks in those stories. tinyPM is able to present two types of iteration burndown chart based on tasks.

Iteration burndown (“Tasks”). This chart may work with tasks without any estimates. If tasks estimation is turned off then all tasks will be treated as even (assuming they are small enough to be completed within a day). They burn down they chart when they are completed. Additionally each task in progress is presented as the yellow area on the chart so that it’s possible to see if a lot of work is in progress but not completed. If the tasks are estimated, then the estimates are used to calculate the burn rates on the chart and bigger tasks burn it quicker than the small ones.

tinyPM - Iteration burndown ("Tasks")

Iteration burndown (“Effort left”). This chart (apart of task estimates) requires entering time left on tinyPM’s timesheet. However if you don’t do that and provide only estimates for tasks you will notice that it will look like the one based on “Tasks”.

Time left on the timesheet activity

Time left comes from Scrum methodology when it’s declared every day for each tasks in Sprint. Iteration burndown (“Effort left”) starts with total estimated effort of tasks. Thats why, if you plan to use time left from timesheet, then task estimations should be also done using time units. After that, for each iteration day, all time left values are added up to calculate total time left to complete iteration.

tinyPM - Iteration burndown ("Effort left")

This type of chart may go up if some day during the iteration we find out something that makes completing the task impossible withing the initially estimated time. At that point we enter higher value of time left for such task in the timesheet. So this chart to work properly requires both – task estimation and timesheet entries with time left for those tasks.

Time spent on the timesheet activity

Time spent entered in the tinyPM’s timesheet is used only on the budget tracking chart. Also the story estimated effort is used in this type of chart to calculate the scope line (blue one). Total effort entered for all stories becomes 100% of scope on this chart, while budget (in man-hours) entered for project (on project settings form) is used as 100% of budget (red line).

Each story completed burns down the scope line while, each hour entered as time spent (on timesheet) burns down budget line. More on budget tracking idea you can read in the article “We’re in the Right Truck!“.

tinyPM - Budget tracking chart

tinyPM - Project settings form

Three Weeks Left to OpenAgile Romania

April 26th, 2010 by Marcin Niebudek

Not so long ago I’ve been writing about first edition of Agile Central Europe and now there are only three weeks left to another very promising agile event in our region – OpenAgile Romania.

OpenAgile Romania - May 14-15th - Bucharest

The conference has a very interesting speakers lineup and along with AgileCE and upcoming Agile Easter Europe makes a great set of affordable and very high quality agile events in the Central/Eastern Europe. So make sure you won’t miss it!

tinyPM Team is also proud to be able to support this event as a Bronze sponsor. Early bird registration ends on May 5th, so register and visit Bucharest this spring.

AgileCE 2010 – Summaries and Thoughts

April 11th, 2010 by Marcin Niebudek

AgileCE 2010 is over. It was a great organized, unique in terms of scale and speakers agile event in Poland. All talks were recorded and will be probably published at the conference website, but here are some notes from the lectures I’ve attended and find interesting to share just right now.

AgileCE 2010

The Talks

Jens Korte – ScrumFluenca

Jens presented part of his great work on documenting sources, influences and theories that led to forming Scrum method and keep influencing all kinds of agile movements. Jens made a very interesting chart which you will find at http://www.agilefluenca.org and I strongly recommend you to take a look at it. This is a really good piece of work, that I hope Jens will continue to update.

Monika Konieczny – How to cope with communication problems in an agile project?

Monika presented an idea of using simulation games to improve communicating some ideas within teams and mentioned also an interesting theory called “The Fun Theory” which I like very much (see http://www.thefuntheory.com). All that started with a very funny game of backing cake by an IT team :-) You should definitely watch it when the video will be available at AgileCE site.

What I missed in Monika’s talk, were 2-3 cases or real projects examples of games that solved some particular problems which would turn the talk from theoretical to more practical.

Zuzana Sochova – Company Culture as the Key Agile Milestone

Zuzana presented some of the results of her MBA research on organizational culture influence on successful agile adoption. Zuzana already posted slides from her talk at http://www.slideshare.net/zuzuzka/company-culture-as-the-key-agile-milestone. Also the survey results are available at Zuzana’s blog (http://soch.cz/AgileSurvey.pdf)

Paweł Lipiński – Being an agile nearshore team

This was the best Pawel’s presentation I’ve seen so far. It’s because his talk was based purely on his experience from running his own company Pragmatists and building there a really agile environment. What we miss the most on agile conferences are the real cases and examples agile / xp implementations instead of all that couching / consulting theory many time full of wishful thinking. This presentation was real from the start to the very end.

There are also a few interesting ideas that I’ve noted out from Pawel’s talk:

  • using a single user in your version control system along with pair programming to eliminate blaming and empower collective code ownership
  • customer clicks through the application during the demo session – this makes him focused on what he actually accepts
  • often pair switching when pair programming prevents team members from achieving small small goals and successes (like finishing a single task) and does not work well – switch pairs after the task is done
  • customer not paying for not accepted work – encouraging time and material way of work by sharing a risk

Paweł Brodziński – The Kanban Story

Same as with Paweł Lipiński talk, this one also contained thoughts and motivation from the real life example of implementing Kanban. A few thoughts I’ve noted out:

  • Kanban without strong engineering practices produces garbage (garbage in – garbage out)
  • change of the Kanban board triggered by the team member that holds a sticky note and does not know where to put it

We also continued the talk about Kanban on the open session during the lunch break. You can read the full story about this kanban implementation at Pawel’s blog:
http://blog.brodzinski.com/2009/10/kanban-story.html

Gwyn Morfey & Laurie Young – The Sword and Other Tales

This was a great and entertaining closing of the AgileCE. The talk’s (or shall I say performance) main theme was how to focus on quickly and without unnecessary ceremony solving all kinds of  issues that an agile team may face. Gwyn and Laurie talked about how to change and improve the solutions to make them stick. Definitely a video worth watching when it will be posted at AgileCE website (you will find out about sword of integration, stealthholders, heat-seeking actions and more).

Short Retrospection

So what went well?

  • The venue was great and perfectly prepared for this kind of event
  • Good set of talks with interesting and original content that we couldn’t hear before in Poland / Central Europe
  • Very well organized (kudos to Paul Klipp and his team!)

What could be done better?

  • Open Space sessions during the event of this size (150 – 200 people) should get their own piece of time line during the tracks instead of competing with the talks. The most talks has been scheduled during the lunch break as the most people did not wanted to choose between talks and open space sessions.
  • Marketing should have been started much earlier. I had an impression that many people did not had a chance to come to AgileCE because they just learned about the event to late.
  • The schedule should be posted earlier next time (even if it about to change slightly later on) because many people decide about attending mostly by looking at conference talks and schedule.

Overall the event was great and as tinyPM team we’re proud we could support it as the Bronze Sponsors. Now we’re waiting for a next great event in Kiev (AgileEE) and definitely are waiting for a next AgileCE in 2011.

Burning down, climbing up…

November 10th, 2009 by Marcin Niebudek

tinyPM 2.1 introduced three types of project scope charts. We would like to write few words about differences, advantages and disadvantages of using each of them. We will use all three types of charts on the same project data, this way we can better compare the information that can be read from them.

Burndown chart

(with initial project estimation as a starting point)

Burndown (type I)

As you can see, the project started with a backlog containing stories worth about 50 story points in total. When we use the initial estimation as a staring point we simply put the total backlog effort on the chart and each following iteration we mark how much effort there is still to be burned (blue line) and what is the expectation (the green line).

The green line never goes up because this would mean that we expect negative velocity. However the blue line may go up in one case, which is a feature creep.  In other words, the line goes up when at some point of time (T10) more new stories get into our backlog than we can actually complete. This way at the end of the iteration we have more effort left than we had at the beginning.

So we can instantly see the feature creep effect using this type of burndown. But what can we say about our team’s activity between T10 and T14 or even T20? Did they do anything? Iterations where passing by (green line continuously heading down to the level zero) but we cannot see any significant move on the blue line. Does it mean that the team did not do anything, or that the backlog got as many user stories each iteration as we could complete. Actually it may be each one of those explanations. So the point is, that with this type of burndown we don’t know that exactly.

Finally when the green line hits the zero level we can see how late we are.  In our scenario the project was supposed to be finished by the T14, but at that point the team was still missing over 30 points (new stories not included in the initial scope) and the distance kept growing.

You may say this project was in a deep trouble, but we intentionally chosen such data, because when everything goes well and the lines dance close to each other, there is nothing interesting to observe and the devil is in the details. What is so valuable about burndown charts, is that they can quickly warn us when some bad things start to happen. This project could have actually be rescued somewhere between those T10 and T14 points.

Advantages:

  • simple to draw even on the white board
  • can show a feature creep
  • can show the point where the team loses the ability to actually complete the project

Disadvantages:

  • doing nothing and doing only enough to balance a feature creep looks the same on this kind of chart
  • cannot read the velocity out of this chart
  • your backlog needs to be estimated at the beginning, otherwise you will soon cross the zero level (which will look odd)

What types of projects is it good for:

  • good for projects with some initial vision represented in the backlog and estimated at the beginning (at least as the epic stories)
  • good for projects with fixed-price contract as then we usually have an initial estimation and we want to watch it burned according to a planned velocity

Burndown chart

(with total estimated effort as a starting point)

Burndown (type II)

This type of chart is recalculated each time it is viewed and the burndown always starts with the total currently estimated effort for all backlog items. So even if the project stars with about 50 story points, when we take a look at it after few iterations it shows current total which may be for example 80 points.

Here we can only observe the relationship between plan and execution. We assume that stories may be added to the backlog at any point of time. We may even start with few stories. Until the blue line stays under the green one, everything is fine. If we accept all those new stories (by simply extending the budget or by working based on T&M contract) then at the point T10 there is no trouble in our project – we’re still doing fine having velocity higher than expected.

At T14 we can see that the development stopped for some time. Probably at the point of T14 it reached zero (and maybe has been released), but later the velocity started to decrease (blue line above the green one).

On this type of chart both lines always go down. It does not tell anything about the feature creep in the project, but only about the changes in the team’s velocity.

The last observation that we can make with this chart is that at T29 planned effort reaches zero while there is still some real work to be done. This means that even with all those new stories we should have finished at that point and now we’re getting late.

Advantages:

  • you may actually see the changes in team’s velocity in the project
  • does not require any initial estimation, nor the fully populated backlog

Disadvantages:

  • hard to maintain on the white board (requires recalculations for the past iterations)
  • feature creep may not be seen
  • treats all stories as “must haves”

What types of projects is it good for:

  • as it does not require any initial estimation it’s best for some research projects or exploratory work where stories are invented based on the results from the recent iterations

Burnup chart

Burnup (type III)

This type of chart actually climbs up. It also introduces the third series (gray line) which is the “current total effort”. It combines advantages from the both previous burndows and at the same time does not have their disadvantages.

We start the project with zero completed and planned effort. Total effort may start also with zero or it may start with some initial backlog stories estimation. The goal is to reach the “total” gray line with the blue one, so actually build all those planned features.

Here we can clearly see both – the velocity of our team (on the blue line) as well as any feature creep by looking at total effort line (gray one). If the gray line goes up, then stories are being added to the backlog (or re-estimated with some higher values) . When it goes down, it means the scope to reach gets smaller.

At the T10 we’re doing fine in terms of team’s velocity but at the same time our project scope gets larger. It’s time to decide if it’s something wrong or if we accept those new ideas. At T14 we’re done with some part of our product, and it looks like we’re are done just in time. However there is still lot to do (for example for release 2.0). T28 is the point when we actually planned to reach the goal (green line meets the gray one), but somewhere between T14 and T28 our team has lost it’s initial velocity and now we are still missing about 20 points (blue line still not there).

Advantages:

  • shows most of the interesting patterns in all kinds of projects
  • easy to maintain even on the white board

Disadvantages:

  • none that we know of unless you find this chart being painted upside-down ;-)

What types of projects is it good for:

  • all types of projects

We hope that those examples will let you better choose the best type of chart for your project. We are waiting for you suggestions or any other ideas on how to visualize the project status even better.

Agile Team Meets a Fixed Price Contract

October 20th, 2009 by Marcin Niebudek

Recently we gathered some of our thoughts and practices about fixed price into a longer article which starts the series for agile techniques that work (don’t know yet how often we will be able to publish one of these).

Agile Team Meets a Fixed Price ContractWe like to say that fixed price contracts are evil, but they are reality which many agile teams have to face. So what if we try to tame it instead of fighting against it?

The main point in the “Agile Team Meets a Fixed Price Contract” is that what actually bothers us in the iron triangle is not a fixed price nor the time but the scope which is defined upfront. So what actually the agile team needs to try, is to change the explicitly defined requirements into scope defined as the amount of work which has to be done.

In other words, exchange a “what” into “how much” value we need to deliver because “what” is about to change and we want that change to happen. How the company can execute this kind of contract using agile practices to achieve better results with lower risk?

Take a look at the full article in the white papers section:

http://www.tinypm.com/whitepapers

As always we are waiting for your comments. What works for us may not work for you, so we are always happy to hear about new ideas that worked in your context.

All Those New Old Ideas

September 24th, 2009 by Marcin Niebudek

I’m still about to write a roundup of AgileEE conference that we attended in Kiev few days ago, but just to warm you up I want to try a little quiz (somehow inspired by J. B. Rainsberger).

Take a look at the following quotes I’ve chosen from a single article:

  • “For some reason what a software design is going to do is subjective to wide interpretation even after previous agreement. It is important to involve the customer in a formal way so that he has committed himself at earlier points before final delivery.”
  • “[...] Every bit of code should be subjected to a simple visual scan by a second party who did not do the original code [...]“
  • “To give the contractor free rein between requirement definition and operation is inviting trouble.”
  • “Test every logic path in the computer program at least once with some kind of numerical check.”
  • “Without this simulation the project manager is at mercy of human judgment.”
  • “If the computer program in question is being developed for the first time, arrange matters so that version finally delivered to the customer [...] is actually the second version insofar as critical design/operations areas are concerned.”
  • “Each and every worker must have an elemental understanding of the system.”

Do you see all the customer involvement, common vision/goal, code reviews, unit testing, prototypes that I see in this? So the question is where do those quotes come from :-) But don’t cheat :-) Make a wild guess.

I’ll post a response in the comments in few days if it’s needed (but I don’t think it will be necessary). So have fun while thinking about it for few minutes.

Sprinting on a long distance

August 11th, 2009 by Marcin Niebudek

I find SCRUM’s “sprint” a very intriguing name for an iteration. In the heart of agile development there is continuous delivery of a working software. To do that we time-box software development into iterations / sprints.

They have their rhythm and require different kind of discipline from our team. We become sprinters who continuously plan, test, implement, evolve architectures, deliver, improve the process, celebrate to finally be back in the starting blocks to launch another sprint. We do that iteration by iteration.

Can sprinter be a long distance runner?

A very common technique in agile projects is tracking team’s average velocity. It’s said that it should stabilize after few initial iterations on some level. This is also called finding a sustainable pace for a team, which in short means that our team members commit to just enough work to become productive without burning out to early at the same time.

I’m not going to convince you here why a sustainable pace is a good thing and why a tired developer is not going to be efficient and creative. It’s the opposite that always intrigues me in the name “sprint”.

When we sprint, we put all our energy to run a short distance (a single iteration) the best we can. However we plan our efforts differently when we are about to run a marathon of 20 iterations. So how long are we able to sprint and keep our average velocity constant?

Velocity loss

Is there a point at which the team will start to loose it’s velocity? Well the answer might be that that’s where the sustainable pace comes to mind. We do not overcommit and we in fact stop sprinting at the maximum available velocity that we can achieve to sustain the pace.

Sustainable pace or sustainable undercommitment?

So how do we distinguish sustainable pace from sustainable undercommitment? Where is that point that we know we should not commit to more work as a team without being accused of just not being willing to do more while hiding behind a very nice term of “sustainable pace”?

My answer to that is great people, trust and transparency – all being the key parts of agile development. What is yours? How do you keep it at the level everybody accepts?

Why a bug tracker is not a good tool for agile project management?

July 16th, 2009 by Marcin Niebudek

Or yet another point of view on what to do with all those bugs in the backlog…

From time to time we observe a new discussion on whether we should put the bugs into our backlog or not. Opinions are diverse but I see one more aspect of that topic.

The idea behind the backlog is to have all items that we plan to ship for a product as some prioritized list. We leave the backlog in the hands of Product Owner and he decides what comes in and how important that thing is. the backlog forms the vision of what our product will be.

When asking ourselves about putting bugs/issues/tickets into backlog we usually look at it from the development team’s perspective. But lets take a look at what happens before product owner puts anything into the backlog.

We as a team perceive the backlog as the only source of the job to be done, but for Product Owner the backlog is the endpoint of the whole process of gathering ideas, requirements, issues from a lot of different sources. At the beginning of a new product development those sources might be:

  • real users needs,
  • client ideas and requirements,
  • team’s own ideas about the product

As the development goes further bugs arise and at that point they are usually addressed during iterations. When our product is finally released and starts it’s own life then the Product Owner may (should?) use all sets of new sources to fill his backlog items list:

  • feedback from the market (by e-mial, phone, through company’s help desk),
  • bugs reported through the bug tracker directly or indirectly by users,
  • sites that manage new ideas (like UserVoice or GetSatisfaction)

All those sources start producing new items that Product Owner is dealing with every day. They may be:

  • relevant to the product vision or not,
  • duplicates of other ideas that we already know from other sources,
  • a part of some bigger requirement that will later on form a user story

Bugs, especially if we adopt the culture of avoiding them instead of waiting for their arrival, are only a small part of the list that Product Owner should think of when forming his backlog. Also each of the sources that Product Owner deals with have their own life cycles.

Bugs in particular might be:

  • confirmed and fixed,
  • rejected,
  • postponed,
  • merged with items from other sources to form stories.

Most companies adopting agile methods usually already use some bug tracking systems and have some flows for dealing with issues that are put in those systems.

When they start working the agile way, the first thought is to start putting user stories into the same bug tracker or convert their bug tacking system into agile management system by mapping user stories to tickets. Other think that now, as they’re becoming “agile”, they should stop using their bug tracker and find some “agile tool”. But after all they start thinking about where to put all those bugs and the only place they find is their new backlog.

I think that either way of thinking comes from the wrong assumptions that bugs can be treated as stories or handled the same way as new features development. Instead of that we should put our Product Owner, a “man of vision”, between the list of bugs (bug tracker) and the backlog.

If the Scrum Master or any other similar role (we’re not talking only about SCRUM) is the wall protecting the team and the process during the iteration, then the Product owner should become a wall protecting the product vision and the backlog. Does it mean that no bug will slip into the backlog? No… some of them will as they need to be addressed individually. But many of them will never reach the backlog in the original form.

I like the idealog concept that Mark Mansour described at:
http://stateofflux.com/2009/04/10/is-the-product-backlog-an-idealog

I think bugs should become at first a part of such list (idealog) next to the items from other sources connecting Product Owner with the real world. And only after becoming a part of such buffer they should pass through the first gate and become backlog items. Going from this point to the rich universe of tools you will start with idealog and the backlog (even if the tools to manage them are your white boards or some Spreadsheets). When it becomes insufficient you will end up with both: bug tracker and some agile management tool, as well as with all other tools that might help you gather the feedback about your product.

They all play a different role when we take a look at the product management part of the process.

Why agile methods actually work?

May 21st, 2009 by Marcin Niebudek

One of the goals of agile methods is to go from a command and control model to self organizing teams, to get rid of some bureaucracy  in favor of direct communication. Many people think at that point that this will make people stop working efficiently or turn the process into uncontrolled chaos. On the other hand we, agile enthusiasts, always emphasize that agile methods require a great amount of discipline.

Lately I had a chance to give a lighting talk (followed by a very interesting discussion) about a “Definition of Done” and it’s role in the agile (and not only) process. It’s sometimes good to stop for a moment over one of the basic practices (like developing DoD for your team)  to remember what make agile process actually work?

Is it that we just decide to be disciplined this time, and that will help us keep the process running? No… It’s because agile replaces all kinds of procedures from the command and control model with… constraints. Sure we let the teams self organize, review the process, adapt, etc. But we as a team also put constraints on ourselves in all those little places that let the process flow in the right direction.

What actually makes us disciplined in agile process is:

  • acceptance tests on user stories – help us do “just enough”,
  • definitions of done – make us keep the required quality and prevent our iterations/sprints/releases from finishing with too big debt left for later stages of development,
  • time boxing and short iterations with shippable results – it’s not enough to work hard at the end of a project to be done, we need to be done every X weeks,
  • TDD – think what you’re implementing, implement “just enough” to pass the test,
  • pair programming – have you ever seen two developers playing on-line game or reading news on some portal while pair programming in front of a single computer (I think at least not too often)

Where else do you see that invisible hand which pushes us further every iteration? Are you starting to regret all those lazy periods of doing nothing between the milestones in waterfall process followed by death marches?