当技能阻抗不匹配时，结对编程是否有效？
例如，是否可以将一位 C#.NET 经验有限的经验丰富的编码员与一位经验丰富的 C#.NET 编码员成功配对，而次要目标是让前者跟上 C#.NET 的速度？
For example, can an experienced coder with limited C#.NET experience be successfully paired with an experienced C#.NET coder with the secondary aim of getting the former up to speed with C#.NET?
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（16）
绝对地。 共享知识是结对编程的要点之一（以及让一个人输入一点内容并让另一个人边做边检查的有用动态）。
根据我的经验，这是最有效的方法之一 - 并且允许经验不足的编码人员仍然可以做出有用的贡献（与完成整个工作相比，审查专家正在做的事情并做出明智的评论/干预所需的经验更少） 。
Absolutely. Sharing knowledge is one of the points of pair-programming (along with the useful dynamic of having one person type for a bit and the other review as they do it).
In my experience, it's one of the most effective ways of doing so - and allows the less experienced coder still to usefully contribute (it takes less experience to review what an expert is doing and make sensible comments/interventions than to do the entire job).
这取决于他们之间的个人化学反应。 如果经验丰富的程序员愿意并且能够分享他的知识，而让经验不足的程序员通过编写代码和讨论来参与开发，我会说这是一种非常有效的学习方式。
That depends on the personal chemistry between them. If the more experienced programmer is willing and able to share his knowledge, and let the less experienced programmer participate in the development through writing code and discussions, I would say that it is a very efficient way of learning.
是的，我发现好的结对编程总是有两种方式，它本质上是一种伪装成 IT 创新的社会工程。
Yes, I find good pair programming is always two way, it's essentially a piece of social engineering masquerading as an IT innovation.
是的，这会起作用。 如果 1) 经验有限的程序员愿意学习 C#，并且 2) 其他程序员愿意教 C#。
Yes, this will work. If 1) the programmer with limited experience is receptive to learning C# and 2) the other programmer is willing to teach C#.
当技能不匹配程度很高时，它确实会变得更像是师生关系。 这不错，但会浪费技术人员的时间。
然而，即使不切实际或浪费，偶尔进行一次结对会议也是非常有用的！ 即使学生不知所措或感到尴尬，有时对于“学生”来说，了解顶级人士如何工作和思考也是有用的。 它有助于让他们了解高质量工作的问题/技能/方法。 可以将其想象为一名高中生参观研究实验室。 对于专业科学家来说，教高中生是一种浪费，但是 1 小时的参观可以帮助学生集中注意力，让他们了解最终目标……
我记得为什么选择 Emacs 作为我的编辑器。 我恰好坐在一位专家用户旁边，粗鲁地越过他的肩膀，我看到他超快地重新排列和导航代码。 我只看了不到一分钟，而且我从来没有和他说过话……他可能根本没有注意到我在看！ 但我很震惊，决定学习 Emacs。 十年后，我的技能仍然不如那位专家，但我并不后悔更换编辑的决定，因为我看到了可能性。
When the skill mismatch is high, then it does become more of a teacher/student relationship. This isn't bad, but can waste time of the skilled person.
However, even if it's impractical or a waste, it can be very useful to have a very occasional pair session! Even if the student is overwhelmed or it's awkward, sometimes it's useful for "students" to see how people of top level work and think. It helps give them an idea of the problems/skills/methods of high quality work. Think of it as a high school student visiting a research laboratory. It's a waste for the pro scientists to teach the high school student, but the 1 hour visit can help focus the student and give them a glimpse of the ultimate goals...
I remember why I chose Emacs as my editor. I just happened to sit near an expert user, and literally rudely peering over his shoulder I watched him rearrange and navigate code super-quickly. I only watched for less than a minute and I never talked to him.. he may have not even noticed I was watching! But I was floored, and decided to learn Emacs. Ten years later I still don't have as much skill as that expert, but I don't regret my decision to change editors, since I got a glimpse of what was possible.
就我个人而言，我认为这会很有效，并且是结对编程的目标之一，但成功程度将取决于两个程序员。 如果程序员 1（学习 C# 的那个）投入了一些额外的时间来真正加快速度，而程序员 2（另一个）有耐心和渴望教授，那么这对双方都有好处。
Personally, I think that would work well and is one of the goals of pair-programming but how successfully will depend on the two programmers. If programmer 1 (the one learning C#) was putting in some extra time to truly get up to speed and programmer 2 (the other one) has the patience and desire to teach it should be good for both.
您当然可以做到这一点 - 我们过去已经做到了。 但您必须接受，您需要在“代码质量”收益与培训收益之间进行权衡。 恐怕没有免费的训练。
You can certainly do this - we've done it in the past. But you have to accept that you trade off the "code quality" benefits against training benefits. There's no free training ride, I'm afraid.
它在某种程度上起作用。 通常是一个人领先另一个人……所以从这个意义上来说，结对编程并不多。
这在很大程度上取决于经验丰富的编码员的教学技能和其他编码员的快速学习技能。
It works to some extent. Usually it's one leading the other... so it's not much pair programming in that sense.
It depends heavily on the experienced coder's skill to teach and the other coder's skill to learn quickly.
是的，但前提是较好的人有耐心并愿意教导，而较差的人愿意学习。 我曾与不如我的人结对编程，这很乏味，但我认为他们从中学到了东西。 我曾与比我优秀的人结对编程，我当然从中学到了东西。 确实取决于人。
Yes, but only if the better person is patient and willing to teach and the worse person is willing to learn. I've pair programmed with people not as good as me and it was tedious, but I think they learnt from it. I've pair programmed with people that are better than me and I certainly learnt from it. Depends on the people really.
它可能会有效，但需要注意以下事项：您必须更换合作伙伴。
事实上，我也曾遇到过这种情况，如果差距很大，对两人来说都会造成很大的负担。 最好在几个小时后更换合作伙伴，具体时间各不相同根据您的公差和间隙的大小。 如果该选项不可用，请混合一些独奏节目。
It can be effective with the following caveat: You must switch partners.
I've actually been in this situation and, if the gap is large, it can be very taxing for both members of the pair. Best to switch partners after a few hours, with the time varying according to your tolerance and the size of the gap. If that option isn't available, mix in some solo programming.
有句话说，一个团队的实力取决于其最薄弱的环节。 传统上，将最强者与最弱者配对一直是最好的策略，因为最弱者向最强者学习可能会确保最多的学习量。 如果担心最强的人不感兴趣，那就用真正最强的人取代最强的人。
There's a saying that a team's strength is as good as its weakest link. Pairing the strongest one with the weakest one has traditionally been the best strategy because the weakest learning from the strongest potentially ensures most amount of learning. If there is a worry of the strongest being uninterested, then replace the strongest with someone who'd really be the strongest.
这完全取决于开发人员的个性，没有硬性规定。
可以肯定的是，经验丰富的开发人员在与缺乏经验的开发人员一起工作时，工作效率会降低。 我个人认为结对编程时需要能力的良好匹配。 然而，这是让缺乏经验的开发人员加快速度的一个非常好的方法。
It all depends on the personality of the developers there is no hard and fast rule.
One thing that is certain is that the experienced developer will be less productive when working with an inexperienced developer. I personally think there needs to be a good match of abilities when pair programming. It is however a very good way of getting inexperience developers up to speed.
虽然这是一个好主意，但实际上可能没有用。 要培训某人，您可以组织培训并指派可以提供帮助和指导的导师。 导师可以分配实际项目中的工作并可以进行监督。
如果你想从这个概念中获益，结对编程应该在相对有经验的人之间进行。 在我看来，与没有经验的人结对编程会降低生产力，并且不确定当有人不断检查他时，这个人会学到多少。 分配一项任务并给予独立开发它然后回顾它的机会将提供良好的自我学习。
Although its a good idea but practically it may not be useful. To train somebody you can organize training and assign mentor who can help and guide. The mentor can assign work from the real project and may monitor.
Pair programming should be between relatively experienced people, if you want to get the benefits of this concept. In my view pair programming with an inexperienced person will have loss of productivity and not sure how much the person will pickup when somebody is constantly checking on him. Assigning a task and giving chance to develop it independently and then review it will provide good self learning.
是的，但是使其有效的方法一开始可能并不明确。 结对编程的任务应该是经验不足的程序员（我们称他为迈克尔）的任务。 我还会让 Michael 开始结对编程课程，以解释该课程的目标是什么。 这种方法让迈克尔处于主导地位，而更有经验的程序员（我们称他为比尔）将扮演更多的指导角色。
通常，比尔会承担或接受更复杂的任务来完成。 这种方法使Michael能够从事更适合其经验水平的任务。 我建议首先每隔 30 分钟到小时关闭一次，以便 Michael 能够习惯将控制权交给其他人的过程。 您可以慢慢地将这些关闭时间间隔缩短至 15 分钟或对两个开发人员最有效的时间间隔。
Yes, but the approach to make it effective may not be clear at first. The task that is being pair programmed on should be the task of the less experienced programmer (We will call him Michael). I would also have Michael start the pair programming session so as to explain what the objective of the session is. This approach puts Michael in the drivers seat where the more experienced programmer (We will call him Bill) will serve more of a mentoring role.
Typically Bill will either take or be given more complex tasks to work on. This approach allows Michael to work on tasks that are more suited to his experience level. I would recommend switching off at 30 minute to hour intervals at first such that Michael can get used to the process of giving someone else control. You can slowly shorten these switch offs to 15 minute intervals or whatever works best for the two developers.
我认为你得到的最终结果取决于这样做的人。 在这种情况下，您可能最终会得到一个领先另一个（而另一个只是注意理解第一个正在使用的语言功能）。
I think that the final results you get depend on the guys that are doing this. In this case, you'd probably end up with one leading the other (and where the other is just paying attention to understand the language features the first one is using).
这取决于我们所讨论的技能阻抗不匹配程度。
两个不同语言的优秀程序员可以通过它快速成长，显然是以当前项目语言的一位专家的速度稍微慢一些为代价的。
相反，如果差异太大（例如，老将和新秀），最好从其他方法开始，以避免产生高度适得其反的风险。
永远要小心极端结对编程！
It depends on how much skills impedance mismatch we're talking about.
Two good programmers in different languages can grow-up quickly with it, obviously at the cost of a little slowdown of the one expert in the current project's language.
If the difference is too big (for example, a veteran and a rookie), instead, it might be preferable to start with some other kind of approach, to avoid the risk of getting highly counterproductive.
Always beware the extreme pair programming !