Remember that Points are just ROMs(rough order of magnitude) established through the use of "Planning Poker" as a common practice. The first few Sprints are when you start to identify what the points mean to the team and the longer you go the more accurate the team gets.
Plus look to use points that are a bit more spaced out. A practice I've seen and used is to use the fibonacci sequence, it makes sure that you don't have too many 1 point differences.
Also don't forget testers, when pointing a story anyone doing testing needs to weigh in as sometimes a simple development task can cause a large testing effort and if they are true Sprints the idea is to have everything completed as it could be shipped (built, tested and documented). So the estimate of a story is determined by the team not by an individual.
A story point is related to the estimate of course, and when you try to figure out how much you can do for a sprint, a story point is one unit of "work" needed to implement part of or a whole feature. One story point could be a day, or an hour, or something in between. I've confused the "estimate" and "story point" below, don't know what I was thinking.
What I originally wrote was "estimates" and "story points". What I meant to write (and edited below) was "story points" and "velocity".
Story points and velocity goes hand in hand, and they work together to try to give you a sense of "how much can we complete in a given period of time".
Let's take an example.
Let's say you want to estimate features in hours, so a feature that has an estimate of 4 will take 4 hours to complete, by one person, so you assign such an estimate to all the features. You thus consider that feature, or its "story", worth 4 points when it comes to competing for resources.
Now let's also say you have 4 people on your project, each working a normal 40-hour week, but, due to other things happening around them, like support, talking to marketing, meetings, etc., each person will only be able to work 75% on the actual features, the other 25% will be used on those other tasks.
So each person has 30 hours available each week, which gives you 30*4 = 120 hours total for that week when you count all the 4 people.
Now let's also say you're trying to create a sprint of 3 weeks, which means you have 3*120 hours worth of work you can complete. This is your velocity, how fast you're moving, how many "story points" you can complete.
The unit of your velocity has to he compatible with the unit for your story points. You can't measure stories in "how many cups will the developer(s) consume while implementing this" with "how many hours do we have available".
You then try to find a set of features that together takes close to, but not over, 120 points, ranked by their priority. This would simply be to sum accumulative from the top and downwards until you reach a task that tips the sum over, or equal to, those 120 points. If it tipped it over, don't include the task.
You could just as easily estimate in days, or cups of coffee consumed by the developer, just as the number is representative for the type of job you're doing, and it can be related to the actual work you will perform (ie. how much time you have available).
You should also evaluate your workload after each sprint to figure out if that 75% number is accurate. For instance, if you only managed half of what you set out to do, figure out if your feature estimates was wrong, or if your workload estimates was wrong. Then take what you've learned into account when estimating and planning for the following sprints.
Also note that features should be split up if they become too big. The main reason for this is that bigger estimates have a lot more uncertainty built into them, and you can mitigate that by splitting it up into sub-features and estimating those. The big overall feature then becomes the sum of all the sub-features. It might also give you the ability to split the feature over several people, by assigning different sub-features to different people.
A good rule of thumb is that features that have an estimate over 1 days should probably be split.*
The value 10 is merely a value relative to the other estimates, e.g. it is half as hard as a 20 or slightly more difficult than a 9. There isn't a specific translation of 1 point = x hours of effort is something to point out.
Where I work, we have what we call "epic points" which is how hard is some high level story,e.g. integrate Search into a new website, that will consist of multiple stories to complete and then we estimate hours on each story that is created from breaking down each epic,e.g. just put Search in for support documents on the site. The "epic points" are distributed in a variation of Fibonacci numbers(1,2,3,5,8,13,21,28,35) so that broader, more vague epics merely get a large value, e.g. anything greater than 8, is an indicator that it can be broken down into more easily estimatable stories. It is also worth noting here that where I work we only work 5 days a week and within each sprint a day is lost to meetings like the demo, iteration planning meeting, retrospective and review so there is only 9 days to a sprint. Adding in pair programming for some things, time for fixing bugs and other non-project work like support tickets and it becomes rather hard to say how many hours will be spent by the handful of developers in the sprint.
The first few sprints are where the values start to become more concrete as based on the experience gained, the estimates can become clearer in terms of how to guess the value.
With a new team or project we always start out by assuming a story point is a single "ideal day", and we figure each developer getting around 3.5 ideal days per week, which is how we calculate our likely initial velocity.
Once you've gone through the "planning poker" stage and balanced/compared all your stories, the actual real-world duration of a story point is really unknown - all you really have is a pretty good idea of relative duration, and use your best judgement to come up with a likely velocity.
At least, that's how I do it!
If you are also aiming your story points at being roughly equal to an ideal day, then I'd suggest breaking your stories down into smaller stories, otherwise you're not going to have a good time in planning and tracking iterations.
One point I would like to add is that it's not really important what you choose as a base for your points value (hours, ideal days, whatever else). The important is to keep it consistent.
If you do keep it consistent it will allow you to discover "true velocity" of your team. For example lets say you had few iterations:
Now assuming your points estimations are consistent you can be reasonably sure that the team will finish items 1,2 and probably 3 but definitely not 4.
You can apply the same to release backlog to improve your prediction of release date. This is what allows Scrum teams to improve their estimations as they go along.
JB King has the best answer, but no votes which means incorrect information is being propagated and contributing to the generally poor interpretation of scrum. Please see the real answers from one of the people who designed Scrum here:
发布评论
评论（6）
请记住，积分只是通过使用“规划扑克”建立的 ROM（大致数量级）作为一种常见做法。 前几个 Sprint 是您开始确定积分对团队意味着什么的时候，您走的时间越长，团队获得的准确度就越高。
另外，请注意使用间距更大的点。 我见过并使用过的一种做法是使用 斐波那契 序列，它确保您不会没有太多1分的差距。
另外不要忘记测试人员，在指出一个故事时，任何进行测试的人都需要权衡，因为有时一个简单的开发任务可能会导致大量的测试工作，如果它们是真正的冲刺，那么想法就是完成所有事情，因为它可以交付（构建） 、测试并记录）。 所以一个故事的评价是由团队决定的，而不是由个人决定的。
Remember that Points are just ROMs(rough order of magnitude) established through the use of "Planning Poker" as a common practice. The first few Sprints are when you start to identify what the points mean to the team and the longer you go the more accurate the team gets.
Plus look to use points that are a bit more spaced out. A practice I've seen and used is to use the fibonacci sequence, it makes sure that you don't have too many 1 point differences.
Also don't forget testers, when pointing a story anyone doing testing needs to weigh in as sometimes a simple development task can cause a large testing effort and if they are true Sprints the idea is to have everything completed as it could be shipped (built, tested and documented). So the estimate of a story is determined by the team not by an individual.
啊！ 凭记忆写作对我来说是正确的。
当然，故事点与估算相关，当您试图弄清楚在一个冲刺中可以做多少事情时，故事点是实现部分或整个功能所需的一个“工作”单元。 一个故事点可以是一天、一小时或介于两者之间的时间。 我混淆了下面的“估计”和“故事点”，不知道我在想什么。
我最初写的是“估计”和“故事点”。 我想写（并在下面编辑）的是“故事点”和“速度”。
故事点和速度齐头并进，它们共同努力让您感觉到“我们在给定的时间内可以完成多少”。
让我们举个例子。
假设您想要以小时为单位估计要素，因此估计值为 4 的要素将需要一个人 4 小时才能完成，因此您将这样的估计值分配给所有要素。 因此，在资源竞争方面，您认为该功能或其“故事”值得 4 分。
现在，我们还假设您的项目有 4 个人，每个人每周正常工作 40 小时，但是，由于他们周围发生其他事情，例如支持、与营销人员交谈、会议等，每个人只能75% 用于实际功能，另外 25% 将用于其他任务。
因此，每个人每周有 30 个小时的空闲时间，如果算上 4 个人，那周总共有 30*4 = 120 个小时。
现在，假设您正在尝试创建 3 周的冲刺，这意味着您可以完成 3*120 小时的工作。 这是你的速度，你移动的速度有多快，你可以完成多少个“故事点”。
速度的单位必须与故事点的单位兼容。 您不能用“开发人员在实施此操作时消耗多少杯”来衡量故事，而用“我们有多少小时可用”。
然后，您尝试找到一组总分接近但不超过 120 分的功能，并按其优先级排名。 这只是从上到下累加总和，直到您完成一项使总和超过或等于 120 分的任务。 如果它翻倒了，就不要包含该任务。
您可以轻松地估计开发人员消耗的天数或咖啡杯数，就像该数字代表您正在执行的工作类型一样，并且它可以与您将执行的实际工作相关（即如何执行）你有很多空闲时间）。
您还应该在每次冲刺后评估您的工作量，以确定 75% 的数字是否准确。 例如，如果您只完成了计划要做的一半，请弄清楚您的功能估计是否错误，或者您的工作负载估计是否错误。 然后在估计和规划以下冲刺时考虑您所学到的知识。
另请注意，如果功能变得太大，则应将其拆分。 造成这种情况的主要原因是，更大的估计会带来更多的不确定性，您可以通过将其分解为子特征并对其进行估计来缓解这种情况。 然后，大的整体特征就变成了所有子特征的总和。 它还可以让您通过将不同的子功能分配给不同的人来将功能拆分给多个人。
一个好的经验法则是，估计时间超过 1 天的特征可能应该被分割。*
Argh! Serves me right for writing from memory.
A story point is related to the estimate of course, and when you try to figure out how much you can do for a sprint, a story point is one unit of "work" needed to implement part of or a whole feature. One story point could be a day, or an hour, or something in between. I've confused the "estimate" and "story point" below, don't know what I was thinking.
What I originally wrote was "estimates" and "story points". What I meant to write (and edited below) was "story points" and "velocity".
Story points and velocity goes hand in hand, and they work together to try to give you a sense of "how much can we complete in a given period of time".
Let's take an example.
Let's say you want to estimate features in hours, so a feature that has an estimate of 4 will take 4 hours to complete, by one person, so you assign such an estimate to all the features. You thus consider that feature, or its "story", worth 4 points when it comes to competing for resources.
Now let's also say you have 4 people on your project, each working a normal 40-hour week, but, due to other things happening around them, like support, talking to marketing, meetings, etc., each person will only be able to work 75% on the actual features, the other 25% will be used on those other tasks.
So each person has 30 hours available each week, which gives you 30*4 = 120 hours total for that week when you count all the 4 people.
Now let's also say you're trying to create a sprint of 3 weeks, which means you have 3*120 hours worth of work you can complete. This is your velocity, how fast you're moving, how many "story points" you can complete.
The unit of your velocity has to he compatible with the unit for your story points. You can't measure stories in "how many cups will the developer(s) consume while implementing this" with "how many hours do we have available".
You then try to find a set of features that together takes close to, but not over, 120 points, ranked by their priority. This would simply be to sum accumulative from the top and downwards until you reach a task that tips the sum over, or equal to, those 120 points. If it tipped it over, don't include the task.
You could just as easily estimate in days, or cups of coffee consumed by the developer, just as the number is representative for the type of job you're doing, and it can be related to the actual work you will perform (ie. how much time you have available).
You should also evaluate your workload after each sprint to figure out if that 75% number is accurate. For instance, if you only managed half of what you set out to do, figure out if your feature estimates was wrong, or if your workload estimates was wrong. Then take what you've learned into account when estimating and planning for the following sprints.
Also note that features should be split up if they become too big. The main reason for this is that bigger estimates have a lot more uncertainty built into them, and you can mitigate that by splitting it up into sub-features and estimating those. The big overall feature then becomes the sum of all the sub-features. It might also give you the ability to split the feature over several people, by assigning different sub-features to different people.
A good rule of thumb is that features that have an estimate over 1 days should probably be split.*
值 10 只是一个相对于其他估计值的值，例如，它的难度是 20 的一半，或者比 9 稍难一些。需要指出的是，没有具体的翻译 1 点 = x 小时的努力。
在我工作的地方，我们有所谓的“史诗点”，即一些高级故事的难度，例如将搜索集成到一个新网站中，该网站将包含多个要完成的故事，然后我们估计创建的每个故事的时间从分解每个史诗，例如只需在网站上搜索支持文档即可。 “史诗点”以斐波那契数的变体形式分布（1,2,3,5,8,13,21,28,35），因此更广泛、更模糊的史诗只会获得较大的值，例如任何大于 8 的值，是一个指标，表明它可以分解为更容易估计的故事。 还值得注意的是，在我工作的地方，我们每周只工作 5 天，并且在每个 sprint 中，每天都会被用于演示、迭代计划会议、回顾和审查等会议，因此 sprint 只有 9 天的时间。 再加上一些事情的结对编程、修复错误的时间和其他非项目工作（如支持票），很难说少数开发人员在冲刺中会花费多少时间。
前几次冲刺是值开始变得更加具体的地方，因为根据所获得的经验，估计在如何猜测值方面会变得更加清晰。
The value 10 is merely a value relative to the other estimates, e.g. it is half as hard as a 20 or slightly more difficult than a 9. There isn't a specific translation of 1 point = x hours of effort is something to point out.
Where I work, we have what we call "epic points" which is how hard is some high level story,e.g. integrate Search into a new website, that will consist of multiple stories to complete and then we estimate hours on each story that is created from breaking down each epic,e.g. just put Search in for support documents on the site. The "epic points" are distributed in a variation of Fibonacci numbers(1,2,3,5,8,13,21,28,35) so that broader, more vague epics merely get a large value, e.g. anything greater than 8, is an indicator that it can be broken down into more easily estimatable stories. It is also worth noting here that where I work we only work 5 days a week and within each sprint a day is lost to meetings like the demo, iteration planning meeting, retrospective and review so there is only 9 days to a sprint. Adding in pair programming for some things, time for fixing bugs and other non-project work like support tickets and it becomes rather hard to say how many hours will be spent by the handful of developers in the sprint.
The first few sprints are where the values start to become more concrete as based on the experience gained, the estimates can become clearer in terms of how to guess the value.
对于一个新的团队或项目，我们总是首先假设一个故事点是一个“理想的一天”，并且我们计算每个开发人员每周大约有 3.5 个理想的天，这就是我们计算可能的初始速度的方式。
一旦您完成了“计划扑克”阶段并平衡/比较了所有故事，故事点在现实世界中的实际持续时间就真的是未知的 - 您真正拥有的只是相对的一个很好的想法 持续时间，并利用您的最佳判断来得出可能的速度。
至少，我就是这么做的！
如果您还希望故事点大致等于理想的一天，那么我建议您将故事分解为更小的故事，否则您将无法很好地规划和跟踪迭代。
With a new team or project we always start out by assuming a story point is a single "ideal day", and we figure each developer getting around 3.5 ideal days per week, which is how we calculate our likely initial velocity.
Once you've gone through the "planning poker" stage and balanced/compared all your stories, the actual real-world duration of a story point is really unknown - all you really have is a pretty good idea of relative duration, and use your best judgement to come up with a likely velocity.
At least, that's how I do it!
If you are also aiming your story points at being roughly equal to an ideal day, then I'd suggest breaking your stories down into smaller stories, otherwise you're not going to have a good time in planning and tracking iterations.
到处都有好的答案。
我想补充的一点是，您选择什么作为积分值的基础（小时、理想天数或其他）并不重要。 重要的是保持一致。
如果你确实保持一致，它将让你发现团队的“真实速度”。
例如，假设您进行了几次迭代：
现在您正在开始迭代 4，并且待办事项中有以下内容（按优先级排序）：
现在假设您的点估计是一致的，您可以合理地确定团队将完成项目 1， 2，可能是 3，但绝对不是 4。
您可以将相同的方法应用于发布待办事项，以改进对发布日期的预测。
这使得 Scrum 团队能够不断改进他们的估算。
Good answers all around.
One point I would like to add is that it's not really important what you choose as a base for your points value (hours, ideal days, whatever else). The important is to keep it consistent.
If you do keep it consistent it will allow you to discover "true velocity" of your team.
For example lets say you had few iterations:
And now you are starting iteration 4 and you have the following in the backlog (sorted on priority):
Now assuming your points estimations are consistent you can be reasonably sure that the team will finish items 1,2 and probably 3 but definitely not 4.
You can apply the same to release backlog to improve your prediction of release date.
This is what allows Scrum teams to improve their estimations as they go along.
JB King 给出了最佳答案，但没有投票，这意味着错误的信息正在传播，并导致对 scrum 的普遍较差的解释。 请在此处查看 Scrum 设计者之一的真实答案：
http://blog.mountaingoatsoftware.com/seeing-how-well-a-teams-story-points-align-from-one-to-eight
请记住，这是关于努力，而不是复杂性。
现在阅读并观看视频：
http://www.agilebok.org/index.html php?title=Relative_Sizing_and_Story_Points
JB King has the best answer, but no votes which means incorrect information is being propagated and contributing to the generally poor interpretation of scrum. Please see the real answers from one of the people who designed Scrum here:
http://blog.mountaingoatsoftware.com/seeing-how-well-a-teams-story-points-align-from-one-to-eight
Remember, it's about effort, not complexity.
Now read about and watch a video here:
http://www.agilebok.org/index.php?title=Relative_Sizing_and_Story_Points