Why can't developers estimate the time?

Why can't developers estimate time?

Why can't developers estimate the time?

We can't estimate the time for any individual task in software development because the nature of the work is creating new knowledge.

In software development, we cannot estimate the time required for a single task, because the essence of work is to create new knowledge.

The goal of software development is to automate processes. once a process is automated, it can be run repeatedly, and in most cases, in a predictable time. source code is like a manufacturing blueprint, the computer is like a manufacturing plant, the inputs (data) are like raw materials, and the outputs (data) are like finished goods. to use another analogy, the reason Starbucks makes drinks so quickly and repeatably is because they invested a of time inDesignOf the process, which was (and is, ongoing) a complex and expensive task. individual Starbucks franchises don't have to re-discover this process, they just buy the blueprint. i'll leave it as an exercise to the reader to infer my opinion of the Costa coffee-making process.

The purpose of software development is to automate the process. Once the process is automated, it can be repeated in a predictable period of time. The source code is like a blueprint, a computer is like a factory, an input (data) is like a raw material, and an output (data) is like a finished product. Another analogy is that Starbucks can efficiently repeat beverage production because they have invested a lot of time in process design, which was once (still, continue) a complex and high-consumption task. Starbucks individual operators do not need to re-develop this process. They only need to purchase a blueprint. As for the Costa Coffee production process, let readers speculate on my views.

It's not actually always a problem that development time is unpredictable, because the flipside is that so is the value returned. A successful piece of software can make or save vastly more than its cost. tom DeMarco argues for focussing on the high value projects for exactly this reason. note that this does require a value-generation mindset, rather than the currently-prevalent cost-control mindset. this is a non-trivial problem.

Unpredictable development time may not necessarily cause problems, because, on the other hand, you have a return on value. A successful software can create or save much more value than the cost, so Tom DeMarco has called for projects that focus on high value return. Note that this requires an idea of creating value, rather than the current popular concept of cost control. This is a serious problem.

By far the best explanation I 've read of variability and how to exploit for value is Don Reinertsen's Principles of Product Development Flow, which is pretty much the adopted "PatchSpace Bible" for day-to-day process management. and when I say "by far the best", I mean by an order of magn?abve pretty much everything else I 've read, apart from the Theory of Constraints literature.

So far, the best analysis of variables and how to convert them into value is Don Reinertsen's "Principles of product development processes". patchSpace Bible is the most widely used Bible in daily process management ). What I said "Till now" means the best in my cognitive scope, not based on what principles.

Here is the data from my last development project. (Histogram generated in R with 5-hour buckets: the horizontal axis shows the duration in hours for the user stories-0-5 hours, 5-10 hours, etc; the vertical axis is the number of stories that took that duration ). we worked in 90 minute intervals and journaled the work on Wave, so we knew task durations to a pretty fine resolution. (We did this for both client communication and billing purposes .) the result: our development times were about as predictable as radioactive decay, but they wereVeryConsistently radioactive. Correlation with estimates was so poor I refused to estimate individual tasks, as it wocould have been wilfully misleading, but we had enough data to make sensible aggregates.

The following figure shows the data of my recent project. Each column in the histogram spans five hours. The horizontal coordinates indicate the workload of the user material (user stories), for example, 0-5 hours or 5-10 hours; ordinate the number of user clips. We record every 90 minutes of work, so we have a clear understanding of the work time of the task (we did this because of customer communication and Bill opening ). The result is that our development time is predictable like radioactive decay, but they always emit. The accuracy of the estimation is so poor that it is highly misleading that I refuse to estimate a single task, but we have enough data to make a wise estimate of the overall task.

Rule of thumb: take the estimates of a developer, double it and add a bit

Rule of thumb: Take the developer's evaluation time and double it and add a bit more

The double-and-add-a-bit rule is interesting. When managers do this, how often are tasks completed early? We generally payMuchMore attention to overruns than underruns. if a team is not completing half of its tasks early, it is padding the estimates, and that means trading development cycle time for project schedule. cycle time is usually much more valuable than predictability, as it means getting to market sooner. again, see Reinertsen's work, the numbers can come out an order of magn?apart.

The rule "double up a bit" is very interesting. If the manager does this, what is the probability of task completion ahead of schedule? We usually focus more on overestimating time rather than underestimating time. If the team cannot complete half of the task as early as possible, it is likely to exceed the estimate, which means the cost of the development cycle of the project plan will be taken. The development Cycle time is more valuable than the predictability, which means that the product is pushed to the market earlier. The Reinertsen conclusion may differ by an order of magnitude.

Also, this is the basis for Critical Chain project management, which halves the "safe" estimates to condense the timescale, and puts the remaining time (padding on individual tasks) at the end, as a "project buffer ". this means that Parkinson's Law doesn't cause individual tasks to expand unduly. i'm unconvinced that Critical Chain is an appropriate method for software though, as the actual content of development work can change significantly, as feedback and learning improves the plan.

In addition, this is the foundation of the Critical Chain project management. We cut the "Security" estimation by half to reduce the time span, and then add the remaining time (the time of a single task) as a "project buffer period ". This means that the Parkinson rule will not cause excessive extension of a single task. I do not agree that the key chain is an appropriate method of software. Because the actual content of the development work may vary greatly, feedback and learning can improve the work plan.

People in general just make shit up

Most people are fooling around (make shit up)

It's not just developers that are bad with estimates either. everyone at some point is just winging it because it's something they 've never done before and won't be able to successfully make a judgement until they have.

Not only do developers get inaccurate estimates, but to some extent everyone will get inaccurate, because things have not been done before, and it is difficult to make correct estimates, unless they have already done so.

As a community we need to get away from this. If we don't know, we don't know, and we needSay it. Clients who see regular progress on tasks they were made aware were risky (andChoseTo invest in) have much more trust in their team than clients whose teams make shit up. It's true! Srsly. Don't just take my word for it, though-read David Anderson's Kanban.

As a group, we need to avoid this situation. If we don't know, we don't know. Let's talk about it. Customers who are aware of risky tasks (and choose to invest) have more trust in the team than customers who are fooled by the team. This is true! However, do not always trust me-see David Anderson's Kanban.

Estimating is a very important skill and shoshould be taught more in junior dev roles

Estimation is an important skill. More junior developers should be educated.

I propose an alternative: what we need to do is teach to junior devs the meaningDone. If estimation problems are bad enough, finding out at some indeterminate point in the future that something went out unfinished (possibly in a rush to meet a commitment... I mean-estimate !) Blows not only that estimate out of the water, but the schedule of all the current work in process too. this is very common, and can cause a significant loss of a development team's capacity.

I propose an alternative: we need to educate junior developers to "complete. If the estimation is too bad, find out what is uncertain: when the task is not completed in the future, it will not only affect the task itself, but also affect all ongoing tasks. This is common and may cause significant losses to the development team's capabilities.