When practicing new programming techniques I am a fan of ping-pong pairing. Ping-pong pairing is a way of pairing with TDD that evenly distributes the amount each programmer spends in front of the keyboard and the amount of test code versus actual code each programmer writes.
The description from the C2 Wiki reads:
Pair Programming Ping Pong Pattern * A writes a new test and sees that it fails. * B implements the code needed to pass the test. * B writes the next test and sees that it fails. * A implements the code needed to pass the test. And so on. Refactoring is done whenever the need arises by whoever is driving.
Two programmers sit in from of one computer, with one keyboard and one screen.
Ping-pong pairing is great in a learning context because it keeps both programmers in front of the keyboard and it encourages conversation.
But, there are a couple of problems. Keyboards and editors! What if one programmer uses Dvorak and the other Qwerty? Or, one programmer cannot even think of writing another line of code without Das Keyboard while the other prefers an ergonomic keyboard? Or, one programmer uses Vim on OSX and the other Notepad on Windows?
Ping-Pong Pairing Over Git
What if we alter the setup to give each user their own computer, keyboard, screen, rubber duck, or whatever tickles their fancy? It would seem that this isn't paring any more! But, if we place the pair side-by-side and let them communicate over Git, we actually get a very nice flow. There is still only one person typing on the keyboard at a time, but they are typing on their own keyboard.
The pattern above is changed to:
Ping Pong Paring Over Git Pattern * A writes a new test and sees that it fails. * A commits the failing test and pushes the code to Git * B pulls the code from Git. * B implements the code needed to pass the test. * B writes the next test and sees that it fails. * B commits the failing test and pushes the code to Git * A pulls the code from Git. * A implements the code needed to pass the test. And so on.
I've tried this pattern on a couple of code retreats and it is actually pretty smooth. To make it even more smooth I implemented a simple command line utility, tapir that allows for simple communication between the two computers and automates the pulling of the new code. It works like this. Each programmer starts a listener on their machine that pulls the code when it receives a message.
# Start a listener on 'my-topic', run git pull when a message arrives tapir --cmd listen --script 'git pull' mytopic
Write a simple script to combine
git push with a calling
#!/bin/sh # ./push script pushes code to git and pings the tapir-server git push tapir mytopic
Now, instead of calling
git push, you call
./push and the code is
automatically pulled on the other machine, eliminating one step from the loop.
Why is the utility called
tapir? Because, pingpong and ping-pong were already
taken and I like tapirs! :).