Are there any formal/informal measures of comparing completed functionality vs initial requirements of a project.
The word(s) you are looking for is "Done Criteria". It has a more deeper meaning than the words itself, in the Agile world. It is often the first thing to be fixed in an Agile Organization, if it is found to be missing. Below (at the end) is a link to an article which explains it in more detail.
Most Agile Teams use User Stories as their "initial requirements". The user story would be your initial requirements which would be just enough to get the Team started. The measure used, should be what most Teams call, "the Done Criteria". Every User story should have a done criteria. For eg. In order to call a backlog done, these list of things need to be Done. While setting this we do not worry about How it would be done, only What needs to be done.
During the Sprint Review, the Team would do a show and tell of the working software, and if it meets the done criteria, the PO should approve it to be officially marked done.
Off course, sometimes User stories have changing Done criteria, especially for new Teams or Projects, but that is perfectly normal, because a sign of a good user story is that it is negotiable. The Done Criteria can be slightly modified after getting approval of Team. Teams rarely disapprove these, unless the change causes a dramatic increase in complexity of the work to be done.
So to summarize:
Initial requirements i.e. User Stories need to have a "what" needs to be Done Criteria". If something is missed and discovered during the Sprint the PO may change the Done Criteria of a User Story after getting an approval from the Team.
During Sprint Reviews the working software can be measured against the Done Criteria, and if it measures up, the User Story can be called done.
In an agile approach, changes in requirements are expected and considered healthy. Responsiveness to change is considered more important than following a plan.
A sprint review is one place to gather feedback and new requirements. Usability tests also help. But what helps the most is heavy use of the software by a QA team and/or actual users.
If you happened to be using JIRA and GreenHopper for managing your requirements (as stories), you might find helpful a search for stories created after a certain date. Finding modified requirements would be more interesting.
Is software ever complete? Obviously the real benchmark for completeness is someone's mind's eye view of what the software should do.
Trying to measure against a person's mental image is ultimately going to be challenging and no formal method will ever really do it well. The only thing you can measure against are the requirements they give you. You can look at un-addressed requirements, but you can never measure the gap of what they didn't tell you.
The message I have gotten from the agile school of thought is that measuring completeness is kind of a waste of time - it's really the wrong question.
For example, with scrum, you make a prioritized backlog of all the requirements and just start working down the list. When the money/desire runs out... you stop.
If you're going the agile/scrum route as you imply, then generally you'll want to break up the project into small discrete units of effort. A project contains epics (or is an epic), an epic contains stories, a story contains tasks. (A task should ideally be 4-8 hours of work. Something that somebody can do in a work day.)
As each story is completed, it should be tested and verified. This generally isn't done for tasks because often a single task can't be tested by a user until other tasks for the story are complete. A user can't be expected to test "Write a method to persist an order to the database" but would instead test "When this button is clicked, the order is persisted to the database and the user is shown an updated shopping cart to include re-calculated taxes and shipping."
This testing/verification is not done by the developer. It should be verified by whoever is in charge of the product/project or a delegate thereof. The developer will naturally test it the way he or she wrote it, expecting it to work that way. If anything was misinterpreted in the requirements, it would just be misinterpreted again.
As each story is verified as complete, it's a discrete and measurable step towards project completion. (Measurable by how many tasks it involved and therefore how much work was completed towards the sum total.)
Keep in mind that any such measurements can change from one sprint to the next. If upper management is looking for a single road-map with completable steps along the way all the way to the end of the project, they may be misunderstanding a fundamental concept in agile development. The stories further down the line haven't been fully defined yet. They may involve more or less work than originally estimated, based on development done on (and changes made to) the immediate stories.
One way to try to approach the concept of fluid stories and changing requirements is to not think in terms of "projects" but just epics and stories. These discrete units should be wholly workable and testable on their own (though some will of course have others as pre-requisites). Changing priorities can move the stories around at will. A "project" doesn't need to be "put on hold" if priorities change, its stories are simply moved to the backlog in lieu of other stories.
The idea is that management is steering where you go next, not just giving you a list of destinations and hoping you'll arrive at them in the right order.
In this sense, the "completeness" of a "project" almost entirely loses its meaning. How much is "complete" is up to whoever owns the product/project. They can add to it or remove from it at will, shift priorities easily, etc. If they want to know "when will we arrive at destination A?" then that's up to them. You've given them estimates on how much work is involved in each step along the way, it's up to them to steer in what they think is the best direction to get there while you provide the work.
发布评论
评论（4）
您正在查找的单词是“完成标准”。在敏捷世界中，它比单词本身具有更深刻的含义。如果发现缺失，它通常是敏捷组织中首先要修复的问题。下面（最后）是一篇文章的链接，其中更详细地解释了它。
大多数敏捷团队使用用户故事作为他们的“初始要求”。用户故事将是您的初始需求，这足以让团队启动。使用的衡量标准应该是大多数团队所说的“完成标准”。每个用户故事都应该有一个完成的标准。例如。为了称待办事项已完成，需要完成这些事项清单。在设置此设置时，我们不担心如何完成，只担心需要做什么。
在 Sprint 评审期间，团队将展示并讲述工作软件，如果它符合完成标准，PO 应批准将其正式标记为完成。
当然，有时用户故事会改变完成标准，特别是对于新团队或项目，但这是完全正常的，因为一个好的用户故事的标志是它是可以协商的。在获得团队批准后，完成标准可以稍作修改。团队很少会反对这些，除非变更导致要完成的工作的复杂性急剧增加。
总结一下：
初始要求，即用户故事需要有一个“需要完成什么”的标准。如果在 Sprint 期间遗漏并发现了某些内容，PO 可能会在获得团队批准后更改用户故事的完成标准 在冲刺评审期间，
来衡量工作软件，如果达到标准，则可以将用户故事称为“完成”。
可以根据“完成标准” 定义-of-done-dod" rel="nofollow">http://scrumalliance.org/articles/105-what-is-definition-of-done-dod
The word(s) you are looking for is "Done Criteria". It has a more deeper meaning than the words itself, in the Agile world. It is often the first thing to be fixed in an Agile Organization, if it is found to be missing. Below (at the end) is a link to an article which explains it in more detail.
Most Agile Teams use User Stories as their "initial requirements". The user story would be your initial requirements which would be just enough to get the Team started. The measure used, should be what most Teams call, "the Done Criteria". Every User story should have a done criteria. For eg. In order to call a backlog done, these list of things need to be Done. While setting this we do not worry about How it would be done, only What needs to be done.
During the Sprint Review, the Team would do a show and tell of the working software, and if it meets the done criteria, the PO should approve it to be officially marked done.
Off course, sometimes User stories have changing Done criteria, especially for new Teams or Projects, but that is perfectly normal, because a sign of a good user story is that it is negotiable. The Done Criteria can be slightly modified after getting approval of Team. Teams rarely disapprove these, unless the change causes a dramatic increase in complexity of the work to be done.
So to summarize:
Initial requirements i.e. User Stories need to have a "what" needs to be Done Criteria". If something is missed and discovered during the Sprint the PO may change the Done Criteria of a User Story after getting an approval from the Team.
During Sprint Reviews the working software can be measured against the Done Criteria, and if it measures up, the User Story can be called done.
http://scrumalliance.org/articles/105-what-is-definition-of-done-dod
在敏捷方法中，需求的变化是预期的并且被认为是健康的。对变化的响应被认为比遵循计划更重要。
冲刺评审是收集反馈和新要求的地方。可用性测试也有帮助。但最有帮助的是 QA 团队和/或实际用户大量使用该软件。
如果您碰巧使用 JIRA 和 GreenHopper 来管理您的需求（作为故事），您可能会发现搜索在特定日期之后创建的故事很有帮助。寻找修改后的需求会更有趣。
In an agile approach, changes in requirements are expected and considered healthy. Responsiveness to change is considered more important than following a plan.
A sprint review is one place to gather feedback and new requirements. Usability tests also help. But what helps the most is heavy use of the software by a QA team and/or actual users.
If you happened to be using JIRA and GreenHopper for managing your requirements (as stories), you might find helpful a search for stories created after a certain date. Finding modified requirements would be more interesting.
软件是否完整？显然，完整性的真正基准是人们对软件应该做什么的看法。
试图衡量一个人的心理形象最终将是具有挑战性的，并且没有任何正式的方法能够真正做到这一点。您唯一可以衡量的是他们给您的要求。您可以查看未解决的需求，但您永远无法衡量他们没有告诉您的内容之间的差距。
我从敏捷思想流派得到的信息是，衡量完整性有点浪费时间——这确实是一个错误的问题。
例如，通过 Scrum，您可以对所有需求按优先顺序积压，然后开始按照列表进行工作。当金钱/欲望耗尽时……你就会停下来。
Is software ever complete? Obviously the real benchmark for completeness is someone's mind's eye view of what the software should do.
Trying to measure against a person's mental image is ultimately going to be challenging and no formal method will ever really do it well. The only thing you can measure against are the requirements they give you. You can look at un-addressed requirements, but you can never measure the gap of what they didn't tell you.
The message I have gotten from the agile school of thought is that measuring completeness is kind of a waste of time - it's really the wrong question.
For example, with scrum, you make a prioritized backlog of all the requirements and just start working down the list. When the money/desire runs out... you stop.
如果您按照您的暗示采用敏捷/Scrum 路线，那么通常您会希望将项目分解为小的离散工作单元。一个项目包含史诗（或者是一个史诗），史诗包含故事，故事包含任务。 （一项任务理想情况下应该是 4-8 小时的工作。某人在一个工作日内可以完成的事情。）
每个故事完成后，都应该对其进行测试和验证。通常不会对任务执行此操作，因为在故事的其他任务完成之前，用户通常无法测试单个任务。不能期望用户测试“编写将订单保存到数据库的方法”，而是测试“单击此按钮时，订单将保存到数据库，并向用户显示更新的购物车以包括重新计算税费和运费。”
此测试/验证不是由开发人员完成。应由负责产品/项目的人员或其代表进行验证。开发人员自然会按照他或她编写的方式对其进行测试，并期望它能够以这种方式工作。如果需求中存在任何误解，那么它只会再次被误解。
由于每个故事都被验证为完整，因此这是项目完成的一个离散且可衡量的步骤。 （可以通过涉及的任务数量以及完成的总工作量来衡量。）
请记住，任何此类衡量标准都可能从一个冲刺到下一个冲刺发生变化。如果高层管理人员正在寻找一个具有完整步骤的单一路线图，一直到项目结束，他们可能会误解敏捷开发的基本概念。后续的故事尚未完全确定。根据对直接故事的开发（和更改），它们可能涉及比最初估计更多或更少的工作。
尝试处理流动故事和不断变化的需求概念的一种方法是不要考虑“项目”，而只考虑史诗和故事。这些离散单元应该是完全可行的并且可以自行测试（尽管有些单元当然会有其他单元作为先决条件）。改变优先级可以随意改变故事的方向。如果优先级发生变化，“项目”不需要被“搁置”，它的故事只是移动到待办事项中而不是其他故事。
这个想法是，管理层引导你下一步去哪里，而不仅仅是给你一个目的地列表并希望你能按正确的顺序到达它们。
从这个意义上说，“项目”的“完整性”几乎完全失去了意义。多少“完整”取决于产品/项目的所有者。他们可以随意添加或删除，轻松改变优先级等等。如果他们想知道“我们什么时候到达目的地A？”那么这取决于他们。您已经向他们提供了整个过程中每个步骤涉及多少工作的估计，由他们在您提供工作的同时按照他们认为的最佳方向进行引导。
If you're going the agile/scrum route as you imply, then generally you'll want to break up the project into small discrete units of effort. A project contains epics (or is an epic), an epic contains stories, a story contains tasks. (A task should ideally be 4-8 hours of work. Something that somebody can do in a work day.)
As each story is completed, it should be tested and verified. This generally isn't done for tasks because often a single task can't be tested by a user until other tasks for the story are complete. A user can't be expected to test "Write a method to persist an order to the database" but would instead test "When this button is clicked, the order is persisted to the database and the user is shown an updated shopping cart to include re-calculated taxes and shipping."
This testing/verification is not done by the developer. It should be verified by whoever is in charge of the product/project or a delegate thereof. The developer will naturally test it the way he or she wrote it, expecting it to work that way. If anything was misinterpreted in the requirements, it would just be misinterpreted again.
As each story is verified as complete, it's a discrete and measurable step towards project completion. (Measurable by how many tasks it involved and therefore how much work was completed towards the sum total.)
Keep in mind that any such measurements can change from one sprint to the next. If upper management is looking for a single road-map with completable steps along the way all the way to the end of the project, they may be misunderstanding a fundamental concept in agile development. The stories further down the line haven't been fully defined yet. They may involve more or less work than originally estimated, based on development done on (and changes made to) the immediate stories.
One way to try to approach the concept of fluid stories and changing requirements is to not think in terms of "projects" but just epics and stories. These discrete units should be wholly workable and testable on their own (though some will of course have others as pre-requisites). Changing priorities can move the stories around at will. A "project" doesn't need to be "put on hold" if priorities change, its stories are simply moved to the backlog in lieu of other stories.
The idea is that management is steering where you go next, not just giving you a list of destinations and hoping you'll arrive at them in the right order.
In this sense, the "completeness" of a "project" almost entirely loses its meaning. How much is "complete" is up to whoever owns the product/project. They can add to it or remove from it at will, shift priorities easily, etc. If they want to know "when will we arrive at destination A?" then that's up to them. You've given them estimates on how much work is involved in each step along the way, it's up to them to steer in what they think is the best direction to get there while you provide the work.