Background
My team current is currently in the "bug fixing and polishing" phase of shipping a major rewrite. We still have a large stack of bugs to fix, scheduled against a couple of milestones. We've been asked to come up with estimates, of how much engineering effort is required to fix the bugs for each milestone.
我的团队目前正在进行重大改写的“bug修复和抛光”阶段。我们仍然有大量的错误需要修复,安排在几个里程碑上。我们被要求提出估算,以确定修复每个里程碑错误所需的工程量。
For previous milestones, we've followed the following process:
对于之前的里程碑,我们遵循以下流程:
- Assign the bugs to the people that know the most about that area of the code, and will likely be the one to fix the bug.
- Have each person go through the bugs that are assigned to them, and estimate how long they think it will take to fix the bugs, at an hour-level granularity. If a bug looks like it will potentially take more than a day or two to fix, they break the bug into likely subtasks, and estimate those.
- Total the amount of work assigned to each person for each milestone, and try and balancing things out if people have drastically different amounts of work.
- Multiply each person's total for each milestone by a "padding factor", to account for overly optimistic estimates (we've been using 1.5).
- Take the largest total across the team members for a given release, and make that the time it will take for the team to close the existing bugs.
- Estimate the number of bugs we expect to be created during the time it takes us to reach a particular milestone, and estimate how long on average, we think it will take to close each of these bugs. Add this on to the time to close the existing bugs for each release. This is our final number of the amount of work needed, delivered as a date by which we'll definitely ship that milestone.
将错误分配给最了解代码区域的人员,并且很可能是修复错误的人。
让每个人都经历分配给他们的错误,并估计他们认为修复错误需要多长时间,以小时级别的粒度。如果一个bug看起来可能需要一两天才能修复,他们会将bug分解为可能的子任务,并估计这些。
总计为每个里程碑分配给每个人的工作量,如果人们的工作量大不相同,请尝试平衡事情。
将每个里程碑的每个人的总数乘以“填充因子”,以考虑过于乐观的估计(我们一直使用1.5)。
获取给定版本的团队成员中最大的总数,并使团队关闭现有错误所需的时间。
估计在我们达到特定里程碑期间我们期望创建的错误数量,并估计平均多长时间,我们认为需要关闭每个错误。将此添加到关闭每个版本的现有错误的时间。这是我们所需工作量的最终数量,作为我们肯定会发布该里程碑的日期。
This has been fairly accurate (we've come in pretty much spot on on our previous three milestones), but it's rather time consuming.
这是相当准确的(我们已经在我们之前的三个里程碑中得到了很多信息),但它相当耗时。
Current Problem
We've been asked to give estimates of the engineering time for upcoming milestones, but asked not to use the above process because it's too time consuming. Instead, as the tech lead of the team, I've been asked to provide estimates that are less certain, along with a certainty interval (ie, 1 month, plus or minus a week).
我们被要求估计即将到来的里程碑的工程时间,但要求不要使用上述过程,因为它太耗费时间。相反,作为团队的技术主管,我被要求提供不太确定的估计值,以及确定性间隔(即1个月,正负一周)。
My primary estimation experience is with some variation of the method I described above (from a background of freelancing for a number of years). I've found that when I "shoot from the hip" on large tasks, I tend to be way off. I suspect it will be even worse when estimating how long it takes to fix bugs in areas of the code I don't know very well.
我的主要估计经验是上面描述的方法的一些变化(从*职业的背景多年)。我发现当我在大型任务中“从臀部射击”时,我倾向于离开。我怀疑在估计代码中我不太了解的代码区域需要多长时间时会更糟糕。
What tips, tricks or techniques have you found successful for estimating quickly, without breaking things down into fine grained tasks and estimating them?
您有哪些提示,技巧或技巧可以成功快速估算,而不会将细分任务分解成细粒度的任务并进行估算?
Things that are not an option:
不可选择的事情:
- Not giving an estimate - I've tried this, it didn't fly:)
- Picking a number and confidence interval that is ridiculously wide - I've considered this, but I don't think it'll fly either.
- Evidence-base scheduling - We're using JIRA, which doesn't have any evidence-base scheduling tools written for it, and we can't migrate to FogBugz currently (BTW, if someone goes and writes an evidence-based scheduling plugin for JIRA, we would gladly pay for it).
没有估计 - 我试过这个,它没飞:)
选择一个非常宽的数字和置信区间 - 我考虑过这个,但我认为它也不会飞。
循证调度 - 我们正在使用JIRA,它没有为其编写任何证据基础调度工具,我们目前无法迁移到FogBugz(BTW,如果有人去写一个基于证据的调度插件, JIRA,我们很乐意为此付钱)。
10 个解决方案
#1
The best tip for estimating: round up a heck of a lot.
估计的最佳提示:收集很多东西。
It sounds like you're already an expert on the topic of estimation, and that you know the limitations of what's possible. It just isn't possible to estimate a task without assessing what needs doing to complete it!
听起来你已经是估算主题的专家,而且你知道可能的局限性。如果不评估完成任务需要做什么,就无法估算任务!
Amount of time assessing is directly proportional to accuracy of estimate. And these things converge at the point when time assessing is so accurate you've solved the task, at that moment, you know exactly how long it takes.
评估的时间量与估计的准确性成正比。当时间评估如此准确以至于您已经解决了任务时,这些事情就会趋同,在那一刻,您确切知道需要多长时间。
Hmm, sorry, this may not be the answer you wanted to hear... it's just my thoughts on it though.
嗯,对不起,这可能不是你想听到的答案......但这只是我的想法。
#2
- Be prepared to create a release at any time
- Have the stake-holders prioritise the work done
- Work on the highest priority items
准备好随时创建一个版本
让利益相关者优先考虑完成的工作
处理最高优先级的项目
Step 1. means you never miss a deadline.
第1步意味着你永远不会错过截止日期。
Step 2. is a way of turning the question back on those who are asking you to estimate without spending time estimating.
第2步是将问题转回给那些要求您估算而不花时间估算的人。
Edit...
The above doesn't really answer your question, sorry.
抱歉,以上内容并没有真正回答你的问题。
The stake holders will want to prioritize work based on how long and expensive each task will be, and you are likely to be asked which of the highest prioritized changes you expect to be able to complete by the next deadline.
利益相关者希望根据每项任务的时间和成本来确定工作的优先级,并且可能会询问您希望在下一个截止日期之前能够完成哪些最高优先级更改。
My technique that takes the least time is to use three times my impression of how long I think it would take me to do it.
我花费最少时间的技术是使用三次我的印象,我认为这需要多长时间才能完成。
You're looking for something taking longer than that, but not as long as your previous excellent estimates.
你正在寻找比这更长的东西,但不像你以前的优秀估计那么长。
You'll still need to look at each bug, even if only to take a guess at whether it is easy, average, or tricky, or 1,2,4,8,16 or 32 hours work.
您仍然需要查看每个错误,即使只是猜测它是否容易,平均或棘手,或1,2,4,8,16或32小时工作。
If you produce some code complexity metrics over your code base (eg cyclomatic complexity), and for each task, take a stab at which two or three portions of that code base will need to be changed the most, then estimate based on the assumption that the less complex portions of code will be quicker to change than the more complex portions. You could come up with some heuristics based on a few of your previous estimates, to use for each bug fix, giving an estimate of the time and variability required.
如果您在代码库中产生一些代码复杂度指标(例如,圈复杂度),并且对于每个任务,请尝试更改该代码库的两个或三个部分,然后根据假设进行估计。较复杂的代码部分将比更复杂的部分更快地更改。您可以根据之前的一些估算得出一些启发式方法,用于每个错误修复,估计所需的时间和可变性。
#3
How about:
estimate=(bugs/devs)xdays (xK)
As simple as this is it's actually quite accurate. And can be estimated in 1minute. It's confidence level is less than your detailed method, but I'd recommend you check your data on the last three milestones and check the difference between this quick estimate and your detailed estimate that will give you a "K" value representing your team's constant.
这很简单,实际上非常准确。并且可以在1分钟内估算。它的置信水平低于您的详细方法,但我建议您检查最近三个里程碑的数据,并检查这个快速估算与您的详细估算之间的差异,这将给您一个代表您团队常数的“K”值。
Be surprised.
#4
Use Planning Poker, see the answers to How to estimate the length of a programming task
使用Planning Poker,请参阅如何估计编程任务的长度的答案
#5
In simplest terms:
最简单的说法:
Your Most Absolutely Liberal Estimation * 3 = Your Estimate
你最绝对*的估计* 3 =你的估计
The above may look like a joke, but it's not. I've used it many times. Time estimation on software projects of any kind is a game, just like making a deal with a car dealer. That formula will get you something to provide your management in a pinch and give you some room to play with as well.
以上可能看起来像个笑话,但事实并非如此。我已经多次使用它了。任何类型的软件项目的时间估计都是游戏,就像与汽车经销商达成交易一样。该公式将为您提供一些帮助您管理的东西,并为您提供一些空间。
However, if you're somehow able to get down to the more granular details (which is really the only way you'll be able to be more accurate), Google on Function Point Analysis, sometimes called "Fast Function Point Analysis" or "Fast Function Point Estimation".
但是,如果您能够以某种方式获得更细粒度的细节(这是您能够更准确的唯一方式),Google就功能点分析,有时称为“快速功能点分析”或“快速功能点估计“。
Many folks out there have a myriad of spreadsheets, PDF's and the like that can help you estimate as quickly as possible. Check out the spreadsheets first as they'll have formulas built in for you.
许多人都有无数的电子表格,PDF等可以帮助您尽快估算。首先查看电子表格,因为它们将为您构建公式。
Hope this helps!
希望这可以帮助!
#6
You've been asking how to produce an estimate and an uncertainty interval. A better way to think of this is to do a worst-case estimate and a best-case estimate. Combine the two to have an estimate range. Well understood issues will naturally be more specific then the estimates for less-understood issues. For example, an estimate that looks like 1.5-2 days is probably for a well understood issue, an estimate that looks like 2-14 days would be typical for an issue not at all understood. Limit the amount of investigation and time spent producing an estimate by allowing for a wider gap between the estimates. This works because its relatively easy to imagine realistic best case and worst case scenarios. When the uncertainty range is more than you're comfortable dealing with in the schedule, then take some time to understood the less understood issues. It may help to break them up.
你一直在问如何产生估计和不确定性区间。考虑这一点的更好方法是进行最坏情况估计和最佳情况估计。将两者结合起来估算范围。很好理解的问题自然会比对不太了解的问题的估计更具体。例如,看起来像1.5-2天的估计可能是一个很好理解的问题,对于一个根本没有理解的问题,估计看起来像2-14天。通过允许估算之间存在更大的差距来限制调查数量和产生估算所花费的时间。这是有效的,因为它相对容易想象现实的最佳案例和最坏的情况。当不确定性范围超出您在日程表中处理的时间时,您需要花一些时间来理解不太了解的问题。它可能有助于打破它们。
I usually go for half-day granularity rather than hour granularity in my estimates if the work is expected to take more than a week overall.
如果预计整个工作需要超过一周的时间,我通常会在估算中使用半天粒度而不是小时粒度。
#7
public static class Time
{
/// <summary>
/// Estimates the hours.
/// </summary>
/// <param name="NumberPulledFromAss">The number pulled from ass.</param>
/// <param name="Priority">The priority.</param>
/// <param name="Complexity">The complexity.</param>
/// <returns>
/// a number in hours to estimate the time to complete a task.
/// Hey, you will be wrong anyway why waste more time than you need?
/// </returns>
public static int EstimateHours(int NumberPulledFromAss, int Priority, int Complexity)
{
var rand = new Random(NumberPulledFromAss);
var baseGuess = rand.Next(1, NumberPulledFromAss);
return (baseGuess + (Priority * Complexity)) * 2;
}
}
#8
Your estimates are as accurate as the time you put into them. This time can be physical time breaking down the problem or drawing upon past experiences in areas you're familiar. If this isn't an option the try breaking the bugs/polish down into groups.
您的估算与您投入的时间一样准确。这段时间可以是物理时间来解决问题,也可以利用您熟悉的领域的过去经验。如果这不是一个选项,尝试打破错误/打磨成组。
- Trivial fix of a few hours.
- Up to one day effort.
- Very complex - one week effort.
几个小时的琐碎修复。
最多一天的努力。
非常复杂 - 一周的努力。
Once you have these categorised then you can work out a rough guestimate.
一旦你对这些进行了分类,你就可以得出一个粗略的猜测。
#9
Many hints may be useful in this article on an agile blog: Agile Estimating.
在敏捷博客上的这篇文章中,许多提示可能都很有用:敏捷估算。
#10
Calculating the variability in your estimate will take longer than calculating your estimate.
计算估算值的可变性需要比计算估算值更长的时间。
#1
The best tip for estimating: round up a heck of a lot.
估计的最佳提示:收集很多东西。
It sounds like you're already an expert on the topic of estimation, and that you know the limitations of what's possible. It just isn't possible to estimate a task without assessing what needs doing to complete it!
听起来你已经是估算主题的专家,而且你知道可能的局限性。如果不评估完成任务需要做什么,就无法估算任务!
Amount of time assessing is directly proportional to accuracy of estimate. And these things converge at the point when time assessing is so accurate you've solved the task, at that moment, you know exactly how long it takes.
评估的时间量与估计的准确性成正比。当时间评估如此准确以至于您已经解决了任务时,这些事情就会趋同,在那一刻,您确切知道需要多长时间。
Hmm, sorry, this may not be the answer you wanted to hear... it's just my thoughts on it though.
嗯,对不起,这可能不是你想听到的答案......但这只是我的想法。
#2
- Be prepared to create a release at any time
- Have the stake-holders prioritise the work done
- Work on the highest priority items
准备好随时创建一个版本
让利益相关者优先考虑完成的工作
处理最高优先级的项目
Step 1. means you never miss a deadline.
第1步意味着你永远不会错过截止日期。
Step 2. is a way of turning the question back on those who are asking you to estimate without spending time estimating.
第2步是将问题转回给那些要求您估算而不花时间估算的人。
Edit...
The above doesn't really answer your question, sorry.
抱歉,以上内容并没有真正回答你的问题。
The stake holders will want to prioritize work based on how long and expensive each task will be, and you are likely to be asked which of the highest prioritized changes you expect to be able to complete by the next deadline.
利益相关者希望根据每项任务的时间和成本来确定工作的优先级,并且可能会询问您希望在下一个截止日期之前能够完成哪些最高优先级更改。
My technique that takes the least time is to use three times my impression of how long I think it would take me to do it.
我花费最少时间的技术是使用三次我的印象,我认为这需要多长时间才能完成。
You're looking for something taking longer than that, but not as long as your previous excellent estimates.
你正在寻找比这更长的东西,但不像你以前的优秀估计那么长。
You'll still need to look at each bug, even if only to take a guess at whether it is easy, average, or tricky, or 1,2,4,8,16 or 32 hours work.
您仍然需要查看每个错误,即使只是猜测它是否容易,平均或棘手,或1,2,4,8,16或32小时工作。
If you produce some code complexity metrics over your code base (eg cyclomatic complexity), and for each task, take a stab at which two or three portions of that code base will need to be changed the most, then estimate based on the assumption that the less complex portions of code will be quicker to change than the more complex portions. You could come up with some heuristics based on a few of your previous estimates, to use for each bug fix, giving an estimate of the time and variability required.
如果您在代码库中产生一些代码复杂度指标(例如,圈复杂度),并且对于每个任务,请尝试更改该代码库的两个或三个部分,然后根据假设进行估计。较复杂的代码部分将比更复杂的部分更快地更改。您可以根据之前的一些估算得出一些启发式方法,用于每个错误修复,估计所需的时间和可变性。
#3
How about:
estimate=(bugs/devs)xdays (xK)
As simple as this is it's actually quite accurate. And can be estimated in 1minute. It's confidence level is less than your detailed method, but I'd recommend you check your data on the last three milestones and check the difference between this quick estimate and your detailed estimate that will give you a "K" value representing your team's constant.
这很简单,实际上非常准确。并且可以在1分钟内估算。它的置信水平低于您的详细方法,但我建议您检查最近三个里程碑的数据,并检查这个快速估算与您的详细估算之间的差异,这将给您一个代表您团队常数的“K”值。
Be surprised.
#4
Use Planning Poker, see the answers to How to estimate the length of a programming task
使用Planning Poker,请参阅如何估计编程任务的长度的答案
#5
In simplest terms:
最简单的说法:
Your Most Absolutely Liberal Estimation * 3 = Your Estimate
你最绝对*的估计* 3 =你的估计
The above may look like a joke, but it's not. I've used it many times. Time estimation on software projects of any kind is a game, just like making a deal with a car dealer. That formula will get you something to provide your management in a pinch and give you some room to play with as well.
以上可能看起来像个笑话,但事实并非如此。我已经多次使用它了。任何类型的软件项目的时间估计都是游戏,就像与汽车经销商达成交易一样。该公式将为您提供一些帮助您管理的东西,并为您提供一些空间。
However, if you're somehow able to get down to the more granular details (which is really the only way you'll be able to be more accurate), Google on Function Point Analysis, sometimes called "Fast Function Point Analysis" or "Fast Function Point Estimation".
但是,如果您能够以某种方式获得更细粒度的细节(这是您能够更准确的唯一方式),Google就功能点分析,有时称为“快速功能点分析”或“快速功能点估计“。
Many folks out there have a myriad of spreadsheets, PDF's and the like that can help you estimate as quickly as possible. Check out the spreadsheets first as they'll have formulas built in for you.
许多人都有无数的电子表格,PDF等可以帮助您尽快估算。首先查看电子表格,因为它们将为您构建公式。
Hope this helps!
希望这可以帮助!
#6
You've been asking how to produce an estimate and an uncertainty interval. A better way to think of this is to do a worst-case estimate and a best-case estimate. Combine the two to have an estimate range. Well understood issues will naturally be more specific then the estimates for less-understood issues. For example, an estimate that looks like 1.5-2 days is probably for a well understood issue, an estimate that looks like 2-14 days would be typical for an issue not at all understood. Limit the amount of investigation and time spent producing an estimate by allowing for a wider gap between the estimates. This works because its relatively easy to imagine realistic best case and worst case scenarios. When the uncertainty range is more than you're comfortable dealing with in the schedule, then take some time to understood the less understood issues. It may help to break them up.
你一直在问如何产生估计和不确定性区间。考虑这一点的更好方法是进行最坏情况估计和最佳情况估计。将两者结合起来估算范围。很好理解的问题自然会比对不太了解的问题的估计更具体。例如,看起来像1.5-2天的估计可能是一个很好理解的问题,对于一个根本没有理解的问题,估计看起来像2-14天。通过允许估算之间存在更大的差距来限制调查数量和产生估算所花费的时间。这是有效的,因为它相对容易想象现实的最佳案例和最坏的情况。当不确定性范围超出您在日程表中处理的时间时,您需要花一些时间来理解不太了解的问题。它可能有助于打破它们。
I usually go for half-day granularity rather than hour granularity in my estimates if the work is expected to take more than a week overall.
如果预计整个工作需要超过一周的时间,我通常会在估算中使用半天粒度而不是小时粒度。
#7
public static class Time
{
/// <summary>
/// Estimates the hours.
/// </summary>
/// <param name="NumberPulledFromAss">The number pulled from ass.</param>
/// <param name="Priority">The priority.</param>
/// <param name="Complexity">The complexity.</param>
/// <returns>
/// a number in hours to estimate the time to complete a task.
/// Hey, you will be wrong anyway why waste more time than you need?
/// </returns>
public static int EstimateHours(int NumberPulledFromAss, int Priority, int Complexity)
{
var rand = new Random(NumberPulledFromAss);
var baseGuess = rand.Next(1, NumberPulledFromAss);
return (baseGuess + (Priority * Complexity)) * 2;
}
}
#8
Your estimates are as accurate as the time you put into them. This time can be physical time breaking down the problem or drawing upon past experiences in areas you're familiar. If this isn't an option the try breaking the bugs/polish down into groups.
您的估算与您投入的时间一样准确。这段时间可以是物理时间来解决问题,也可以利用您熟悉的领域的过去经验。如果这不是一个选项,尝试打破错误/打磨成组。
- Trivial fix of a few hours.
- Up to one day effort.
- Very complex - one week effort.
几个小时的琐碎修复。
最多一天的努力。
非常复杂 - 一周的努力。
Once you have these categorised then you can work out a rough guestimate.
一旦你对这些进行了分类,你就可以得出一个粗略的猜测。
#9
Many hints may be useful in this article on an agile blog: Agile Estimating.
在敏捷博客上的这篇文章中,许多提示可能都很有用:敏捷估算。
#10
Calculating the variability in your estimate will take longer than calculating your estimate.
计算估算值的可变性需要比计算估算值更长的时间。