Report from ACCU 2008

I just came back from 7 days in Oxford attending the annual conference arranged by ACCU. Around 300 delegates (I was told), interesting program, very suitable conference location and excellent organising comittee lead by Giovanni Asproni. The conference was packed with people that really care about programming like myself and they all behaved as if we were long time friends. It was this feeling of… feeling of… coming home. The conference was a superb experience. I just wish I knew about this conference years ago and I will definitely try to go next year as well.

(Disclaimer: this is a report based on what I heard and remember, not necessarily what was actually said or written. I do apologize upfront for any sloppy understanding and recollection of a particular subject, session and happening.)

On Tuesday (Day 0) I attended a one-day tutorial about Erlang – the programming language. I do believe that we are about to see a paradigm shift in the way we think about programming computers. Declarative and functional languages might soon play an important role, also in the industry. The tutorial was presented by Joe Armstrong, Mr Erlang himself. I enjoyed the tutorial very much. I hope to get more time to do play around with Erlang soon.

Tuesday night a group of us went out for a curry at Chutneys. Highlight: The bill. Why? As someone proudly announced: “Hey folks. This is fantastic! We are 23 geeks and the bill is of course exactly 529 pounds!”. When everybody around you smile and find that amusing – then you know you are among friends.

Wednesday started with a keynote by Tom Gilb (slides). Tom was concerned about delivering real business value to all stakeholders in a project. He proposed to add an “agile envelope” around the agile methodology and lean principles. Several in the audience was provoked when Tom insinuated that agile practitioners are not really trying to deliver business value… and you know that you are at the right conference when someone just stands up in anger and shouts (something like) “Tom, what you are saying is wrong!”. He continues to promote the Impact Estimation Table. And as usual his solutions involves meassuring and quantifying stuff – which makes me sceptical.

Roger Orr talked about writing programs in a networked world. I found the talk interesting even if it was not too much new for me here. Having worked with networked applications for over a decade, most of the stuff was known. At the same time, it is always useful to get reassurance on things that you think you know. Key messages: Good networking interfaces are the key to good support and maintenance. Prefer higher level abstractions, allowing for multiple potential transport protocols. Make sure that you handle versioning issues. Security usually conflicts with other goals (eg, supportability) and it is often not possible to add proper security late to a product.

How to become Agile was a talk by Jutta Eckstein about introducing agility to a project or to an organization. The key idea was that a successful transition is impossible without involving management. But at the same time, introducing agility top-down does not work – trust is lost at the beginning. People are often looking for recipes, which is kind of opposite to what agile methods is all about. It is useful to identify and empower change agents that can assist the process. The change agent is often someone from inside, but they might need some support from outside at first. People tend to listen more to external people than internal people even if the message is the same. As most agile experts seem to agree upon, Jutta claimed that doing retrospectives is the most important agile technique. It is a big mistake to skip the retrospetive sessions. Between projects you might need to use a whole day, while an hour might be sufficient between iterations. Useful links (The World Cafe, Virginia Satir, Shuhari, Agile Software Development in the Large).

Perhaps the most entertaining talk at the conference was Robot Wars by Ed Sykes and Jan-Klaas Kollhof. They believe that there is an exciting robotics market about to evolve, and they have been looking into different development tools. They demonstrated how to use Microsoft Robotics Studio to program Lego NXT robots. Then we got a demo of free alternatives for robot programming. For their final demonstration, Ed and Jan-Klaas added a camera purchased from mindsensors.com to show how a robot could chase another using a very simple application. I have an NXT myself and I thought this was really great stuff.

There is something in the air… said Simon Peton Jones, Mr Haskell himself, during his opening keynote on Thursday. His talk was about Caging the Effects Monster – the next decade’s big challenge. The key message was that in order to improve and reach nirvana in programming we need to be able to control the effects and implement large parts of our programs without any side-effects. Simon demonstrated some really nice examples and rationale for functional programming. He also presented strong indicators showing that functional languages are attracting substantially more attention these days. Links: ( Haskell, F#, Erlang, OCaml, Scala, monads)

The Selfish Object was a talk by Kevlin Henney. The key idea was that instead of focusing on what an object can use or be given, you should focus on what it wants. Need and want is not the same thing. The same goes for object interfaces. When extracting interfaces, focus on the usage and not on the implementation, fex, do not name the interface after the implementation, but find a name based on client usage. Avoid singletons, there is never a real need for them, you can always parameterize from above (Pfa) instead. Don’t use approaches like Template Method (NVI). Through techniques for controlling dependencies, such as Pfa (parameterize from above), dependency inversion, role-based naming, and more, you might end up with a better radial architecture (onion ring) than the more traditional one-way architecture (layer cake). Later same day, John Lakos summerized nicely: “I want to depend on the interface, the whole interface, and nothing but the interface. So help me Kevlin.”.

Just after lunch there was a BOF session about local ACCU groups. Since I am involved in a lot of geek activities in the Oslo area, I was interested to hear what kind of things local ACCU groups were discussing. How to get speakers and how to attract people to the events was discussed. Apparently getting a location for events is difficult. In Oslo we often use pubs for small events (up to 120 people), this seems to be more problematic in UK for some reason (perhaps there are not that many pubs in UK?). The ACCU group in London have had success with borrowing meeting rooms from the big banks. Another group had managed to use the computer section of a book store, a really nice idea. Recording of presentations was also discussed. But, first of all recording introduces a lot of work and also the speaker and audience is less likely to interact and engange in interesting discussions if recorded. This aspect is also true for the ACCU conference. Recording the sessions removes the magic.

John Lakos ran through 562 slides in his talk: Toward a Common Intuition and Reusable Testing Methodology. It was an excellent presentation, but it was deep stuff and I have to admit that was not able to absorb all the ideas – it was like drinking from a fire hose. But there was a very interesting and solid discussion about what it means to be “the same” and what the salient attributes of something are. In C++ a lot of errors arises due to ignorance to these subjects. John, what about dividing this talk into two, where the first is named “The same? What the fuck do you mean?”, that would be more like sipping a superior single malt.

The next session I attended was about Memory Allocation by Andrei Alexandrescu. The main message was: If you try to write your own allocator, you will fail. Over and over again, we see that the best general purpose memory allocator outperforms a special purpose memory allocator. If you have identified, through proper profiling, that you indeed have some specific needs, then you should use a reaps allocator (regions with free-list), otherwise go for the Doug Lea memory allocator.

The last session of Thursday was a special version of Just a Minute hosted by Ewan Milne. Funny, but perhaps not so useful. As I did not know about the “Just a Minute” concept, I thought (for some reason) that we would get some sort of Lightning talk session. We have used this format (1-10 minutes talks) successfully at several events in Oslo. I would love to see a session of lightning talks at ACCU next year.

The opening keynote on friday was presented by Andrei Alexandrescu. He talked about fundamental challanges in programming languages, and briefly introduced Stepanovs litmust tests: If you can’t implement max, swap or linear search properly, what are your chances to implement really complex stuff? To kind of underline the point, Andrei demonstrated an even more fundamental problem, even implementing the identity() function is really complex in C++. Fortunately, with C++0x we are apparently moving in the right direction.

Despite being a dedicated Emacs power user, I have to admit that I sometimes envy the tools that Java developers have available – Eclipse being one of them. I wish I could use Eclipse on C++ code as well. For the last few years I have been downloading the latest version of Eclipse CDT once in a while to give it a go. For now, I do not see that it adds any value to my C++ development environment, but I am still optimistic because I can see improvements every time. When I saw that Peter Sommerlad was giving a talk about C++ Refactoring and TDD with Eclipse CDT (slides). I thought I might learn more about the state of CDT – and I did. Some of the new refactoring tools that have been added looks interesting, but I got the impression that they are still quite fragile for variable C++ coding styles.

Testing is a way of showing that you care. This was a key message from Kevlin Henney in his talk Know Your Units. There are many testing techniques – unit testing being only one of them. But it is important that you distinguish between what is a unit test and what is not. A test is not a unit test if it uses external resources or if it require a particular order of execution. By focusing on doing unit testing correctly, you will often be forced into making sound design and architectural decisions. Tests that are not unit tests according to the definition might also be very useful but they serve another purpose – often they focus on finding bugs. A useful technique when writing unit tests is to prefix the test name with ‘require’ as in ‘require_that_sqrt_of_4_is_2()’ rather than ‘test_sqrt_4_is_2()’. Your tests should look like requirements and this naming style will guide you into writing better unit tests. Other guidelines: The more general a method gets, the less useful it is for a particular application. Get rid of your singletons, they make your code untestable. Don’t ever invite a vampire into your house, you silly boy – it renders you powerless.

Before the Speakers Dinner friday night, two teams met at the squash court to settle the long term debate of whether braces should be aligned:

// aligned style
if (is_ready())
{
do_foo();
do_bar();
}

or disaligned:

// disaligned style
if (is_ready()) {
do_foo();
do_bar();
}

I was (of course) playing for the “disaligned” team and it was a fierce competition for about an hour and a half before we gave up… failing to declare a winner. It was decided to bring in more combatants and do a boat race later in the evening to settle the debate. If I remember correctly the ‘disaligned style’ team lost, but as you know, in a boat race having most supporters and the biggest team is not an advantage…

I would have liked to see Roger Orr presenting the keynote on Saturday morning, especially since I later was told that it was a really good one. But I did not get to bed before 5am saturday morning and sometimes you have to prioritize hard.

Detlef Vollman gave a talk about C++ for Embedded Systems. This was a particularly useful session for me since it is exactly what I do for a living. Some messages: In embedded systems, power consumption is often the biggest problem. Immutable strings make sense, so you might need to implement your own string class. In low-level classes you should not use dynamic memory allocation. Don’t fall into the OOAD trap where you only analyse a system top-down, for embedded systems you must also use a bottom-up lego approach. C++ is a multi-paradigm language, which is very useful for embedded systems. Only use OO if it really gives you some benefit.

For the last year I have been following the C++0x process closly, so of course I had to attend C++ 2009 in 90 minutes by Alisdair Meredith. I already know about most of the things that are going into the new standard, but my knowledge is superficial. For example, when I first saw the proposal about rvalue references I did of course realize how useful they are for making dead hard quiz questions, but after Alisdairs talk I understand more about why some of these things are important additions to the language.

Then finally, there was a panel debate about the State of the Practice lead by Giovanni with Tom Gilb, Hubert Matthews, Russel Winder, Peter Sommerlad and James Coplien in the panel. They all seem to agree that as an industry we have really screwed up badly. Sure there was a lot of good points made, but I suspect they have a somewhat biased experience base. Big names like these guys are often brought in to fix stuff in failing projects rather than watching successful projects completing a masterpiece. In addition, it is always comfortable to be the one critisizing instead of being optimisitic – being a pessimist is the safe bet in all things with a large degree of uncertainty. But at the same time, the session was indeed interesting. Some stuff that was dicussed: Are there too many lay programmers out there? Do we need to become a registered profession? Perhaps we must split CS into displines like telecom, banking, military, and so on? Are we going into a cultural rot? Is software development a normative discipline? Do customer buy a service or a product? Does better compilers make it just easier for lay people to write bad software? Will making a registered profession have impact on free and open source software development? Is the free market for software working?

And then the conference was over.

Sunday morning. 6am. Three alarm goes off. Must not be late for my flight back to Oslo. Looking out of window. England covered in snow. Wow! Prepared for a really bad trip home. Luck. Flight was just a few hours delayed. Wife and two kids. It’s always nice to come home…

One Response to Report from ACCU 2008

  1. Thomas Guest says:

    Nice report Olve.

    “I would love to see a session of lightning talks at ACCU next year.”

    I agree, lightning talks are a great way to involve people and add some more dynamic content.

%d bloggers like this: