The design you describe sounds like it might be a little too tightly-coupled. A renewed focus on enterprise patterns (such as Inversion of Control, programming to interfaces, etc) could help a lot.
If you are doing pair programming, you should be checking each other's work, making sure all of the i's are dotted and the t's are crossed.
If you are doing Test Driven Development, your tests should not be passing until all requirements for that particular portion of the development effort are satisfied.
If you are developing a large, complex system, you need experienced developers who understand the design and development process. You may also need a hands-on (read:coding) architect who can oversee the whole process.
Oh, and checklists (despite their traditional nature) are good too.
I'd suggest reading Alistair Cockburn's "”Agile Software Development: The Cooperative Game" - he takes quite an intelligent approach to Agile that's largely "do what gets the job done". That might help you work out how to get some kind of checklist / documentation into what you're doing without making everything horribly top-heavy.
Could some of your problems be solved by better tests? When you talked about not doing things that need to be done, my first thought was "why hasn't a test failed?" Maybe you need to look at tools for testing user interfaces? (edit: or even some small script on commit that greps code for whatever indicates the need for translation strings and checks against the files with the translations in?)
Also, can you change your design so that it's both less coupled and "forces" you to do the right thing. Perhaps making those data types implement a logging interface that the logger delegates to, or similar...?
Depending on your IDE there are various tools to help identify strings that need to be externalized, but if you are in a habit of just not putting in static strings this can be avoided.
If you need to add logging I would suggest AOP, as, at some point you will want to remove the logging code and you risk breaking the application.
But, a long-term, complex system is ideal for agile development, as, while you are developing, the needs of the client/customer may change, and you can adapt to it.
You need to ensure that the customer has feedback on a regular basis (ideally daily, and in a perfect system the customer has a rep sitting by for questions).
When I have many steps that must be done, esp for something like datatypes, I will resort to using a spreadsheet, so, you add a datatype, you add a row to the spreadsheet. Then you can track everything that needs to be done before that datatype is completely added to the application.
Have cross-component teams. That way when you add some functionality, the member(s) from the logging component will update their part and the translator(s) will update the strings.
I think it is important to understand that Agile methodology is only a process framework, not a process in itself. For example it says to follow test driven development and do pair programming but it does not say how to write the tests, or suggest a review checklist or suggest a coding guideline or say what documents to write. Those parts are entirely upto you or your organization to define and follow.
When planning a feature, you can add a engineering task called "review" and allot time for it. You could do the review task in whatever way works best for you and your organization. If pair programming doesn't work as well as a formal inspection for you, you should do formal inspections.
Well, where I work we have QA that can catch some of the bugs if there are missing requirements or something slips through. I'm not saying the development team is intentionally putting in bugs, but as a codebase grows, it becomes harder and harder to remain nimble and thorough in checking everything.
Wikis can be useful for capturing methods used to try to get the clearest requirements. By clear I mean that the story card isn't likely to list all the requirements and that there may be discussions with an end-user or business analyst to get their understanding of what is desired. Part of our sign-offs involve getting an end-user to see the functionality and approve it before moving from the development environment.
Once every handful of sprints, we may have most of a sprint devoted to bug fixing/refactoring so that things can be cleaned up that would otherwise not get done as they aren't likely to be important. This can be cosmetic bugs or broken windows that while they have little business value initially can be useful in the long run.
发布评论
评论（7）
您描述的设计听起来可能有点过于紧密耦合。重新关注企业模式（例如控制反转、接口编程等）可能会有很大帮助。
如果你正在进行结对编程，你应该检查彼此的工作，确保所有的 i 都是点状的，并且 t 都是交叉的。
如果您正在进行测试驱动开发，则在满足开发工作的特定部分的所有要求之前，您的测试不应通过。
如果您正在开发一个大型、复杂的系统，您需要了解设计和开发过程的经验丰富的开发人员。您可能还需要一位能够监督整个过程的实践（阅读：编码）架构师。
哦，检查清单（尽管其传统性质）也很好。
The design you describe sounds like it might be a little too tightly-coupled. A renewed focus on enterprise patterns (such as Inversion of Control, programming to interfaces, etc) could help a lot.
If you are doing pair programming, you should be checking each other's work, making sure all of the i's are dotted and the t's are crossed.
If you are doing Test Driven Development, your tests should not be passing until all requirements for that particular portion of the development effort are satisfied.
If you are developing a large, complex system, you need experienced developers who understand the design and development process. You may also need a hands-on (read:coding) architect who can oversee the whole process.
Oh, and checklists (despite their traditional nature) are good too.
我建议阅读 Alistair Cockburn 的“敏捷软件开发：合作游戏”——他采用了一种相当明智的敏捷方法，主要是“做能完成工作的事情”。这可能会帮助你弄清楚如何将某种清单/文档纳入你正在做的事情中，而不会使一切变得头重脚轻。
您的一些问题可以通过更好的测试来解决吗？当你谈到不做需要做的事情时，我的第一个想法是“为什么测试没有失败？”也许您需要查看用于测试用户界面的工具？ （编辑：或者甚至是提交时的一些小脚本，该脚本可以对任何指示需要翻译字符串的内容进行 grep 代码，并检查包含翻译的文件？）
另外，您可以更改您的设计，以便减少耦合并“强制”您做正确的事。也许使这些数据类型实现记录器委托的日志记录接口，或类似的......？
I'd suggest reading Alistair Cockburn's "”Agile Software Development: The Cooperative Game" - he takes quite an intelligent approach to Agile that's largely "do what gets the job done". That might help you work out how to get some kind of checklist / documentation into what you're doing without making everything horribly top-heavy.
Could some of your problems be solved by better tests? When you talked about not doing things that need to be done, my first thought was "why hasn't a test failed?" Maybe you need to look at tools for testing user interfaces? (edit: or even some small script on commit that greps code for whatever indicates the need for translation strings and checks against the files with the translations in?)
Also, can you change your design so that it's both less coupled and "forces" you to do the right thing. Perhaps making those data types implement a logging interface that the logger delegates to, or similar...?
根据您的 IDE，有各种工具可以帮助识别需要外部化的字符串，但如果您习惯不放入静态字符串，则可以避免这种情况。
如果您需要添加日志记录，我会建议 AOP，因为在某些时候您会想要删除日志记录代码，并且有破坏应用程序的风险。
但是，长期、复杂的系统是敏捷开发的理想选择，因为在开发过程中，客户/顾客的需求可能会发生变化，而您可以适应它。
您需要确保客户定期获得反馈（最好是每天，并且在完美的系统中，客户有一名代表在场解答问题）。
当我有许多必须完成的步骤时，尤其是数据类型之类的步骤，我将诉诸使用电子表格，因此，您添加数据类型，然后向电子表格添加一行。然后，您可以跟踪该数据类型完全添加到应用程序之前需要完成的所有操作。
Depending on your IDE there are various tools to help identify strings that need to be externalized, but if you are in a habit of just not putting in static strings this can be avoided.
If you need to add logging I would suggest AOP, as, at some point you will want to remove the logging code and you risk breaking the application.
But, a long-term, complex system is ideal for agile development, as, while you are developing, the needs of the client/customer may change, and you can adapt to it.
You need to ensure that the customer has feedback on a regular basis (ideally daily, and in a perfect system the customer has a rep sitting by for questions).
When I have many steps that must be done, esp for something like datatypes, I will resort to using a spreadsheet, so, you add a datatype, you add a row to the spreadsheet. Then you can track everything that needs to be done before that datatype is completely added to the application.
拥有跨组件团队。这样，当您添加某些功能时，日志记录组件中的成员将更新其部分，并且翻译器将更新字符串。
Have cross-component teams. That way when you add some functionality, the member(s) from the logging component will update their part and the translator(s) will update the strings.
我认为重要的是要理解敏捷方法只是一个过程框架，而不是一个过程本身。例如，它说遵循测试驱动开发并进行结对编程，但没有说明如何编写测试，或建议审查清单或建议编码指南或说明要编写哪些文档。这些部分完全由您或您的组织来定义和遵循。
规划功能时，您可以添加名为“审核”的工程任务并为其分配时间。您可以采用最适合您和您的组织的任何方式来完成审核任务。如果结对编程对您来说不如正式检查那么有效，那么您应该进行正式检查。
I think it is important to understand that Agile methodology is only a process framework, not a process in itself. For example it says to follow test driven development and do pair programming but it does not say how to write the tests, or suggest a review checklist or suggest a coding guideline or say what documents to write. Those parts are entirely upto you or your organization to define and follow.
When planning a feature, you can add a engineering task called "review" and allot time for it. You could do the review task in whatever way works best for you and your organization. If pair programming doesn't work as well as a formal inspection for you, you should do formal inspections.
做需要做的事情，但不要做更多：
Do what needs to be done, but not more:
嗯，在我工作的地方，我们有 QA，可以在缺少需求或漏掉某些内容的情况下发现一些错误。我并不是说开发团队故意引入错误，但随着代码库的增长，在检查所有内容时保持灵活和彻底变得越来越困难。
Wiki 对于捕获用于尝试获得最清晰需求的方法很有用。明确地说，我的意思是故事卡不太可能列出所有要求，并且可能会与最终用户或业务分析师进行讨论，以了解他们的需求。我们签核的一部分涉及让最终用户在离开开发环境之前查看功能并批准它。
每进行几次冲刺，我们就可能将大部分冲刺专门用于错误修复/重构，以便可以清理那些本来不会完成的事情，因为它们不太重要。这可能是外观错误或破损的窗户，虽然它们最初没有什么商业价值，但从长远来看却很有用。
Well, where I work we have QA that can catch some of the bugs if there are missing requirements or something slips through. I'm not saying the development team is intentionally putting in bugs, but as a codebase grows, it becomes harder and harder to remain nimble and thorough in checking everything.
Wikis can be useful for capturing methods used to try to get the clearest requirements. By clear I mean that the story card isn't likely to list all the requirements and that there may be discussions with an end-user or business analyst to get their understanding of what is desired. Part of our sign-offs involve getting an end-user to see the functionality and approve it before moving from the development environment.
Once every handful of sprints, we may have most of a sprint devoted to bug fixing/refactoring so that things can be cleaned up that would otherwise not get done as they aren't likely to be important. This can be cosmetic bugs or broken windows that while they have little business value initially can be useful in the long run.