ACCU 2011 Conference
This year’s ACCU conference (my fourth) was always going to be a little bit different because this year I was going to be speaking. That meant no stupid late nights staying up in the bar chatting with my fellow ACCU members and other like minded individuals about programming because I was a professional and I had a job to do…
I arrived on the Tuesday evening just in
time for the obligatory visit to Chutneys - an Indian restaurant in the centre
of town. Many of the usual suspects were already there and it took no time at
all to slip into idle chat about what we’ve all been up to since we sat in the
same restaurant a year ago. Then it was back to the bar and a chance to catch
up with the late arrivals and gatecrash a few conversations in an attempt to do
a little networking before a nice early night. What a ridiculous notion. Of
course I ended up in the bar until
The opening keynote on Wednesday morning was from Giles Colborne, titled Advanced Simplicity. As someone who is a backroom boy these days I don’t spend any time doing UI work, but the talk seemed to transcend that and provided perfect analogies that could just as easily be applied to API design. He provided some nice examples of how you can avoid a whole class of potential error scenarios by just using a simpler control in the first place. There were also examples of ideas that you would expect to work, but didn’t, and cases where people used the tool in ways the designers hadn’t anticipated. Some quotes from the likes of Donald Norman and Alan Cooper provided a nice backdrop.
That was the easy bit out of the way and a shot of coffee was then needed whilst I spent the 30 minute break trying to decide between 5 typically awesome sessions. Sometimes you just have to use darts, dice, a coin or whatever because the line-up is so varied. For my first session I chose Peter Pilgrim’s Introduction to Scala. I don’t generally follow the Java world but I have heard interesting things about Scala and Peter’s introduction was a whirlwind tour of the various language features. It has elements of functional languages that I’m not used to but his examples still made sense and he finished off with a nice comparison of the various JVM based languages that seem to be vying for the hearts and minds of developers.
The 90 minute lunch break is quickly over when you’ve been nattering away and it was Lisa Crispin and her Dealing with Defects talk that filled my early afternoon slot. This was an interesting look at the techniques and tools that teams often use to track and manage bugs. There was definitely a feeling that many organisations spend too much time on tracking and managing bugs and not enough on preventing them in the first place. Lisa got the audience to do a little exercise where we played the role of developer and tester. The two had to collaborate to draw a simple map, first standing back-to-back and then facing each other. This illustrated how much better it is for the two to engage directly instead of via, say, email – simple but very effective. This was a useful talk that helped to confirm my team are heading in the right direction.
I made Kevlin Henney’s talk about OO as my final choice for the day because I saw his Value Objects session last year and I clearly still have much to learn about OO even after all this time. He didn’t disappoint this time either as he slowly managed to show that the SOLID principles rest on flaky ground, ending up with just SID! However I got the feeling that the Single Responsibility Principle (the S in SOLID) should also be taken under advisement. His revelation about the Liskov Substitution Principle was most enlightening and goes to show that the terms type, subtype, class, interface, abstract data type, etc. are often banded about and incorrectly used interchangeably in OO circles. The question now is whether I still answer “Encapsulation, Polymorphism and Inheritance” in a job interview?
Sadly Uncle Bob couldn’t provide the closing day’s keynote and so Michael Feathers stepped up to the plate instead. This was a curious keynote that I felt never really went anywhere. He commented on the productivity of Ruby and noted the verbosity of C++ but never appeared to come to any conclusion. Was he suggesting the world would be a better place if we all switched to Ruby? Did the fact that there were so many C & C++ programmers in the audience cause him to refrain from saying what he really wanted to? If nothing else it generated chatter in the bar after…
Tom Preston-Werner, one of the big cheeses at Github, opened business on the Thursday morning. On the one hand it’s nice to see that some companies can provide an excellent place to work, but on the other there is a large degree of smugness that goes with this kind of presentation. Unmetered holidays, self organising teams, a bar on-site, and they’re making a profit too - it sounds like programming nirvana. It sure will be interesting to see how it scales with the age of the employees and the size of the company.
My first optional session for the day was titled Distributed Computing 2.0 by Filip Van Laenen. I wasn’t sure what to expect from this as I didn’t really read the blurb and therefore was somewhat surprised to hear the details of his hobby project that used Twitter as the communication channel for a distributed system. This immediately raised many questions in my mind about scalability and reliability and he answered nearly all of them during his talk as he explained how Facebook and Yahoo/Google Groups could also be used in a channel bonding style. The problem he is attempting to solve fits nicely inside the limits of the architecture; ok, so it’s not a general purpose solution, but he never claimed it was. I soon started thinking about how to use the add-on services like yfrog and twitpic to overcome the message size limits so it’s clearly had some impact.
I suppose I didn’t really have a choice about what I was going to see in the afternoon. Given that I had stayed up in the bar into the wee hours Tuesday night to listen to an argument about equality I just had to go and see Roger Orr and Steve Love cover the subject in detail. This focused mainly on the pitfalls of how to correctly do an equivalence comparison in Java and C# as there is much complexity involved. C# has a plethora of interfaces for dealing with equality – more than I knew. They also showed some really ‘interesting’ behaviour around the way one JVM caches the boxed values -100 to +100. It’s not often that people remark how simple C++ is, but in this case it really is and the wording in the standard backed that up.
I felt I needed to hear some hard-core techie stuff at some point and so Scott Meyers was the perfect choice with a session all about CPU’s and cache lines. Scott is an entertaining presenter and he made the low-level topic easily understandable. Although I was aware of many of the symptoms and solutions from Herb Sutter’s writings I gained a much better insight into the hardware side and why these problems exist. I have much more respect for the chip designers now! He also briefly covered Profile Guided Optimisation and Whole Program Optimisation to cover the instruction cache side of things.
Lightning talks – 5 minute talks by the general populace – made their appearance again this year and their popularity is clearly growing as the number of speakers approached 23 over the two days. Olve Maudal kicked off the first set of talks with a tongue-in-cheek piece called Technical debt is good! Other notable shorts include Pete Goodliffe’s Manyfestos, which was a poke at the ever growing number of developer manifestos out there, and Mark Dalgano’s Optimise for Unhappiness which reflected back on the day’s keynote to show how too many companies treat their employees.
Friday’s keynote was due to be given by both authors of the hugely popular book Growing Object Orientated Software, but unfortunately it was left to Steve Freeman to go it alone. The title, Good Enough Is the Enemy of Better, sums up perfectly how software development is often approached in many organisations. But Steve showed how it can be a false economy and that doing it right can pay dividends both from an operational and maintenance perspective. As someone who is currently working on a system built this way it’s great to be nodding in absolute agreement instead of longing to be taking part.
The morning coffee break was swiftly followed by a visit to see Jon Skeet discuss Java and C# - the lessons learned and mistakes replicated by the latter from the former. Jon may be a Java programmer by day and C# hobbyist by night, but he still knows way more about C# than most! The discussion about the differences, such as the handling of generics was typically enlightening as was the curious adoption of much of the Object behaviour and how that was probably a bad choice. I left somewhat disappointed as I had hoped for more crystal ball gazing and the answers to some of his questions where clearly already in “C++” and “D” which just goes to show how hard it is to keep up with even the “curly brace” languages.
The weather really brightened up for lunch and it was somewhat of a shame to be stuck indoors in the afternoon, but if anyone is ever a ray of sunshine it’s Tom Gilb. I thought I should go to at least one “process” related talk and the contentious title “What’s Wrong With Requirements” sounded like it could generate some debate. Tom’s premise always seems to be that everything can be measured and quantified and this was no different. What seems to be wrong is that we use “woolly” terms instead of backing them up with a measurable value to guide the design and implementation. A simple message but fairly well rammed home with plenty of entertaining anecdotes and tangents that only Tom seems to get away with.
I really had no option about what to go to after the break because I was one of those going to be doing the talking! It was a great experience that I felt went pretty well, even if I did speak a little too quickly. Interestingly however feedback suggests that I need to do work in other areas instead; such is the problem with not being able to watch yourself. The good thing is that I have 12 months to work on my presentation skills before next year.
The second round of lightening talks followed the day’s final coffee break and once again it was a packed with speakers. Didier Verna is clearly in the wrong job and should be “treading the boards” as he appeared again – twice. Richard Harris rose to the challenge from Roger Orr and Steve Love by showing us how to correctly compare floating point numbers and Jim Hague tried to drum up interest for the local folk dancing display before showing what he’d unearthed whilst spelunking the King James’ Bible. Phil Nash closed the year’s talks with a very succinct demonstration of his new lightweight unit testing framework called Catch.
Friday always plays host to the Speakers’
Dinner where the attendees get to spend a little more time up close and
personal with the presenters. After each course they have to switch tables
whilst the speakers stay put so there is always someone new to chat with. There
was also an auction in aid of
Sadly my presence ended a little earlier
this year and so I had to miss out on the Saturday sessions. I haven’t even
looked at what was on because it will only depress me further knowing what has
escaped me. I know I say it each year, but you really cannot put a price on the
time you spend with the speakers and other attendees in the bar at the end of
each day. Yes, as the evening progresses the value-per-pint slowly diminishes,
but even at
Chris Oldwood
23/04/2011
Bio
Chris started out as a bedroom coder in the 80s, writing assembler on 8-bit micros. These days it’s C++ and C# on Windows in big plush corporate offices. He is also the commentator for the Godmanchester Gala Day Duck Race and can be contacted via gort@cix.co.uk.