SPA 2011

Along with some other friends from Caplin, I went to the SPA2011 conference at the beginning of this week.

Web applications a la node

JavaScript turned out to be very popular this year and the first session I went to was on node.js. Node.js is considered a highly performant framework based on its insistence on evented stream processing ‘all the way down’. We used cloud9, which is a fairly impressive web based ide. The part that you as a developer write is in JavaScript which is rapidly becoming more accepted as a server side language. In this case, JavaScript is a fairly good choice because evented io seems to be a lot easier in a language that makes it easy to create closures.

Javascript developers are also used to asynchronous calls and callbacks, and not used to having to worry about threading, which all fits in quite well with the node.js philosophy. We also used a templating engine called Jade (which is a little idiosyncratic in my opinion).

At the end of the day, while node.js is very interesting from a technical point of view – event based might be an good way of writing servers in general – and from seeing javascript extend its reach, I think it’s unlikely I would choose to use it over any of the many other frameworks for building web applications.

HTML5/Javascript Boot Camp

The HTML5/Javascript Boot Camp session was run by some guys from New Bamboo, who also do Pusher. It covered drag and drop, reading files, localstorage and websockets for building a system that shared images. HTML5 has too many aspects to cover in a single session, particularly a practical one, and they said that their main aim was to get over peoples inertia at writing html 5 code.

Test-driven Development From Hell

Jason Gorman ran a session where we did the TDD ‘write a roman numeral converter’ exercise but with the aim of breaking as many of the TDD rules as possible within as little code as possible. I found it a bit harder than expected. Jason claims that being ‘good’ at that exercise requires two things; mindfulness about the TDD practices and an eagle eyed pair. He was particularly keen to make the point that many people were doing much ‘better’ than they realised at breaking the practices but their pair was not paying enough attention to spot it, so the takeaways were the responsibility of the pair and more generally trying to develop mindfulness of the TDD practices.

At the Extremities of Extreme

Last year I did the ‘wolfpack programming’ session run by the guys from Cincom (in Smalltalk). It’s an extremely interesting and fun working methodology that they consider to be ‘at the extremities of extreme’. The environment is essentially a simultaneous collaborative web based ide, where the unit tests are run on every change and code changes take immediate effect. They introduce it as taking all of the agile practices and turning them up to 11 and the whole methodology is based on the metaphor of packs of wolves. However the whole idea does depend on good, specialised tools so it would be difficult to replicate the experiment outside of the smalltalk environment that they have built.

Rant – John Nolan

John Nolan gave a short rant about how software development is not very much like Engineering at all, and that Cooking is a more apt metaphor. He also made the point repeatedly that ‘Software is Software’, and that all the concern with finding good metaphors from e.g. eastern philosophy or western engineering were mistaken, not particularly helpful and somewhat childish. Apparently we aren’t warrior monks on the path to code enlightenment.

Changing the industry by changing education

Apart from bemoaning the fact that undergraduate study at universities tend to produce people who don’t know TDD or about the existence of source code revision control systems (or sometimes even the ability to program anything), and also worrying that the teachers who teach computing at an earlier level are crushing the enthusiasm to program out of children, we also heard from someone who has (with great difficulty) introduced a 40 hour a week masters degree course in the USA where the students work on real agile projects for paying customers from day one while simultaneously learning the skills they need to work well in software. There was also some debate on the relative merits of Computer Science (I’m fairly keen on at least some CompSci), and an idea that companies with enthusiastic programmers should consider it part of their CSR to encourage them to visit local schools to enthuse the children.

Treating Javascript like a full programming language

Rich and James from Caplin ran a session that, considering the level of interest in Javascript and also the confusion over how to do it well, seemed very timely. It was extremely well attended, and was also very interesting. I think lots of people were interested in the idea that design patterns (such as MVVM), and TDD and other modern techniques and tools were applicable in javascript.

Rant – Keith Braithwaite

Keith humorously characterised software development in London in a way that got a lot of wry smiles of recognition (you’re working for a bank and you have to write some software to take some numbers from one system and add them up. However, for political and compliance reasons you’re not allowed to add them up yourself, you have to send the work to ‘the compute grid’, which only accepts data in a format that is exactly like XML but with the angle brackets reversed and all numbers have to be in base 13….). He contrasted the ‘stress’ level of what we do with the life of a farm worker (his father) or the life of a domestic servant (his mother).

Double Loop Learning

Benjamin Mitchel did a presentation on dealing with conflict based on the theories of Chris Argyris. I found the presentation a bit disjointed and rushed but it did cover some very interesting ideas about the proper way to deal with conflict. The title ‘double loop learning’ comes from not just changing our actions when we realise we need to improve but changing the mindset behind the actions. He was also very negative about the technique of ‘easing in’, where you try to get the person you’re criticising to guess the criticism you intend without you actually having to say it, and other forms of deceptive communication which are often ineffective.

One practical suggestion that I found very interesting is that generally speaking when we approach a situation of conflict we try to communicate our high level, abstract ideas but it’s better to start by communicating the observations that they are based on, moving up the ‘ladder of inference’ and checking at each step if the other person agrees. (ladder of inference: data -> selection of data -> ascribing meaning to the data -> assumptions -> conclusions -> beliefs -> actions).

Developer Anarchy at Forward

At Forward they have a very flexible and responsive working environment. They claim to have done away with managers and the traditional product management roles in favour of a much more developer led system, based on giving the developers visibility on live, responsive business value data (around the number of people visiting the site, number of click conversions, etc) and continuous deployment.

They make it extremely easy for developers to follow their own ideas, but everything anyone tries receives feedback about real business value very quickly. They also offer 20 days of ‘innovation leave’ a year, where the developer is free to persue an idea. They don’t have to say in advance what they are going to do (in case they change their mind), but they do have to demonstrate it afterwards. It sounds like a very responsive and productive environment, based on the idea of making failure cheap and having as much as possible rooted in real data (even whether to fix a specific bug or not is based on whether it will measurably improve the bottom line).

Lightning Talks

We had a guy suggest that everyone eat porridge at lunch as a way of avoiding sleepiness, plus a number of companies trying to recruit. It seems that there is a shortage of good developers at the moment.

Web Apps That Shine

This session was run by myself and Ian. Naturally it was the highlight of the conference. Lots of people were impressed with the html based presentation that Ian wrote for this session incorporating interactive elements with the presentation itself. You can access the presentation and code examples at

Rant – Slow and Dirty

Jason Gorman showed us some interesting graphs and industry data that showed that for the vast majority of development teams, spending more time on quality would result in faster delivery.

Whatever Happened To…?

Run by people who had been at SPA and other conferences 10 years ago or more, we had talks from people who had been at the forefront of Subject Orientated Programming (now pretty much dead, although traces of it can be seen in AOP), Software Reuse (achieved in a much reduced form compared to what was imagined), Design Patterns (changed the world, but not quite as positively as they’d hoped), and OO (complained about the number of ‘objects’ floating around with only data, or only behaviour).

There were lots of other sessions that I didn’t get to, and some interesting ‘diversions’, such as learning the board game Go, and hearing from the government on their plans for agile projects (something that generated enthusiasm and skepticism in nearly equal measure). Overall, it was an excellent conference, full of interesting people.

Leave a Reply

Your e-mail address will not be published. Required fields are marked *