Austin TDD CodingDojo Complete

On Saturday morning, February 9th, 2008, on the frozen tundra of Lambeau Field, 20+ geeks descended to explore what TDD was all about. Ok, it wasn’t frozen, nor tundra, nor Lambeau Field, but it was Feb. 9th and we were all geeks and it was good.

Overall, I’d like to say: The event was a great success, but the CodingDojo was a failure. We talked a lot about TDD, we actually got a few minor things accomplished via code, clarified a lot of concepts that were a little cloudy in people’s minds (like mine), and opened a few people’s eyes who hadn’t been experience to a lot of TDD — especially the style we used.


We started out — late, in true geek fashion — by doing some introductions and what our experience was with TDD and what we hoped to get out of this event.  Then, the project was revealed: Mathinator.  A dirt-simple command-line based basic math flash card app.  We had a few user stories to kick things off, then spent some time discussing the requirements, clarifying, and expanding on concepts.  We then went right to the code.  This turned out to be a mistake, unfortunately. We should’ve, at this point, spent more time talking about an up-front design.  I felt that things were late already and we had spent a lot of time not talking about TDD or code and that people’s time was being wasted. It turns out that they probably would’ve appreciated spending more time up front talking about design. Mistake #1.  In the future, we should get started quicker and spend more time on design before jumping into code.  The socialization is definitely important, but I think we could’ve spent the whole time talking about various topics (including TDD) and never ended up writing a single line of code.

We drew names from a basket and, I swear it wasn’t rigged, I was one of the first ones.  Tim Hardy of the Fellowship Tech crew (they drove down from Dallas to be there at 8am! God bless ‘em!) was also chosen.  We started out discussing the mechanics of ping-pong pairing.  He told me he wasn’t an expert, but he picked up real quick and we were off coding.

And then the discussions started… These were awesome, but they ended up totally blowing the whole ‘CodingDojo’ part of the event. Many in the crowd commented, asked questions, and many good conversations happened — simultaneously. It was glorious and terrible at the same time. Lack of self control on my part (#1) and crowd control (#2) led to a generally rowdy event where many discussions happened — all of which were wonderful and necessary and thought provoking, but totally confusing to anyone there trying to get serious about learning TDD.  Mistake #2.  Someone is going to have to be ‘Mr. Dick’ next time we do this to keep the thing focused and try to offline or break out these stellar conversations so that the event stays on track, but that the conversations and ideas don’t get lost forever.

I think most people there would agree with me when I say: I wish I could have attended both events going on there that day, simultaneously.  We need to have an event where all we do is just discuss TDD, BDD, design, and such and have a computer near-by just in case it comes to down to JSMTFC. Then we need to have an event where we practice some of the outcomes of the previously mentioned event and we will have (hopefully) got all our arguments shaking out of us and we’re down to fingers-on-keyboard.

I’m seriously thinking of hosting a discussion event, panel, whatever you want to call it on TDD and get these folks together for a bigger discussion on TDD practice and theory. And I’d like to try to do that soon while it’s still fresh in people’s minds. I’d like to get people more familiarized with these concepts so that the next CodingDojo, we can maybe spend more time on the ground running.

I might consider doing a TDD 101 the day before the next CodingDojo for folks who’d like to get up to speed quickly and join the fray with at least one feather in their cap. Would this be useful to anyone?

Anyhow, thanks for everyone who attended/participated/contributed, sorry for everyone who couldn’t. Below are some links from the event in case you were curious:

About Chad Myers

Chad Myers is the Director of Development for Dovetail Software, in Austin, TX, where he leads a premiere software team building complex enterprise software products. Chad is a .NET software developer specializing in enterprise software designs and architectures. He has over 12 years of software development experience and a proven track record of Agile, test-driven project leadership using both Microsoft and open source tools. He is a community leader who speaks at the Austin .NET User's Group, the ADNUG Code Camp, and participates in various development communities and open source projects.
This entry was posted in CodingDojo, TDD. Bookmark the permalink. Follow any comments here with the RSS feed for this post.
  • Chad, thanks for sticking your neck out and blazing a trail. The rest of us benefit from watching you learn. Sounds like the event was beneficial, even if it didn’t meet your expectations.



  • Chad, despite all the necessary distractions the event was awesome. Just think how much better the next one will be. ;-)


  • I think a TDD workshop is another format to consider in the future (which I’d be happy to help with). We had a little bit of “too many chiefs” syndrome. At the very least, everyone left with exposure of TDD done by people that have used it successfully.

  • @Chad – I wouldn’t say the event was a failure because I personally got a lot out of it (it’s all about me you know). Seriously, I think it was great because it’s the first step towards putting together a truly awesome event. Having a slightly chaotic dojo is much better than having no dojo at all. Now that we have that first one out of the way, we have a better understanding of what we want to accomplish and how to get there. Thanks for kicking this thing off! I’m ready for the next one.

  • Great work Chad!

    I think the fact that you’re being honest with yourself and retrospecting is another thing we can all take away here. Plain-and-simple, it’s how a good agile team works.

    I hope we can take this form and move it forward, learning along the way.

  • Aaron Eastburn

    I have to agree with Ray. It didn’t seem like a failure. After all, we all got to see that we struggle with very similar questions when it comes to doing TDD. We also got to see the way that people who do TDD every day approach the same problems. A failure would have been only 8 people out of the 30 showing up.

  • Tim Hardy

    I got a lot out of the event as well. It was great meeting all you TDD experts and just being exposed to your ways of thinking. We are very eager to learn more about how to acutally apply TDD now that we’ve been “exposed”.

    As to any rough spots in the event, it was just iteration One, as people have already said. Thanks a lot for putting the event together.