Teams in my company face the same types of problems. We are building projects with a large number of moving parts and architectural layers that make it difficult to create a working product early on. Additionally, there are often specialty resources that need to be scheduled or slightly out of synch with the team. Some approaches we've taken are below It has been challenging, but these approaches seem to be helping.
Build as vertically as possible
In other words, strive to have something working, end to end as quickly as possible. We typically get there a few sprints in on a 9-16 month project.
You'll often find a significant number of layers can be mocked or held back.
Often, the initial customer facing components are place holders. We create a limited bit of functionality that is something like what the customer wants, but is likely to be very different in the final project. This allows us to prove the rest of the product at a system level and provide visibility from a system perspective.
Separate base architecture from the product
Our early sprints are often centered around infrastructure/architecture. For example, threading subsystems, performance monitoring, communications and test frameworks.
Treat the subsystems as separate deliverables
Fully define each subsystem
Complete (truly complete, not just a partial implementation) each subsystem
Load test each subsystem within the context of how it will be used in the final product
Make your first iteration to be dedicated to architectural design, including the identification of the necessary components and the definition of the relationships and communications between them.
Once you have a clear picture of how the components interact, build the skeleton of each one. That is, implement "stub" components that just have the communication part on place, and the rest of the functionnality just do nothing or return test data. Have an interation dedicated to this task (including testing the component communication mechanisms) as well.
Then you can plan iterations to fully develop each component in the appropriate order, so that the system can grow in a ordered way.
It is unlikely that each layer needs to be complete for it to be usable by the other layers - for example the persistence layer could just serialize objects to a file initially, and converted to use a database when the need arises. I would look at implementing the minimum of each layer needed by the initial stories and fleshed out to add functionality as the the system grows.
Growing a system this way means you only implement the functionality you need, rather than all the functionality you think you may need at some indeterminate time in the future.
If you cannot break the large project into smaller parts that are useful (i.e. enable some use cases) on their own, agile probably won't help you that much in this project. You can pick some techniques like pair programming, refactoring etc. but the overall planning has do be done in a conventional way.
发布评论
评论（5）
我公司的团队面临着同样类型的问题。我们正在构建具有大量移动部件和架构层的项目，这使得早期创建工作产品变得困难。此外，通常还有一些专业资源需要安排或与团队稍微不同步。我们采取的一些方法如下。 这一直具有挑战性，但这些方法似乎有所帮助。
尽可能垂直构建
将基础架构与产品分开
我们早期的冲刺通常以基础架构/架构为中心。例如，线程子系统、性能监控、通信和测试框架。
Teams in my company face the same types of problems. We are building projects with a large number of moving parts and architectural layers that make it difficult to create a working product early on. Additionally, there are often specialty resources that need to be scheduled or slightly out of synch with the team. Some approaches we've taken are below It has been challenging, but these approaches seem to be helping.
Build as vertically as possible
Separate base architecture from the product
Our early sprints are often centered around infrastructure/architecture. For example, threading subsystems, performance monitoring, communications and test frameworks.
让您的第一次迭代致力于架构设计，包括识别必要的组件以及定义它们之间的关系和通信。
一旦您清楚地了解了组件如何交互，就可以构建每个组件的框架。也就是说，实现仅具有通信部分的“存根”组件，而其余功能则不执行任何操作或返回测试数据。也有专门用于此任务的交互（包括测试组件通信机制）。
然后你可以计划迭代，以适当的顺序充分开发每个组件，从而使系统能够以有序的方式增长。
Make your first iteration to be dedicated to architectural design, including the identification of the necessary components and the definition of the relationships and communications between them.
Once you have a clear picture of how the components interact, build the skeleton of each one. That is, implement "stub" components that just have the communication part on place, and the rest of the functionnality just do nothing or return test data. Have an interation dedicated to this task (including testing the component communication mechanisms) as well.
Then you can plan iterations to fully develop each component in the appropriate order, so that the system can grow in a ordered way.
TDD - 编写测试后使用不完整的部分进行迭代。 模拟未准备好的部分。听起来很令人兴奋。
TDD - iterate with incomplete parts after writing tests. Mock the bits that aren't ready. Sounds exciting.
每个层不太可能需要完整才能被其他层使用 - 例如，持久层最初可以将对象序列化到文件，并在需要时转换为使用数据库。我会考虑实现初始故事所需的每一层的最低限度，并随着系统的发展而充实以添加功能。
以这种方式发展系统意味着您只实现您需要的功能，而不是您认为在未来某个不确定的时间可能需要的所有功能。
It is unlikely that each layer needs to be complete for it to be usable by the other layers - for example the persistence layer could just serialize objects to a file initially, and converted to use a database when the need arises. I would look at implementing the minimum of each layer needed by the initial stories and fleshed out to add functionality as the the system grows.
Growing a system this way means you only implement the functionality you need, rather than all the functionality you think you may need at some indeterminate time in the future.
如果您无法将大型项目分解为单独有用的较小部分（即启用某些用例），那么敏捷可能不会在该项目中为您提供太大帮助。你可以选择一些技术，如结对编程、重构等，但总体规划必须以传统方式完成。
If you cannot break the large project into smaller parts that are useful (i.e. enable some use cases) on their own, agile probably won't help you that much in this project. You can pick some techniques like pair programming, refactoring etc. but the overall planning has do be done in a conventional way.