Software development is often seen as a "man vs machine" endeavour. In reality, it's still people who do the work, a work that often has a clear artistic component. It is work we do with others, for others. And here are some of my thoughts on that

Monday, December 10, 2012

On December 8th, I attended the Montréal edition of the 2012 Code Retreat. It was organized by Mathieu Bérubé, to whom I'm very thankful. He asked the attendees for comments on the event, so here I go.

The format of the code retreat is that during the day, there are 6 coding session, using pairs programming. In each session, we try to implement Conways' Game of Life, using TDD principles. We can use any language or framework we want. Sometimes, only one of the partners knows the language used, and the other learns as we go. For some of the session, the leader also adds a challenge or a new guideline. After the session, we delete the code, and we all get together to discuss the session and the challenge. Mathieu had some questions for us to guide the discussion and to make us think.

The goal of the even, however, is not to implement the game of life, but to learn something in the process. I think we all learned a lot, technically. Some of us learned new languages, some learned new ways to approach the problem. I learned that the Game of Life is easier to solve in functional or functional-type languages, rather than with object oriented or procedural languages. I learned the problem cannot be solved by storing and infinite 2D array. I learned that MySQL has special optimisation for "IN" that it doesn't have for "BETWEEN". I learned a smattering of Haskell.

But that's the sort of things one can learn in a book. What else did I learn, that's less likely to be in technology books? In all fairness, some of the following, I already knew, and is covered in management or psychology books, but those book tend to be less popular with developers.

The clock is an evil but useful master

By having only 45 minutes to complete the task, we can't afford to explore various algorithms and data structures to solve the problem - as soon as we see something that looks promising, we grab it, and run with it, until we notice a problem and try down a different path. In some cases, we even started coding without knowing where we were headed. I would normally think of this as a problem, because creativity is a good thing, and stifling it must be bad. However, having too much time usually means I'll over-design, think of all possible ways, but in the end, I may still rush through the implementation. Moreover, I assume that I'll have thought about all the possible snags that can come along, but some problems only rear their ugly heads after some code is written and the next step proves impossible. Sometimes, it's better to start moving down the wrong path, than to just stay in one spot and do nothing at all.

This is somewhat related the the Lean Startup methodology - test your assumptions before you make too many.

At one point, I asked the organizer to put up, on the projector, how much time remained in the session. He pointed out that it was a bad idea, because when we look at the clock, we're more likely to cut corners just to get something working, rather than focus on the quality of the code. This was a hard habit to ignore!

Let go, and smell the flowers

Since my first partner and I solved the problem in the first session, I was really eager to solve it the second (and third, ...) time around, in part to prove that he didn't do all the work, and I was just there to fix the syntax. But from the second session on, Mathieu gave us particular challenges to include in our coding, from "think about change-proofing your solution" to "naive ping-pong (one partner writes the test, the other does the least amount of work possible to pass the test)". As it turns out, it was really hard to completely implement the solution, writing the tests first, and factoring in the challenge. Something had to give. It was really hard to let go "complete the solution" in favor of TDD and the challenges. Recognizing that this is what I was doing certainly helped me let go, but the drive to finish the job kept nagging me. So much so that when I got home, I just HAD to implement the Game of Life in Scala, because I was so upset I didn't finish during the event.

Another aspect of this is how I interacted with my partners. When I thought I had the solution and they didn't, I just pushed on with my idea, so that we'd get the job done as fast as possible. Rushing means I didn't listen as well as I could have to what the other person had to say. You can't speak and listen at the same time. The point of Code Retreat is not to write the Game of Life, that's been done thousands of times. The point was to play with writing code, try different things, and learn something in the process.

The tools make a difference on productivity

Session after session, it became clear that for this particular problem, a functional approach makes more sense than a procedural or object-oriented one. While we can use functional programming concepts in most languages, functional languages make the task much simpler. Even though we struggled setting up the test environment for Scala, we got further than with procedural language, because once started, we just added a test, added an implementation - everything seemed to work almost on the first try.

Another tool that affected productivity is the editor. I'm not advocating for any particular tool, but in all the sessions, we used one participant's set up. Whoever's setup that was would edit so much faster. When using someone else's computer, I quickly got frustrated because I would type some editor command, only to realize that it's the wrong way to do what I want on that editor, or I had to slow down to avoid such mistakes. This happened even though I knew how to use the other person's editor. It may have worked better if we had used something like Dropbox so we could each use our own computer, but given that IDEs tend to organize the source/project differently, it may not have worked either.

I change depending on the personality of my partner

Each team I was on had a different dynamic. This was due in part to the challenge proposed - ping-pong tends to do that, and in part to the personality of my partner. It is likely that they also took cues from my personality as well, particularly since I was generally outspoken between the sessions, so I did not necessarily get to know them well in the process. I tend to avoid being the leader of a group, but I'm also impatient. At the beginning of a session, the my partner didn't suggest something immediately, an approach, a language, etc, I'd propose something. This means that more often than not, I imposed my will on the other. I should have listened more to my partners, and I might have, if I hadn't been so intent on finishing the problem in the 45 minutes!

Deleting the code

One of the instructions in the Code Retreat is that after each session, you delete the code. This was hardest to do, the closer we got to finishing the solution. It was particularly difficult in the session when we wrote in Scala, because after the initial fumbling with the test environment, the progress was steady and fast. If only I had another 10 minutes, I'm positive we could finish! Surprisingly, the working code in MySQL was very easy to delete, possibly because it felt complete, done, over with.

All in all, it was a useful, interesting and fun experience. I highly recommend it to any programmer!