It might be helpful to utilize the 'vertical slices' concept. Imagine a simple 3-layer application (UI/Logic/DB, for example). Instead of building out one layer, then another, you 'slice' vertically through all three. An initial story might be "As a user, I want to be able to log in to the system, so that I can access it." When done, this story is potentially-shippable, in that it provides complete functionality, but is highly unlikely to provide sufficient value to the customer to make it worth actually shipping. One benefit of vertical slices is that you've learned something about all the layers, knowledge which can be use in future iterations.
If you're not familiar with it, the INVEST model is very useful for User Stories:
Any story has a Role, an Action, and a Goal. So, think about writing a story which names an Role (a/k/a Actor) doing something to achieve a goal.
What you put down should have an obvious test, ie, an effective decision procedure that defines success and failure.
Where you're running into troubles here, I think, is getting caught up in "business value". Start by defining overall how you'll know when you'd completed your task successfully. Then, "achives business value" is making some progress toward the goal.
You have to be a tiny bit creative with some things in Agile, because they're so often oriented toward business processes.
Update:
Several points here.
it is a theorem that if you can't observe any effects of a component from outside the system, then that component can be removed without effect in the sense of observational equivalence.
There is defined a thing, usually called a task, that is a programmer assignment smaller than a user story. If you have something that seems to big as a story, break it up as a task. HOWEVER, do so in a way that it has well-defined external behavior, OR build it in a context in which you can observe its behavior.
So there are a couple of possible approaches that recommend themselves to me:
Set up big stories and break them into an unusually large number of substeps
Decompose the stories, perhaps by partitioning the data set. So, for example to decompose "User request tags updated", decompose your test data so that you have only data that would receive tag α and make a story "User requests tags updated to α". Since you know everything will be an α, you build the simplest code that always assigns alpha, and worry about the code that selects.
I think you can measure correct or incorrect results for a partial system as well. You need to stub out other system components. It is certainly possibly. Also, in my opinion it makes sense that one part of the system is an actor to other modules.
发布评论
评论（3）
利用“垂直切片”概念可能会有所帮助。想象一个简单的 3 层应用程序（例如 UI/逻辑/DB）。您无需构建一层，然后构建另一层，而是垂直“切片”所有三层。最初的故事可能是“作为用户，我希望能够登录系统，以便可以访问它。”完成后，这个故事可能是可交付的，因为它提供了完整的功能，但不太可能为客户提供足够的价值以使其值得实际交付。垂直切片的好处之一是您已经了解了所有层的一些知识，这些知识可以在未来的迭代中使用。
如果您不熟悉，INVEST 模型对于用户故事非常有用：
I - 独立
N - 可协商
V - 有价值
E - 可估计
S - 大小适当
T - 可测试
It might be helpful to utilize the 'vertical slices' concept. Imagine a simple 3-layer application (UI/Logic/DB, for example). Instead of building out one layer, then another, you 'slice' vertically through all three. An initial story might be "As a user, I want to be able to log in to the system, so that I can access it." When done, this story is potentially-shippable, in that it provides complete functionality, but is highly unlikely to provide sufficient value to the customer to make it worth actually shipping. One benefit of vertical slices is that you've learned something about all the layers, knowledge which can be use in future iterations.
If you're not familiar with it, the INVEST model is very useful for User Stories:
I - Independent
N - Negotiable
V - Valuable
E - Estimable
S - Sized appropriately
T - Testable
任何故事都有角色、行动和目标。因此，考虑写一个故事，其中指定一个角色（又名演员）做某事来实现目标。
你所写下的内容应该有一个明显的测试，即定义成功和失败的有效决策程序。
我认为，你在这里遇到麻烦的地方是陷入了“商业价值”。首先从总体上定义您如何知道何时成功完成任务。那么，“实现商业价值”就是朝着目标取得一些进展。
对于敏捷中的某些事情，您必须具有一点点创造力，因为它们通常面向业务流程。
更新：
这里有几点。
这是一个定理，如果您无法从系统外部观察到某个组件的任何影响，那么该组件可以在观察等价的意义上被移除而不会产生任何影响。
定义了一个事物，通常称为任务，它是小于用户故事的程序员分配。如果你有一些看起来像故事一样大的事情，请将其分解为一项任务。但是，请以具有明确定义的外部行为的方式执行此操作，或者在可以观察其行为的上下文中构建它。
因此，有几种可能的方法向我推荐：
设置大故事并将其分解为数量异常多的子步骤
Any story has a Role, an Action, and a Goal. So, think about writing a story which names an Role (a/k/a Actor) doing something to achieve a goal.
What you put down should have an obvious test, ie, an effective decision procedure that defines success and failure.
Where you're running into troubles here, I think, is getting caught up in "business value". Start by defining overall how you'll know when you'd completed your task successfully. Then, "achives business value" is making some progress toward the goal.
You have to be a tiny bit creative with some things in Agile, because they're so often oriented toward business processes.
Update:
Several points here.
it is a theorem that if you can't observe any effects of a component from outside the system, then that component can be removed without effect in the sense of observational equivalence.
There is defined a thing, usually called a task, that is a programmer assignment smaller than a user story. If you have something that seems to big as a story, break it up as a task. HOWEVER, do so in a way that it has well-defined external behavior, OR build it in a context in which you can observe its behavior.
So there are a couple of possible approaches that recommend themselves to me:
Set up big stories and break them into an unusually large number of substeps
Decompose the stories, perhaps by partitioning the data set. So, for example to decompose "User request tags updated", decompose your test data so that you have only data that would receive tag α and make a story "User requests tags updated to α". Since you know everything will be an α, you build the simplest code that always assigns alpha, and worry about the code that selects.
我认为您也可以测量部分系统的正确或错误结果。您需要清除其他系统组件。这当然有可能。另外，在我看来，系统的一部分是其他模块的参与者是有道理的。
I think you can measure correct or incorrect results for a partial system as well. You need to stub out other system components. It is certainly possibly. Also, in my opinion it makes sense that one part of the system is an actor to other modules.