Working in a group for programming seems to be like a very friendly way of learning new programming techniques. I feel like most programmers have a very small arsenal of techniques and approaches to certain programming problems. Discussing with other programmers allows a programmer to open their eyes to new techniques and approaches.
I enjoy having a partner at disposal. It allows for so many advantages in coding, testing and debugging.
When coding, there are two general approaches the group can take. If the group can begin working on the code together immediately, they will receive the advantage of being able to conceptually organize their thoughts and ideas on how to approach the project. Otherwise, the group can individually strategize on how to approach the project and try begin coding it on their own. They could then get together afterwards and compare ideas.
The first approach commits more time to the focusing on the project and agreeing on ideas, but may cause a more narrow minded approach since agreements have to be made before programming may begin. The second approach would allow for each individual to map our their own idea and see how well it may work. This would (hopefully) return a range of ideas. With this approach, the group would essentially have to agree on one approach, which may cause planning and programming time to be thrown away.
Of coarse, the two approaches above are the utmost extremes to working in a group that I can think of in terms of planning and preparing to code the project. Once the coding begins, the best approach to take by far is to have all group members focusing on the coding being taken place by one another. Using only one computer is optimal for all group members to understand the code and to make sure everyone is on the same boat. Having multiple computers is nice for speed once understanding the code is no problem.
However, when one group member starts working ahead in a group, thats when the other members feel lost and start having problems keeping up. For this reason, I believe it is key that all members are present when critical coding is being completed. If the other members are not present when more difficult code to understand is being written, their understanding will fade and they will have a harder time understanding the code even for testing.
Having a group for testing purposes is also very nice, since each person almost always thinks of their own unique unit test cases and approaches to problems from debugging. That way, the code can be more protected from crashing and those nasty kind of things.
So basically, having partners for projects helps the narrow-eyed programmer, such as preventing the overlooking stupid mistakes and coming up with possible approaches to a programming problem.