My 2009 ACCU Conference
This was my second ACCU conference - my first being 2008. Last year I was somewhat star struck as many of the authors of the books on my desk were there. Of course they were all very accessible, especially in the bar after hours. This year it didn’t take nearly as long to slip into the routine of walking up to random people and chatting with them over 1 or 5 beers. I also vowed not to stay up until dawn every night and instead make every keynote – I almost succeeded. Another change for me was to focus less on the technology and more on the ‘message’, which as it turned out was pretty hard to miss in some cases...
I got into the swing of things pretty quickly by arriving on the Monday night and taking the pre-conference session on Tuesday by Alisdair Meredith about C++ 0X. I have been loosely following the proposals for the next C++ standard on various blogs, but it still felt good to have a leading figure talk you through the proposals, and how they interact, such as R-Value references and move semantics. As expected he covered the new Memory Model and threading features in reasonable depth, illustrating how the Double-Checked Lock Pattern would be implemented correctly. The middle part of the day covered some of the more settled features like unqiue_ptr, initialiser lists, variadic macros and templates and then he devoted a significant amount of time towards the end to Concepts – the other big new feature. I was doing well, but I’m afraid he lost me when it got to discussing Axioms, luckily there’s still plenty of time to digest all this before it becomes a reality.
Wednesday was the start of the conference proper and the opening keynote was from Uncle Bob about Software Craftsmanship. This was an interesting and insightful piece about how we have attempted to cast ourselves as scientists or engineers or architects and consequently have ended up drawing some pretty poor analogies that has helped neither us nor our customers. This also laid a nice backdrop for Nicolai’s keynote which was due at the end the day.
F# is a new language joining the .Net family and one whose blog I have followed out of curiosity, so I chose Oliver Sturm’s “Functional Programming in F#” as my first session. After double-checking with him first about how “heavy” it was going to be, I was pleased to see that he covered much of the languages’ background to set a context for its use. Using the interactive interpreter he walked us through some F# basics, but its foibles as a statically-typed .Net language looked apparent to those that were perhaps used to other more flexible FP languages, so he didn’t get time to cover some of the more advanced features.
I followed lunch with Roger Orr talking about Refactoring in the Real World. The ‘RW’ suffix was important as this hugely over-subscribed session took on a workshop style as the attendees were all too keen to share their experiences. Roger used rock climbing safety, i.e. only moving one limb at a time as his analogy to drive home the importance of small steps and the use of version control. As someone just starting to do this formally it was useful to see how to avoid refactoring everything in sight when you come to an old codebase that has seen a lot of action.
Michael Feathers and Steve Freeman filled my afternoon with a workshop about Programming Paradigms. They took a simple problem and got four teams of people to solve it using different programming paradigms – Procedural, OO, Functional and Rules Based. The teams would then rotate and implement a new feature using a different paradigm. The paradigms were compared and Steve showed various implementations using Java to illustrate how a multi-paradigm language could be used. This session was also hugely popular and even though I was only a bystander I still found it thought provoking.
This year saw the day finishing with a keynote as well, and it was Nicolai Josuttis that delivered a scathing comment on the lack of quality being applied in the industry due to the marketing drones calling the shots. The large dose of irony that accompanied his examples did not cloud the underlying message which is perhaps more apparent in large corporations than smaller software houses. It certainly generated a fair bit of discussion in the bar later.
Thursday’s keynote was delivered by Linda Rising on the level of abstraction required to make patterns work successfully. She pointed out the dangers of being too specific to one problem domain – namely that other people will fail to see the similarities and discard them or create a new, but very similar pattern, when in reality they should have created a higher-order pattern that encompasses both. I found her account of the POLP conferences shepherding process and writers’ workshop, and how that differs from the usual conference format, particularly interesting.
I decided to go with Phil Nash’s introduction to Objective-C after the coffee break as I had seen snippets of example Objective-C code in magazines and thought the syntax was weird, but as Phil quickly showed (after a brief OO language history lesson), it isn’t really that strange and I was quite taken with many aspects of it until he started to describe the reference counting. Unfortunately time got the better of him, but nonetheless he appeared to cover most of the key language features, and also its reliance on conventions, which appears to be a big aspect. It was a good introduction that has certainly grabbed my attention.
Lunch was again spent outside enjoying the sun. It almost seemed a shame to have to come back inside, but I did for Hubert Matthews talk on Modelling Archetypes. This was, much to my surprise, probably the most enjoyable talk I went to because Hubert managed to bring into a focus a number of questions I had floating around my head about lightweight modelling in general. He introduced a number of entity types to represent certain key concepts like transactions and roles and then proceeded to give them a colour. He showed some example models and went on to explain how the various entities naturally fit together, with the colours making it much easier to see the structure of the model, and more importantly, to see potential problems.
A short coffee break and it was back for more C++, with a session from Andrei Alexandrescu about replacing the Iterator concept with Ranges. His talks are always entertaining as he tries to get a little audience participation going and you know that he’s going to hit you with something cool! He didn’t disappoint as he showed that the iterator concept in C++ has limitations that make implementing certain algorithms or containers difficult or impossible. His solution was to replace the discrete pair of begin/end iterators with a Range concept, which not only encapsulated that behaviour but also vastly simplifies others such as reverse iterators. Once again Andrei makes everything look so simple and leaves you wondering why no one thought of it before.
Another new addition for ACCU 2009 was in store after the sessions – a series of Lightning Talks. These were short (5 minute) presentations from anyone about anything. A fair selection of topics were covered in the first 9 talks, such as; Seb Rose giving a quick description of the Rational Jazz Server, Didier Verna comparing the finer points of Lisp, Jazz and Aikido and Mark Bartosik discussing debugging Windows applications.
Thursday night’s drinking had an extra twist this year as Steve Love and Richard Harris decided to do a spot of fencing in the hotel car park! They had proper kit and everything – not just a couple of broom handles and duffle coats. But, what were they fighting for? Tabs vs. Spaces? Vi vs. Emacs? Honour?
Due to an over-indulgence of Leffe I managed to miss Friday’s keynote and instead started the day with a session on Portable Code from Steve Love. He took a much wider look at what it means to write ‘portable code’ by starting with the more obvious issues around OS’s and tool-chains, but then introducing Testing as another ‘platform’ along with external services and even developers’ differing abilities. Steve’s message about how hard it is to write truly portable code was pretty clear, but by following industry best practices where possible, we can make our code malleable enough to easily cope with whatever ‘platform’ we need to write for.
Another pleasant lunch outside in the sun was followed by the second talk from Andrei Alexandrescu - this time about Cranking Policies Up. This was based on a Scott Meyers article, called “Enforcing Code Feature Requirements in C++”, that heavily used Template Meta-programming to attribute features to code, such as “thread-safe” or “portable” so that feature incompatible code could be flagged at compile time. Andrei’s focus was on showing why the C++ language, as it stands today, does not make the technique scalable. It also gave him the chance to give the D language another plug, by pointing out where it was superior.
My last session for the day was from John Lakos about Designing Good Components, Interfaces and Contracts. In true Lakos fashion, he had some 470 slides (less than last year though!) to cover in just 90 minutes. He gave a whirlwind tour of Physical Design – as defined in his book – and then went on to discuss contracts, in particular how and when to define behaviour and when to leave behaviour undefined, perhaps using defensive programming to highlight when UB has been invoked. Unfortunately, given the ambitious size of the talk it overran and he had little time to spend on the final section about the different forms of inheritance.
I just managed to squeeze a quick pint in before the second set of Lightning Talks. Once again we had another 9 presentations, this time kicked off by “Caring Will Only Cause You Pain” by Peter Hammond which beautifully continued the theme Nicolai addressed days ago in the evening keynote about the death of quality. A bit later Olve Maudal continued the onslaught by using the analogy that you wouldn’t want to work in a messy kitchen, so why do it with your codebase? And later still Mark Dalgarno also tackled Nicolai’s topic of cut-n-paste coding by discussing Code Clones. In between were other talks about Git, Scala, crime, character encodings and the Google web toolkit.
The Conference Dinner that evening was another good opportunity to continue stepping outside my “comfort zone” and just talk to random people. The principle is that the speaker gets to stay put and the attendees switch tables after each course, and with Giovanni controlling proceedings, no one is going to argue when it comes time to switch tables. I managed to speak to a whole bunch of new people and talk to some speakers whose talks I missed because of the annoying physical limitation of only being in one place at a time.
Allan Kelly kicked off the final day with a keynote that looked into the management of software development. Using Fred Brooks’ comment on the quality of people being more important, he introduced 9 principles (although it was 10 really as it was 0-based!) for better management. These principles tackled balancing workload, relationships, quality and risk which hopefully will lead to both happy customers and developers. Although aimed more towards managers, he did pronounce that “Managers are not Aliens” and try to get developers to be more aware of their managers’ needs. He also managed to finish with the most blatant book plug of the conference (I think it was called “Changing Software Development: Learning to become Agile”).
After copious amounts of coffee to aid recovery from the night before I decided to join Klaus Marquardt’s workshop called “Patterns for Versions, Releases and Compatibility”. Whilst giving his introduction he produced a large ball of wool which seemed a little odd, until we found out that we were going to discuss and list the various aspects of our current project’s release cycle, attaching them to the wool to create a washing line, of sorts, that describes the process. We then got to go around the room and see how other people in other domains tackle releases and put love-hearts or lightning bolts on any practices we particularly liked or loathed. There was a good cross section of application domains to ensure this session had the diversity it needed.
My final session of the conference was spent with the bare-footed Pete Goodliffe discussing Legacy Code and how we can learn to live with it. This was a talk about what legacy code is, how do we go about understanding what it does and then how can we change it without breaking anything else and hopefully improving it at the same time. The majority of the talk was about the “understanding” aspect as he initially covered the wider picture such as the build process, documentation, customers, testing etc to show that the context of the code is often bigger than just the raw lines of source code. Pete then focused on how to “map” the software to get a feel for its structure, by looking at interfaces, dependencies, file layout etc. The final section on modifying the code concentrated on testing practices, but also touched on other improvements such as cleaning up old comments. He finished by walking through a code change with the aid of frogs! I found Pete’s session nicely put some of the recent books I’d read (such as Michael Feathers) into a bigger context.
The sessions - the bit you pay for – are worth every penny in their own right, but they’re not the only reason for coming to the ACCU conference. The other reason is networking, or more simply, meeting other likeminded individuals. Every lunch time and evening in the bar once again proved a goldmine as I met new people and got to talk to a few of the speakers in a more informal setting. The great thing is that you know everyone in that bar (well, those under 90 at any rate) is there for the same reason – drinking beer and talking about programming stuff and probably even the real world every now and then. I know it’s only my second year, but it lost none of the magic I experienced last year.
Wednesday, 20 May 2009