Archive for the ‘agile’ Category

Card Of The Day: Actually Do Retrospective Actions

Thursday, July 22nd, 2010

Current cards of the day at eden

Our current Card Of The Day board at Eden

Retrospectives are something we’ve been doing regularly for quite a while at Eden, but we’ve hit a problem. It’s very easy to come up with a great list of actionable items, and then very easy never to look at them again. Don’t tell me you’ve never done this :)

We’ve started doing something slightly different at Eden to try and stop this happening: we’re using a method we’ve called Card Of The Day.

When the retrospective is finished, we take all of the cards with SMART action goals and put them on our company kanban board to ensure they’re done. Then we take all the cards that are a little more hazy (the sort of cards that say: “Be better at X”), we pin them up on the wall, and every morning after standup we read one out at random to the team.

Normally this has a “ahh, yes” effect on the team. Sometimes it generates a conversation, sometimes an action we hadn’t thought of yet and something else to go on the Backlog. There’s always something that comes out of it.

It’s not a perfect method, but it’s working better than the alternative: feeling guilty at the beginning of the next retrospective about all the terribly important things we haven’t done.

Have you tried something similar? Or do you have an alternative way to remember to do retrospective actions?

Radiating status at Eden

Monday, March 22nd, 2010

Information Radiators are always a good idea for software teams, and I’ve been pondering how best to show project state at Eden Development for a while.

Here are the various iterations we’ve been through:

Iteration 1: Build status messages

We’ve had a continuous integration server running on integrity for several months, and we wanted to make it obvious how we were doing, so we got an old mac mini out and plugged in a big monitor. That way everyone could see whether our builds were passing or failing. We set the mac to come on at 9am and turn off at 6pm in System Preferences, and used Plainview to display full screen.

This worked well, except that our builds don’t fail that often: our current projects have short enough builds that developers can still get away with running all the tests locally.

Iteration 2: Enter the cycling metric_fu graphs

We have metric_fu running on a private site anyway, but the stats weren’t very visible. Wouldn’t it be cool if we could see our code stats publicly across the whole company? So we split the screen into two halves using a frameset:

Our status board

Each of our projects now cycles through the most important pages from the metric_fu library, for each of our live projects. That way, if there’s a big change in the graphs one day, everyone can see that there’s a problem and can dive in and fix it.

Iteration 3: Cramming more stuff in

So far so good, but we had some blank space down the bottom left! So we shoehorned in part of Pairyapp’s interface, so that everyone could see who was working with who.

This was nice, because people can suddenly see who’s working on a task on their own, and then jump in as needed. It stopped me trawling round the office just to find somebody: now I can easily see exactly who’s doing what (picture at the bottom).

Iteration 4: First pass on our own build server dashboard

This worked well, for about ten days…

…until we saw this. Our little solution was immediately not good enough and I set to work on make it shinier.

At about the same time we changed to using CI Joe for building our projects. The way we got that working is detailed here.

CI Joe doesn’t come with an integrated dashboard, so I set to work writing my own. Here’s where I’ve got to so far:

My dashboard app

It’s not open source yet, but I plan to make it so soon. The pictures are of the person or pair who made the last commit.

Iteration 5: The final result

And here’s how our screen looks this morning:

The final result

(sorry about the censorship)

It’s not finished yet, I’ve plenty more plans. Expect another few posts on this in the future.

UPDATE: Added link to CI Joe post and explained pictures on the dashboard app.

The Story Card Is Not The Story

Thursday, February 11th, 2010

At Eden we’ve used a number of different options for tracking work to be done on projects. In the early days we used Basecamp tasks. We then rolled our own system, which we’ve since abandoned due to a gradual shift in our business practices. We’ve used Pivotal Tracker extensively. Whilst we still use Tracker a fair amount, on one of our new projects we’re currently using index cards stuck to a kanban board, with Google Wave for extended documentation and discussion.

In the past, we’ve spent a bunch of time arguing about which of these devices better and which is worse, with a view to settling on the “best” system. The merits of simple systems over complex ones, and digital over analogue, have been endlessly debated. I now think that all of these arguments miss the point.

A couple of weeks ago, Enrique spent some time teaching us an early version of our one-day agile workshop. Through the ensuing discussion, I finally got to an important insight about what a story actually is, or rather what it isn’t.

The story is not the terminology, or which precise language you use to describe it. It’s not the text on the card at all in the fact, or even the card itself. It’s not the line in Pivotal Tracker and it’s not the task in Basecamp.

All of the tools we use represent some facet of the story, and help kick-start discussion. They remind us of the story, but they are not the story itself.

The story is simply the team’s understanding of the work to be done: nothing more.

This understanding reframed my view of the endless cards vs online vs Tracker vs everything else debate. These are merely useful props: methods of communicating within the team in order to achieving shared understanding. Granted, some tools are better than others. But they are just that: tools. Nothing should be sacrosanct: we should feel free to replace tools and methods that are failing for a particular client, even if they’ve succeeded on other projects. I now think settling on the “best” system is a vain exercise: we’d spend our time much better simply by properly listening to the customer and doing what they say.

The same principle applies to the almost-as-endless UX/Design communication methods fight. Should we use Balsamiq mockups, or HTML wireframes, or Photoshop mockups, or Sharpies and paper? Answer: use what works. Use whatever tools you need to get your message out into the collective consciousness of the team (that includes developers, designers, testers and customers), so that the work can get done to the customer’s satisfaction. These methods are simply ways of getting messages across: they have differing emphases, and carry different risks.

Often I think the whole way we approach the tools debate is wrong. We ask: “how can we use our favourite tool/method to track the metrics for this project?” Shouldn’t our question instead be: “How can we ensure we are communicating properly with the customer so we can deliver what they really want?” The tool question then becomes secondary and the critical issue of good communication becomes paramount.

The story card is not the story. Let’s ensure our projects serve the customer rather than our favourite tool.

Pairing works for everything

Wednesday, January 27th, 2010

We’ve all heard much discussion and general chatter about the value of pair programming. Amongst other benefits, it focuses the mind, speeds knowledge transfer, and builds in code review.

What’s not talked about so often is the value of pairing on non-coding tasks. Does it add the same level of value? Many of us would naturally pair up on demanding tasks, when we are doing things that require the input of several people, or when we’re unsure about how to proceed. What happens if we make it an explicit part of our day to day work? What benefits would we see?

I’ve been trying where possible to pair explicitly on tasks at Eden in the last few weeks and to encourage others to do the same. We’ve found the following so far:

Pairing works on UX and Design. Spencer is currently teaching User Experience (UX) and Design skills to a number of people internally. Pairing on UX and design work really helps people to pick up skills in a particular tool such as Photoshop, but also drives discussion about design and flow which wouldn’t normally have arisen. We’ve found the result to be better output, and an increased confidence in the person who’s less experienced.

Pairing works on Sales and Business Development. Last week I paired up with Richard, one of the guys I’m mentoring at the moment, to send some sales emails to three or four potential clients. One of these was to a potential new customer who I knew was interested in speaking to us, but whom I’d not emailled before. In explaining my reasoning for the words I was writing, he was able to learn about how to structure emails such as this, and I got valuable insight into how I should approach the task from someone with a different point of view.

Pairing even works on VAT returns! When you’re doing necessary and repetitive tasks such as the preparing the quarterly VAT return, it really helps to have someone beside you spurring you on. Last month I had to prepare one of these returns, and half-jokingly asked whether anyone was interested in helping me out. Thankfully, Elliot stepped up to the challenge. He started learning which expenses fall into the four or five VAT categories that exist, and how to prepare and submit a return online. Just by explaining the vagaries of EU, exempt, zero-rated, and outside-scope expenses to someone else, the job went much quicker, all the figures were double-checked, and it was simply much more fun.

Clearly pairing isn’t going to work all the time. People often need space from others to think, to avoid distraction, and to recharge. Rather than being dogmatic, what I’m asking is this: at the moment non-pairing in our work is the default, and pairing is the exception. What if this was reversed? What difference would this make to our teams?

Next time you approach a non-coding task at work, perhaps have a think about whether a pair would be beneficial, or what someone might learn through working with you. I could well be wrong, but I’ve yet to find a task where pairing doesn’t add some benefit. Can anyone think of one?