kanban task estimation
Kanban task estimation is a very important and relatively advanced topic, but it’s not impossible to get started.
Think about it: how do you estimate tasks in kanban ? You probably have some sort of process like the one below. But does this process work for you? And can you add more accuracy and control to your estimation? If yes, read on!
The problem with traditional task estimation methodologies
Let’s start by looking at the most common way we deal with time estimates: A traditional waterfall approach: We discuss features and divide them into small chunks. Then we estimate each chunk of work using hours or days. At the end of the sprint we sum up all estimations and get an idea of how much work we’ve done in the sprint.
This might all seem very logical when you first hear about it, but when you get into a real project and start to use this approach, some problems arise:
(1) The estimates are contrived, they don’t reflect the actual amount of work that needs to be done in order for us to deliver a feature. We end up estimating more or less instead of thinking about what someone will actually need from us at the end. This results in either underestimating our work (and over-promising), wasting time on useless tasks which could have been simply avoided if we had known earlier what is required from us, or adding redundant features and finishing incomplete ones just because we can’t finish a smaller feature in a single iteration.
(2) Iterations are too short, they don’t leave us enough time to really do something substantial and deliver value. This results in having useless features which were abandoned by the team as soon as an iteration was finished because there is no business value for the client at all. It also results in over-engineering things especially when there is no clear understanding of what will be delivered, but only an idea that it should have certain characteristics – just enough for us to design and implement it – or even worse: not even giving it any thought.
(3) The prototype-driven approach does not work well with iterative development either. Prototypes are great for short iterations, but they are difficult to maintain when the time between two consecutive builds becomes longer. Because there is no direct connection from the prototype to the completed feature, it feels like we're developing something completely different and we lose track easily.
Some of us have experienced how long it can take until a simple functional change in a "prototype" makes it into the product simply because things which seem obvious at first may not be that trivial in reality or even downright impossible. Prototypes should become part of the final product after all if we didn't want them only as an analogy for what we were planning to build. So iterative development with prototypes doesn't work either, although this approach should fit perfectly since prototyping supports iterative development.
A different approach is to use different names for the prototype and the final product. The final version should be called as such (prototype) and not as "the" product, because it isn't "the" one. It's only a test version of the actual product which we will eventually release as "the" product. This may sound like an unnecessary complication but I think that this distinction between two stages with completely different concepts and structures is really needed in order to work more efficiently on products or parts of products .
If we call something a prototype we shouldn't aim for stability, completeness or usability although those properties would be nice to have. But most importantly, even if we succeeded in implementing them, they can never be expected from a prototype and therefore we shouldn't advertise them.
A bit less abstract if you may: imagine that we just started working on our new product. I am of course talking about my current work in progress, the OX Expander . Our future users will be able to store their projects on a SD-card with the oxloader application. But when they want to quickly test some code which they can only write down when holding their beloved oscilloscope on the other hand it would be a nice thing if they could do this in a very short time even with a little program which only consists of several lines.
If we try to implement such a facility in an exponential way from scratch for each new product then doing something which is called "working" would be very hard (or expensive :D). But if we use appropriate free libraries which are tested and available on many different platforms for nearly years then the task becomes much easier.
So I decided to give libusb a try with libusb . And it works like a charm! The whole test application was only about 50 lines of code (50 LOC), i.e. only one tenth of the original OX Expander program! It uses libusb-1.0 to access our oscilloscope via USB and redirects all user interactions into simple stout messages, so that you can just use your favorite serial terminal emulator to communicate with it. Furthermore it allows us to easily write new applications for the storage facilities, e.g. controlling the hardware.