We've done everything except small releases and it's been great. I can't imagine working any other way. From my experience, the tenets I value most are:
Continuous integration (with a solid test suite).
Collective code ownership.
TDD
Team empowerment and decision making.
Coding standards.
Refactoring.
Sustainable pace.
The rest are very nice to have too, but I've found that I can live w/o pairing so long as we have TDD, collective ownership, and refactoring.
It is hard to convince management of this aspect. But I have found this is doable when an engineer gets stuck or we have an engineer who is new to a technology or effort.
Planning game
Yes.
Test driven development
Easy sell to management. However the hard part of some management is adding in more time. A lot of managers believe that Extreme and Agile programming will save them time. They don't save time to deliver you something. In fact, the testing constant requirements gathering adds effort. What it does do, is it gets the customer what they want faster.
Whole team (being empowered to deliver)
Definitely, this is an amazing facet to Xtreme.
Continuous integration
At the end of each iteration (sprint) full integration occurs. Daily full integration does not occur.
Refactoring or design improvement
Your first effort is rarely the best. So yes, I find Xtreme constantly yields better and better solutions.
Small releases
I find that given the infrastructure and resources that can lengthen the suggested length of an iteration of 1 or 2 weeks. A lot of this depends on where you are deploying to. If you system is being deployed to a production environment, formal systems and stress testing can add a lot of overhead. So in this environment, we go with iterations lasting a month or even 2 months. If the system is being deployed to a development area and has not been deployed to production, even something as tight as an iteration lasting 1 day can be doable.
Coding standards
Pair programming for new team members can promote this. Code reviews also can help here. A lot of this depends on how long you have been working with each other.
Collective code ownership
I haven't found that Xtreme really helps here. Everyone naturally falls into certain areas of the code base. So people get ownership of things they spend a lot of time with. This can actually be a good driver as good software engineers will take pride in what ever they write this way.
Simple design
Short iteration cycles do in fact promote a simple design. It needs to be maintainable for the short releases.
System metaphor
Not sure what is meant here?
Sustainable pace
Velocity of a team is a task that can only be acutely estimated with proper metrics. Metrics need to be kept on task estimates and task completions durations.
但是，我确实在一个相当保守的关键任务开发团队中工作。 我并不一定认为 XP 是一种好的开发方式，您必须找到一种适合您的方式并忽略教条。
Whole team (being empowered to deliver)
Small releases
Coding standards
Collective code ownership
But then, I do work in a mission-critical development team that's quite conservative. I don't necessarily thing XP is a good way to develop, you must find a way that's right for you and ignore the dogma.
We are following these practices you've mentioned:
Planning game
Test driven development
Whole team (being empowered to deliver)
Continuous integration
Refactoring or design improvement
Small releases
Coding standards
Collective code ownership
Simple design
And I must say that after one year I can't imagine working differently.
As for Pair programming I must say that it makes sense in certain areas, where there is a very high difficult area or where an initial good design is essential (e.g. designing interfaces). However I don't consider this as very effective. In my opinion it is better to perform code and design reviews of smaller parts, where Pair programming would have made sense.
As for the 'Whole team' practice I must admit that it has suffered as our team grew. It simply made the planning sessions too long, when everybody can give his personal inputs. Currently a core team is preparing the planning game by doing some initial, rough planning.
I consider myself lucky, all except "Pair programming" we can do it, but only to solve big issues not on a day-to-day basis. "Collective code ownership" is hard to achieve as well, not doing pair programming we tend to keep the logical next user stories from iteration to iteration.
发布评论
评论（5）
除了小版本之外，我们已经完成了所有工作，效果非常棒。 我无法想象以任何其他方式工作。 根据我的经验，我最看重的原则是：
其余的也很好，但我发现只要我们有 TDD、集体所有权和重构，我就可以在没有结对的情况下生活。
We've done everything except small releases and it's been great. I can't imagine working any other way. From my experience, the tenets I value most are:
The rest are very nice to have too, but I've found that I can live w/o pairing so long as we have TDD, collective ownership, and refactoring.
在这方面很难说服管理层。 但我发现，当工程师陷入困境或者我们的工程师对一项技术或工作不熟悉时，这是可行的。
是的。
易于销售给管理层。 然而，一些管理的困难部分是增加更多的时间。 许多经理相信极限和敏捷编程可以节省他们的时间。 他们不会节省时间来给你送东西。 事实上，测试不断的需求收集会增加工作量。 它的作用是更快地为客户提供他们想要的东西。
当然，这对 Xtreme 来说是一个令人惊奇的方面。
在每次迭代（冲刺）结束时都会发生完全集成。 日常完全整合不会发生。
您的第一次努力很少是最好的。 所以，是的，我发现 Xtreme 不断产生越来越好的解决方案。
可以将建议的迭代时间延长 1 到 2 周。 这很大程度上取决于您要部署到的位置。 如果您的系统正在部署到生产环境，正式的系统和压力测试可能会增加大量开销。 所以在这种环境下，我们会进行持续一个月甚至两个月的迭代。 如果系统正在部署到开发区域并且尚未部署到生产环境，那么即使是像持续 1 天的迭代这样严格的事情也是可行的。
对新团队成员的结对编程可以促进这一点。 代码审查在这里也能有所帮助。 这在很大程度上取决于你们彼此合作的时间有多长。
我还没有发现 Xtreme 在这里真的有帮助。 每个人都会自然地陷入代码库的某些区域。 因此，人们对他们花费大量时间处理的事物拥有所有权。 这实际上可以是一个很好的驱动程序，因为优秀的软件工程师会对他们以这种方式编写的内容感到自豪。
短的迭代周期实际上确实促进了简单的设计。 对于短期版本来说，它需要可维护。
不确定这里的意思是什么？
团队的速度是一项只能通过适当的指标来准确估计的任务。 需要保留任务估计和任务完成持续时间的指标。
It is hard to convince management of this aspect. But I have found this is doable when an engineer gets stuck or we have an engineer who is new to a technology or effort.
Yes.
Easy sell to management. However the hard part of some management is adding in more time. A lot of managers believe that Extreme and Agile programming will save them time. They don't save time to deliver you something. In fact, the testing constant requirements gathering adds effort. What it does do, is it gets the customer what they want faster.
Definitely, this is an amazing facet to Xtreme.
At the end of each iteration (sprint) full integration occurs. Daily full integration does not occur.
Your first effort is rarely the best. So yes, I find Xtreme constantly yields better and better solutions.
I find that given the infrastructure and resources that can lengthen the suggested length of an iteration of 1 or 2 weeks. A lot of this depends on where you are deploying to. If you system is being deployed to a production environment, formal systems and stress testing can add a lot of overhead. So in this environment, we go with iterations lasting a month or even 2 months. If the system is being deployed to a development area and has not been deployed to production, even something as tight as an iteration lasting 1 day can be doable.
Pair programming for new team members can promote this. Code reviews also can help here. A lot of this depends on how long you have been working with each other.
I haven't found that Xtreme really helps here. Everyone naturally falls into certain areas of the code base. So people get ownership of things they spend a lot of time with. This can actually be a good driver as good software engineers will take pride in what ever they write this way.
Short iteration cycles do in fact promote a simple design. It needs to be maintainable for the short releases.
Not sure what is meant here?
Velocity of a team is a task that can only be acutely estimated with proper metrics. Metrics need to be kept on task estimates and task completions durations.
但是，我确实在一个相当保守的关键任务开发团队中工作。 我并不一定认为 XP 是一种好的开发方式，您必须找到一种适合您的方式并忽略教条。
But then, I do work in a mission-critical development team that's quite conservative. I don't necessarily thing XP is a good way to develop, you must find a way that's right for you and ignore the dogma.
我们正在遵循您提到的这些实践：
。
我必须说，一年后我无法想象工作方式会有所不同
至于结对编程，我必须说它在某些领域是有意义的，在这些领域中存在非常高的难度或最初的良好设计是必不可少的（例如设计界面）。 但我不认为这非常有效。 在我看来，最好对较小的部件进行代码和设计审查，这样结对编程才有意义。
至于“整个团队”的做法，我必须承认，随着我们团队的成长，它已经受到了影响。 当每个人都可以提出个人意见时，这只会使计划会议变得太长。 目前，核心团队正在通过一些初步的粗略规划来准备规划游戏。
We are following these practices you've mentioned:
deliver)
And I must say that after one year I can't imagine working differently.
As for Pair programming I must say that it makes sense in certain areas, where there is a very high difficult area or where an initial good design is essential (e.g. designing interfaces). However I don't consider this as very effective. In my opinion it is better to perform code and design reviews of smaller parts, where Pair programming would have made sense.
As for the 'Whole team' practice I must admit that it has suffered as our team grew. It simply made the planning sessions too long, when everybody can give his personal inputs. Currently a core team is preparing the planning game by doing some initial, rough planning.
我认为自己很幸运，除了“结对编程”之外，我们都可以做到，但只能解决大问题，而不是日常工作。 “集体代码所有权”也很难实现，如果不进行结对编程，我们往往会在迭代之间保留逻辑上的下一个用户故事。
I consider myself lucky, all except "Pair programming" we can do it, but only to solve big issues not on a day-to-day basis. "Collective code ownership" is hard to achieve as well, not doing pair programming we tend to keep the logical next user stories from iteration to iteration.