• A Set of Unit Testing Rules, article by Michael Feathers
• Red-Green-Refactor, article by Jim Shore
• Mocks Aren’t Stubs, article by Martin Fowler
• The Decline and Fall of Agile, article by Jim Shore (rescuing Scrum Teams).
• Original TDD as if you meant it exercise
• TDD as if you meant it exercise repeated at Alt.NET UK day one
• xUnit Test Patterns: Refactoring Test Code, Gerard Meszaros, ISBN 0131495054, Addison Wesley 2007. Also see the accompanying web site.
• Exploring Requirements: Donald Gause and Gerald Weinberg, ISBN 0932633137, Dorset House 1989

Many of these ideas are explored in more detail in my TDD in practice course, which will start from September at Skills Matter.

The exercise involves developing a very simple piece of code strictly adhering to the TDD rules, so much so that participants aren’t allowed to create domain methods or classes other than extracting them from test code. The goal of the exercise is to demonstrate factoring out just what you really need from the test code into domain design rather than starting with a pre-set design structure. Although this is in general taken as a goal of TDD, many programmers (me included) don’t realise how much their assumptions make them jump ahead too quickly. By making it very painful to add new domain code, this exercise slows participants down to a point where people have to spend a considerable amount of time actually focusing code on exactly what is required and no more.

Even on a very simple problem such as tic-tac-toe, differences from a pre-conceived design and the one that emerges from code are considerable, the latter being a lot more elegant and better suited to describe a problem.

The exercise

The original exercise involved stones and the Go game. As I’ve never played that before and we had a lot less time than in the original one, I suggested tic-tac-toe. This turned out to be a very good idea as we spent less time explaining what the domain but it still proved the point of the exercise.

The requirements on the flip-chart were the following:

• a game is over when all fields are taken
• a game is over when all fields in a column are taken by a player
• a game is over when all fields in a row are taken by a player
• a game is over when all fields in a diagonal are taken by a player
• a player can take a field if not already taken
• players take turns taking fields until the game is over

The dynamics

All the participants worked in pairs. Most of the teams started by building a 3×3 board and describing requirements that were not given at all (eg first player won, tics or noughts being placed) and took three or four attempts at describing the problem to really go down to basics. As predicted, people were annoyed by this but I did make an effort to explain that the start of the exercise feels silly and annoying so this went much better than I expected. After the first requirement was done correctly, the next three followed easily as they are fairly related. The fifth one though posed a problem again and this is where things got really interesting, some teams falling back on the grid idea (and getting their code deleted) and some teams starting to flesh out the concepts of players and the actual dynamics of fields being taken.

By the end of the exercise, almost half the teams were coding towards something that was not a 3×3 char/int grid. We did not have the time to finish the whole thing, but some interesting solutions in making were:

• a bag of fields that are literally taken by players – field objects start in the collection belonging to the game and move to collections belonging to players, which simply avoids edge cases such as taking an already taken field and makes checking for game end criteria very easy.
• fields that have logic whether they are taken or not and by whom
• game with a current state field that was recalculated as the actions were performed on it and methods that could set this externally to make it easy to test

Most of the game classes had very nice explicit methods for checking different game end criteria. During a short retrospective at the end, some participants said that their code was very nicely isolated and encapsulated, with “less leakage than normal”, and that very explicit specifications ended up in the code making it easy to understand.

Multiple models

This exercise reminded me again about Eric Evans’ introductory presentation to domain modeling. One of the basic ideas there is that the best models are not the most realistic ones but the ones that allow us to describe a particular problem efficiently. The best models are good because they serve a particular purpose in a particular context, so a bag of fields might be a better model of the tic-tac-toe game than a 3×3 board even if the latter feels much more realistic and natural.

Conclusions

In my view, this exercise worked really well. It was interesting to observe it from a different perspective (this time I got the role of the annoying git who went around the room and deleted code that people wrote and did not need). Tic-tac-toe was a good choice as it did not require spending time on explaining and comes with an almost guaranteed 3×3 pre-conceived model. Some participants suggested that we should have done requirements 5 and 6 first and then moved to 1-4. Although this would take away the big refactoring moment, it might actually work better to allow people to factor out a very different model straight from the start. Introducing that the exercise is a bit annoying at the start was also a good idea, as I think that it went smoother than the original one with less opposition to dropping unnecessary code.

You can see some of the code examples on the openspacecode repository. For more information on the original exercise and the rules, see my earlier post about it. Mark Needham repeated the exercise earlier as well, building a message interceptor – something much more technical and practical than a tic-tac-toe or Go game. You can read his conclusions at markhneedham.com.

The event started with Phil Trelford talking about SI system units of measure and how they fit into F# programming – apparently from the next release this language will have static compile-time checking that you’re using metres, grams and units such as that correctly without requiring you to implement a special class only for that. Phil well earned the appluause from the crowd when he launched a lunar lander game developed entirely in F# based on units of measure, the first practical application in F# that I’ve seen.

Dylan Beattie again did a very interesting presentation, this time on web deployment with MSDeploy and Web Platform Installer, two new Microsoft’s tools for web deployment. He started by going through a list of problems that people typically experience when they want to try out an opensource .NET web tool: setting up the correct version of ASP.NET web platform, SQL server, dependencies, configuring web.config, machine settings and IIS. Dylan then showed the Web Plaform Installer Gallery, a very interesting solution that automates installation of popular applications – comparing it to the Apple iPhone AppStore. Web Plaform Installer Gallery has installation scripts for lots of popular web projects so you can just install them with a few clicks. Dylan then explained how MSDeploy and Web Platform Installer work together to provide this functinality and how teams can use them to automate in-house web site deployment and synchronising development, test and production servers deployments.

David Ross presented MPI.NET, a library that helps organise computing clusters for Fork/Join parallel calculations. MPI (Message Passing Interface) is a standard for message interchange and collaboration for distributed processing, and MPI.NET is a wrapper around the original C API that makes it easier to use and exposes a .NET interface. David talked about Fork/Join and Map reduce patterns and demonstrated how MPI.NET helps write those with very little code.

Alan Dean then talked about Openspace coding days, a community project that started in January as a spin-off of the Alt.NET UK conference intended to be more practical. Openspace coding days are organised without a pre-determined plan, where attendees vote for topics of interest and then participate in workshops on those topics. These workshops range from well established technologies and practices to collaborative learning of a completely new technology or tool.

Scott Cowan demonstrated Spark, a view engine that has the advantages of intellisense support, being able to generate HTML using a command line tool and being more readable than ASP.NET tags. Spark uses special HTML elements and attributes and should look much more familiar to people who know HTML than ASP.NET or NVelocity. One of the more interesting things in the demonstration for me was how loops and conditional logic can be attached to normal HTML elements, such as DIV, avoiding the introduction of custom tags.

I presented how Concordion.NET helps us implement acceptance tests in plain English. Concordion.NET is a port of Concordion acceptance testing framework, originally developed by David Peterson and converted to .NET by Jeffrey Cameron. It works on HTML files and uses special HTML attributes to mark inputs and expected outputs of acceptance tests, allowing us to write and manage tests in free-form HTML text. Concordion.NET integrates with Gallio and links HTML documents to domain code using MBUnit-like fixtures. You can download the slides from resources.

The event ended in what is almost becoming a tradition, Sebastien Lambla presenting his Openrasta web framework (and working on the code to present until 10 minutes before his talk). Openrasta started as a REST framework which Sebastien presented at the first exchange, then became a MVC framework (implemented probably during the second exchange) and yesterday Sebastien demonstrated using embedded pre-compilers for ASP.NET and a standalone service, along with a new view engine based on C# with full intellisense support, so I guess OpenRasta is becoming a web server now.

In retrospect, I really enjoyed catching up with lots of people and I look forward to the next exchange. Next time I should really remember to start drinking after my talk, not before, or arrange to go earlier in the schedule.

This mini-conference is free, but up-front registration is required. Last event attracted more than 200 people, so I suggest registering quickly if you plan to attend. Register on http://skillsmatter.com/event/open-source-dot-net/open-source-dot-net-exchange-iii

The line-up so far looks like this:

Ian Cooper: A First Look at Boo

Boo is a ‘wrist-friendly language’ for the CLR that reduces the ‘noise’ of other CLR languages. It’s also a favorite for writing Internal DSLs In this session Ian Cooper will talk about the Boo language from his recent ‘first look’ at the language. As well as covering the basics of why Boo is different Ian will look at the best way for you to get started learning Boo.

Dylan Beattie: Managing Websites with Web Platform Installer and msdeploy

In this talk, Dylan Beattie will show you how to kickstart your web projects using Microsoft’s new Web Platform Installer, and how you can deploy your websites and manage your servers using msdeploy.exe.

The Microsoft Web Platform Installer is a free tool that gives you everything you need to build and host web applications on Windows. It’ll configure your web server and database, install developer tools like Visual Studio and the .NET framework, and supports many popular Web application frameworks including ASP.NET MVC, PHP, Drupal, SubText, WordPress and DotNetNuke.

Scott Cowan: Spark View Engine

Spark is a view engine for the ASP.Net Mvc and MonoRail frameworks. It allows the html to dominate the view in a way your front end developer will love.

David Ross: Introduction to MPI.NET

MPI.NET is a .NET wrapper around the Message Passing Interface which is a used by the majority of super computers and compute clusters for supporting sharing data between compute nodes.

Gojko Adzic: Acceptance testing in English with Concordion .NET

Concordion is an acceptance testing tool that enables developers, testers and business analysts to build executable specifications in free-form HTML. In this talk, Gojko Adzic introduces Concordion.NET, the .NET port of Concordion, and demonstrates it with examples.

Sebastien Lambla: What OpenRasta does other frameworks can’t

Sebastien Lambla will showcase a few strange usages of OpenRasta.

Phil Trelford: F# Units of Measure

The F# programming language has full support for static checking and inference of units-of-measure. In the process Phil show its use with a sample of retro game Lunar Lander.

OpenSource .NET Exchange is a community meeting of .NET enthusiasts held twice a year as part of monthly Skills Matter OpenSource .NET evenings. The Exchange is aimed to be a larger event
where people from the community can network and exchange ideas. The official programme consists of 6 lightning talks (15-minutes each) focused on opensource .NET tools and progressive .NET practices, followed by lots of community time for mingling (and if we find sponsors
free beer and pizza). The previous event in January attracted more than 200 people. (see the event page and reviews
for more information on the previous event). For more information on
Skills Matter Opensource .NET evenings, see
http://skillsmatter.com/go/open-source-dot-net.