XPDay6 - better than ever...

XPDay6 is nearly over, and it's been great.

One of my favorite sessions was Clarke Ching's Embracing Change: An Introduction to Agile Software Development. Clarke has given similar presentations at XPDay for several years. They've all been good and they keep getting better.

Another was a goldfish bowl session Facilitated by Nat Pryce and Jonathan Clarke asking Why Is Simple So Difficult?

It's hard to define simplicity; it's much easier to define or detect complexity (and then avoid it).

Lots of good ideas in the session; I liked Joe Walnes' comment that you shouldn't do the simplest thing - you should have the simplest thing (but it may be very difficult creating that simple thing).

I introduced Roy Sykes' 3am rule. This defines what I call simple code. It's the sort of code you'd hope to find if you have been called out of bed at 3am to fix a critical defect in production code.

My favorites session today was on LiFT - a framework for literate testing. It can be used as an alternative to FIT, but it can also be used to implement readable FIT fixtures. I'm hoping to give it a spin on my current project.

I really enjoyed the pub session afterwards. (Thanks, Google). Quote of the day - to Angela Martin, as she was taking photos of us all:

"I see you're taking a picture of me while I'm sober. I hope you have a fast film."

Ah well - off to the Old Bank Of England in Fleet Street for the post-conference Extreme Tuesday with more free drinks - thanks, Kizoom!

Factory methods can improve readability in embedded DSLs

Nat Pryce has just got rid of lots of explicit object creation from the interface to GetInLine; the embedded Domain Specific Language now reads much better.

No new()s is goood news, in fact!

Facts and Fallacies of Software Engineering

I've just read Facts and Fallacies of Software Engineering and I love it.

My mate Bryan Dollery lent it to me after a chat in the pub about developer productivity. (Don't look so surprised. I do go the pub occasionally).

The book confirms many long-held opinions, and offers a lot of hard evidence ato support them. In particular, it spells out why a few skilled (and therefore expensive) developers can deliver business value much faster than a larger, less skilled team.

I've started to write a couple of short articles on themes raised by the book. Watch this space.

And thanks, Bryan, for an excellent read.

Ruby and Amazon Web Services

I've been ill at home for the last few days, but today I felt well enough to play a little. I built a really useful little command line application in Ruby. It's already saved the time it took to write it.

It expects to find an ISBN in the clipboard. It checks that the ISBN is valid, uses the Amazon Web Service interface to get book details from an ISBN, and pastes the details to the clipboard, complete with an Amazon affiliate link. (If you buy the book after clicking on the link, I get a little money).

A variant does the same thing, but copies the book details in a format ready to paste into TiddlyWiki which I use as an personal blog/wiki.

I found out how to parse XML in Ruby by reading Enterprise Integration with Ruby. (You can guess how I created that link, can't you?)

Here's the Ruby code. To use it you will have to sign up for Amazon web services (if you haven't done so) and insert your access key into the code.

Ruby rocks.

GetInLine at SourceForge

The GetInLine file processing DSL is now hosted at SourceForge. Code is in cvs and I've released an initial version (0.0.9).

Here's a sample test case that will give you a feeling for how to use it.

Brain Quadrants updated

I'm still fascinated by Ned Herrmann's Brain Quadrant Theory.

My colleague Chris Pollard points out that my earlier blog post never listed the four core types of thinking in Herrman's model.

Here they are:

• logician
• organizer
• communicator and
• visionary.

For a good introduction, read Herrman's overview (pdf).