I would suggest that the issue of team volatility is addressed first. No process is going to work very well if you've got a revolving door in your office in the first place and I'd say that using a process that relies more heavily on an individual's performance and contribution than one intended to be used with "replaceable cogs in a machine" is going to make matters worse if that's possible.
Pair programming might work in a situation like this provided you can keep some people around for long enough so that they can impart their knowledge on new members on the team. However part of the problem with that is that you can't really practise the "pair of equals" part of pair programming and you'll end up in an implied senior/junior situation simply because one half of the pair doesn't know the code well enough.
Most development processes rely on a comparatively stable team that does know the codebase well. If you don't have that, you need to design a process around the fact that you will be dealing with developers that are trying to grasp the codebase at the same time as they're trying to be productive.
Programmer Pairing becomes a must. Engineer practices (XP) along with management practices (SCRUM) enables to deliver at a sustainable pace. One of the first things you should emphasize for a working team is to keep it together. If that is not possible, programming pairing carries even more importance!
For waterfall, a project is started, people are gathered, they then have to go through Form, Storm, Norm then Perform. Once the team learns how to work together, the project ends and the working team is disbanded. Then the process is repeated again. Do you see the problem? Who has so much money that they can continue to pay the cost for teams to Form, Storm, Norm then Perform again and again?
That being said, every team will see team people come and go. With programmer pairing, you can bring new folks to the team and they will become effective almost immediately. By pairing they will learn the business domain, application code and engineering practice very quickly.
We took a team of 4 pair and added 3 new pairs to the team. We paired all the new developers with experience team members. We gave ourselves 30 days to bring the new members up to speed. The team hit all deliverables. Could you image adding 6 developer to a team of 8 developers on a waterfall team. The team would nearly grind to a halt assimilating the new team members.
Bottom line, keep a function team together. If that is not possible, make effective use of pairing to bring new folks on board quickly.
当团队组成不稳定时，什么流程会起作用？ 至少在 XP 中，使用结对编程，您希望不止一名团队成员对代码的所有部分都有一定程度的熟悉。 FWIW，我不练习XP，我只是不明白使用XP如何加剧这个问题。
What process is going to work when the team composition is volatile? At least with XP, using pair programming, you have some hope that more than one team member has some familiarity with all parts of the code. FWIW, I don't practice XP, I just don't see how the issue is exacerbated by using XP.
Pair Programming should help with getting new team members up to speed, as well as osmotic communication in a team room. Extensive suites of both developer and customer tests should make sure that new team members don't break existing functionality. High code quality should help them find their way around faster.
Having said that, volatile teams are really a strong antipattern. Why do you have them in the first place?
High test coverage and a continuous integration can help ensure that new team members do not break what was previously implemented. Pair programming is the fastest way that I've found to help someone get familiar with a project. Planning meetings, short iterations, and tracking velocity over those iterations could also help new developers easily bite small pieces that are more easily managed.
发布评论
评论（5）
我建议首先解决团队波动的问题。 如果你的办公室一开始就有旋转门，那么任何流程都不会运作得很好，我想说的是，使用一个更依赖于个人表现和贡献的流程，而不是打算使用的流程“如果可能的话，机器中可更换的齿轮”将使事情变得更糟。
结对编程可能会在这种情况下发挥作用，前提是您可以让一些人留在身边足够长的时间，以便他们可以向团队中的新成员传授知识。 然而，问题的一部分在于，你无法真正练习结对编程中的“平等对”部分，并且你最终会陷入隐含的高级/初级情况，仅仅是因为一半的人不知道代码足够好。
大多数开发流程都依赖于一个相对稳定且熟悉代码库的团队。 如果你没有，你需要围绕这样一个事实来设计一个流程：你将与那些试图掌握代码库同时试图提高工作效率的开发人员打交道。
I would suggest that the issue of team volatility is addressed first. No process is going to work very well if you've got a revolving door in your office in the first place and I'd say that using a process that relies more heavily on an individual's performance and contribution than one intended to be used with "replaceable cogs in a machine" is going to make matters worse if that's possible.
Pair programming might work in a situation like this provided you can keep some people around for long enough so that they can impart their knowledge on new members on the team. However part of the problem with that is that you can't really practise the "pair of equals" part of pair programming and you'll end up in an implied senior/junior situation simply because one half of the pair doesn't know the code well enough.
Most development processes rely on a comparatively stable team that does know the codebase well. If you don't have that, you need to design a process around the fact that you will be dealing with developers that are trying to grasp the codebase at the same time as they're trying to be productive.
程序员结对成为必须。工程师实践 (XP) 和管理实践 (SCRUM) 能够以可持续的速度交付。 对于一个工作团队来说，你应该强调的第一件事就是保持团结。 如果这是不可能的，编程配对就显得尤为重要！
对于瀑布，一个项目启动，人们聚集在一起，然后他们必须经历形成、风暴、规范，然后执行。 一旦团队学会了如何一起工作，项目就会结束，工作团队就会解散。 然后再次重复该过程。 你看到问题了吗？ 谁有这么多钱，可以持续支付团队一次又一次成型、风暴、规范、执行的成本？
话虽这么说，每个团队都会看到团队成员的来来去去。 通过程序员结对，你可以将新人带入团队，他们几乎会立即发挥作用。 通过结对，他们将非常快速地学习业务领域、应用程序代码和工程实践。
我们组建了 4 对团队，并添加了 3 对新团队。 我们将所有新开发人员与经验丰富的团队成员配对。 我们给自己 30 天的时间来让新成员熟悉情况。 该团队实现了所有可交付成果。 您能否想象在瀑布团队的 8 名开发人员团队中添加 6 名开发人员。 团队在吸收新团队成员的过程中几乎陷入停滞。
最重要的是，保持职能团队的团结。 如果不可能，请有效利用结对来快速吸引新人加入。
Programmer Pairing becomes a must. Engineer practices (XP) along with management practices (SCRUM) enables to deliver at a sustainable pace. One of the first things you should emphasize for a working team is to keep it together. If that is not possible, programming pairing carries even more importance!
For waterfall, a project is started, people are gathered, they then have to go through Form, Storm, Norm then Perform. Once the team learns how to work together, the project ends and the working team is disbanded. Then the process is repeated again. Do you see the problem? Who has so much money that they can continue to pay the cost for teams to Form, Storm, Norm then Perform again and again?
That being said, every team will see team people come and go. With programmer pairing, you can bring new folks to the team and they will become effective almost immediately. By pairing they will learn the business domain, application code and engineering practice very quickly.
We took a team of 4 pair and added 3 new pairs to the team. We paired all the new developers with experience team members. We gave ourselves 30 days to bring the new members up to speed. The team hit all deliverables. Could you image adding 6 developer to a team of 8 developers on a waterfall team. The team would nearly grind to a halt assimilating the new team members.
Bottom line, keep a function team together. If that is not possible, make effective use of pairing to bring new folks on board quickly.
当团队组成不稳定时，什么流程会起作用？ 至少在 XP 中，使用结对编程，您希望不止一名团队成员对代码的所有部分都有一定程度的熟悉。 FWIW，我不练习XP，我只是不明白使用XP如何加剧这个问题。
What process is going to work when the team composition is volatile? At least with XP, using pair programming, you have some hope that more than one team member has some familiarity with all parts of the code. FWIW, I don't practice XP, I just don't see how the issue is exacerbated by using XP.
结对编程应该有助于让新的团队成员跟上进度，以及在团队房间中进行渗透式沟通。 广泛的开发人员和客户测试套件应确保新的团队成员不会破坏现有功能。 高代码质量应该可以帮助他们更快地找到方法。
话虽如此，不稳定的团队确实是一个强大的反模式。 你为什么首先要拥有它们？
Pair Programming should help with getting new team members up to speed, as well as osmotic communication in a team room. Extensive suites of both developer and customer tests should make sure that new team members don't break existing functionality. High code quality should help them find their way around faster.
Having said that, volatile teams are really a strong antipattern. Why do you have them in the first place?
高测试覆盖率和持续集成可以帮助确保新的团队成员不会破坏以前实施的内容。 结对编程是我发现的帮助某人熟悉项目的最快方法。 计划会议、短期迭代以及跟踪这些迭代的速度也可以帮助新开发人员轻松地咬住更容易管理的小部分。
High test coverage and a continuous integration can help ensure that new team members do not break what was previously implemented. Pair programming is the fastest way that I've found to help someone get familiar with a project. Planning meetings, short iterations, and tracking velocity over those iterations could also help new developers easily bite small pieces that are more easily managed.