Title: The ACCU Conference 2004

Another year, another ACCU conference. And this year's conference, like its predecessors, was an excellent event. In this write-up a number of attendees will tantalise you with brief reports of what went on. Let it serve as a memory-jog and piece of nostalgia for those who attended, and as an encouragement to come next year.

The 2004 ACCU conference took place between 14th-17th April, and this year returned to the centre of Oxford. A sense of grandeur was lent by the venue, the Randolph Hotel. Although it's comparatively hard to get into deepest darkest Oxford (the Park and Ride serves admirably), the central location made it much easier to fall out of the conference into the local night life - an essential part of conference attendance.

All four days were packed full of high quality seminars, presentations, tutorials, workshops, "bird of a feather" sessions, and socialising. The ACCU conference is always a great place to meet like-minded individuals; people who like to program, love to learn, and want to sharpen their skills. Many ACCU members relished the opportunity to put faces to the names they see in periodicals and on the mailing lists. It's always surprising when your mental image of an intellectual giant is dashed against the harsh rocks of reality!

The geeks (let's face it, that's all of us) were particularly pleased by the Randolph's freshly installed wireless network, and many a happy hour was spent pulling out hair whilst trying to configure the darned thing to work.

Friday night's speakers banquet was a great success, if not an amusing occasion as delegates struggled to find enough spaces to eat! It was a good quality meal with an added twist - between each course delegates had to switch tables; a chance to meet several speakers, and the many other delegates. Who said technical conferences are dull?

At the core of any ACCU conference are the keynotes and seminars. On each day there were five concurrent themed tracks, ranging from Process to Python, from Open Source Software to hardcore C++. The conference boasted more than 70 speakers, with many new speakers rising from within the ranks of ACCU, a refreshing trend - especially considering the high quality of their talks.

To provide a flavour of the content here are a selection of brief overviews. Unless otherwise specified, these have been supplied by accu-general regular Ric Parkin (ric.parkin@ntlworld.com):

A talk about Open Source Software, from the writer of the highly influential "The Cathedral And The Bazaar". While evangelical, he made some interesting points about domination relationships, which is where your business depends on someone else, out of your control. In particular, software vendors often dominate their customers' future, and not always in a good way. In this light, OSS can be seen as a way of managing your risk - you have more control over your software. For software vendors, this implies a change from making software as a manufacturing company, to supporting software as a service company.

Paul Grenyer adds: The conference fun started in the first keynote, when Eric Raymond mistook Francis Glassborow for nothing more than "The Camera Guy", due to the fact he was filming the session, when he raised his hand to ask a question.

Herb is always an excellent speaker, and here he was going over some aspects of the proposed new C++ binding to the .Net CLI. There are two major design decisions that look to me to be vital, and to be done well:

Herb also did a whirlwind tour of the context sensitive keywords used to declare managed types, and some differences between .Net Generics and templates. To finish, he announced that not only are Microsoft going to give away the VC7.1 command line tools free from today with no restrictions, but they're also going to do the same for the new version as soon as it comes out...

Paul Grenyer adds: Another highlight was when Herb Sutter admitted something that I am sure many of us feel deep down inside: "I Love C++". This, along with his announcement about the now freely downloadable Microsoft Visual C++ compiler (yes free!!!) and the marrying off of two couples of ACCU members as an example of the pairing between C++ and CLI, made the session very memorable.

[The compilers can be found at http://msdn.microsoft.com/visualc/vctoolkit2003/ - it does not include the GUI, but when I spoke to the chap from Microsoft, he did say you can drop the free versions over the previous binaries and everything should still work - Ed]

Tony Barrett-Powell writes: Pete's session was about how to write better software and used the framework of a road sign to structure the session. His first assertion was that the main differentiator between good and bad programmers was not technical excellence but attitude. To illustrate this assertion the session quickly proceeded into a 5 minute practical to work in teams followed by Pete discussing some archetypal programmer attributes and finally to think about your attitude during the practical. He went on to note that software is generally developed in teams and that the individual attitudes effect the team. Finally he presented the ideal programmer in terms of attitudes and his suggestion that adoption of these attitudes would improve a programmer was well received by the audience.

A wide ranging talk about various designs found to be useful, and some thoughts on costs and risk. Many ideas came from managing the risk inherent in writing software - by catching problems early you reduce the risk and costs of finding them later.

An example was making value types rather than built ins. The idea is that you write a new type for every type your domain problem uses. For the small upfront cost (small if you write a decent templated type generator) you write a domain level language that gets the compiler to catch mistakes, and makes the code more expressive in its intent.

Other subjects included tying the units of a quantity into the type system, the different trade offs when choosing how to iterate over a collection, looking at genericity and virtual calls to express static versus dynamic variability.

Mark finished off by looking at using design to capture and manage complexity. Despite some recent languages, OO is not the only, or best paradigm to use. C++ is unusual in being multi-paradigm which allows it to model complexity well. It is:

These different paradigms are tools, to be used when designing.

Tony Barrett-Powell writes: Kevlin's session considered design patterns and how the Gang of Four's book design patterns has influenced, or impeded, the progress of design patterns. Using the framework of the 23 design patterns from the Gang of Four, Kevlin presented some inconsistencies and flaws in the design patterns. For some of the patterns Kevlin reconstructed them to show that in fact they hid further, more fundamental, patterns. The best example of this was his reworking of the Singleton, a much abused pattern and the source of a substantial secondary industry. The result of the reworking was a community of patterns with a genuine creation constraint and much clearer consequences. In summary Kevlin reiterated what patterns were and that the Gang of Four is a historical subset of the patterns we need for effective design.

A quick session over lunch to get some real world statistics on how well programmers can remember, by performing a series of tasks.

Participants were shown three variables and their values. When you thought you had memorized them, you turned the page. There was a nested if statement of the form if((a < e) && (u < a)) then if(e < u) then A else B; Assuming the first if was true, you ticked which statement got executed, A or B. Now that you've been distracted, there was then a list of the previous variable names, plus a fourth one. You had to write down the values, or tick if you would have to look again, or if the variable was the extra one.

This was surprisingly difficult, especially as the same names and values came up regularly but in different permutations, so you couldn't mentally build a system model, as it would mislead you. The results are to be analysed and written up for C Vu.

http://www.dietmar-kuehl.de/cxxrt/

The STL is great, but there are problems. People write loops by hand instead of writing an algorithm, because functors are a pain. Libraries like Boost.Lamda can help but are not perfect. Also, passing pairs of iterators is usually too difficult and unnecessary - most of the time whole containers are used. So we add lots of algorithm overloads and use meta programming techniques to sort out possible ambiguities in the signatures. This gets you code like:

std::for_each( intcontainer, std::cout << _1
      << " squared is " << _1 * _1 << "\n" );

But there are worse problems. The STL concepts are too restrictive:

The solution is to refine some of the iterator concepts - it has a position cursor, and some properties that may be able to be read, written, or treated as an l-value (i.e. a reference taken to the underlying value):

T val = get(propertymap, positionkey);
put(propertymap, positionkey, value);
T& ref = at(propertymap, positionkey);

A wide ranging conversation with the audience, ripping apart the idea of having a Methodology as a panacea. It tended too far into the evangelical; deriding what's wrong without proposing enough to replace it. Still, there were some thought provoking ideas, even if they weren't always well received. For example, Alan suggested that bug tracking systems are often used to hide bugs - if it's 'in the system' it's easy for no one to take responsibility for a bug. This is true, but the solution isn't always to not have a bug tracking system!

A case study of how Francis developed some wrappers for reading and validating user input for a book on teaching C++. A few interesting gotchas, but mainly useful as a reminder that things shouldn't be difficult to use and we would all benefit from better wrappers at the right level.

A lunchtime Birds Of A Feather informal meeting, which wasn't so much about the language, but what tool support was missing, and why this was so. A lot came down to C++ being a hard language to parse, and people not being used to going and getting a library from elsewhere (the number of people who had independently written their own unit testing tools was amazing!)

Dietmar is one of the experts on the C++ IOStreams library, especially the fiendish formatting framework. This was a very useful run through on what you can do and where you should do it. It covered writing your own facets for numerical formatting, and custom stream buffers.

http://www.boost.org/libs/iterator/doc/index.html

Another solution to some STL problems, this is how boost has written an iterator framework. Similar to Dietmar, they presented a set of new iterator concepts:

Thomas then presented two class generators: Iterator Facade that implements an iterator in terms of a small core interface, and an Iterator Adapter that takes another iterator and makes a new iterator that uses the other as part of its implementation. There were lots of useful examples.

To avoid forgetting things in the rush to write code, Alan presented a classification of types, and sets of rules for each type to avoid problems. The types are:

http://www.two-sdg.demon.co.uk/curbralan/papers/accu/MoreC++Threading.pdf

Kevlin is another excellent speaker, and here he raced through the two main models for writing multithreaded code - a C-style procedural API, and a classic OO inheritance model. He then ripped them apart to show how one was error prone, and the other was the wrong abstraction, and then introduced his own novel abstraction using generic techniques to separate concerns and reduce coupling, which ended up very, very neat.

Andrei was in a forgiving mood this conference - his talks were comparatively light on meta programming, so didn't make your ears bleed as much as usual. Here, he looked at using generic techniques to help with the difficulties of avoiding races and deadlocks. An overview of locking strategies brought forth several problems, and he presented some techniques for getting the compiler to help you out.

Paul Grenyer adds: As expected both Kevlin Henney and Andrei Alexandrescu gave two high quality and well attended sessions, on threading, exceptions and patterns.

On Friday evening we had a semi-formal dinner which gave everyone a chance to talk to the various speakers for a while. Much technical and not so technical discussion ensued, which I found great fun and very informative. They continued in the bar, late into the night.

Paul Grenyer adds: The banquet gave further amusement, first with there being too many attendees and not enough tables and then with the fire alarm going off at about 1.30am. Those who had already gone to bed were forced to resurrect themselves to come and stand in the rain. I think this was a cunning plan by the hotel to raise revenue as most people opted for the bar rather than returning to bed.

Andrei zooms into the difficulties in writing exception safe code, working on the problems with manual commit/roll-back schemes, an improvement using manual RAII handles, and finally diving into implementing his ScopeGuard helper.

A very interesting talk about how to approach hiring people, mainly focussing on taking an interview and how to find out if the candidate is suitable. Some good advice on preparation, and some reinforcement of some of the things I try and do.

A quick talk (well, it was the last session and we all wanted to go home!) on how Paul wrote a simple smart pointer, and enforced it's use to avoid mistakes.

by Paul Grenyer <paul@paulgrenyer.co.uk>

I have been attending ACCU conferences since 2001 and this year has certainly been the best, both in terms of the breadth and quality of subjects and speakers, and in terms of the inevitably excessive socialising. Any fears (if there were any) that the conference would falter under its new organisational committee have been well and truly silenced. A superb job has been done by all. The hotel was of the highest standard, my only criticisms were that the WiFi network didn't work in my room and that shoes were a necessity for breakfast.

My favourite session was Jon Jagger's look at the Design and Evolution of C#. I found it very interesting to see how the language was shaped from the successes and failures of C, C++ and Java.

It's difficult to see how this year's conference could be topped, but I am sure that it will and I am very much looking forward to next year.

The conference wouldn't have been possible without the hard work of a dedicated team of people. Attendees owe a debt of gratitude to the conference committee, who organised an excellent programme, and to the conference organisers who ensured the whole thing ran smoothly.

Plans are already under way for next year's conference, and even now it's looking to be unmissable event. Stay tuned... For its low cost the ACCU conference continues to represent staggering value. If nothing else, it's a great chance to pretend to be deeply interested in technical issues when you really just want to meet ACCU regulars and insult them face-to-face.