ACCU2015: Days 2-4: Asynchronisation & Philosophy

As you might have suspected, I have been either too intellectually stimulated or beer fazed to write a blog post from day 2 onwards…

So the time has come to sit down quietly on the Sunday afternoon after the conference and write down some summarising words about the following days.

I had a fair number of insightful moments, either during presentations or subsequent discussions with participants. So much so that I will write about my day 2 lightning talk in a separate post.

Once again there was a great blend of the deeply technical (in this case lots on multi-threading) and the philosophical. This is what I love about this conference because it grounds the philosophical and enlightens the deeply technical. Wonderful.

Olve Maudal & Jon Jagger play Music Mashup

Olve Maudal & Jon Jagger play Music Mashup


Day 2:
There was a truly scary presentation by Alex Naumann from CERN about how physicists were using a C++ interpreter CLING and novices were developing a massive C++ codebase with loads of cut and paste. Thanks to the massive data sets that exist, at least they have a large body of test data to verify correctness – but still…

There was also a great quote from Olve Maudal’s presentation on the history of C and C++ saying that enums in these languages are troublesome because Dennis Ritchie hated them and hacked them in as quickly as possible! A classic point that highlights the relationship between the quality of software and whether a programmer is externally or internally motivated.

Phil Nash’s presentation on seeking simplicity was a great presentation about differentiating the Simple/Complex axis from the Easy/Hard axis. It was also interesting for its reference to Cynefin, which was found in other talks too. His references are at http://www.levelofindirection.com/storage/simplerefs.html.

In the bar (thanks to Bloomberg for the free beer) there was a fun music mashup machine which I had a play with. It consisted of a camera below a translucent panel with blocks which had QR codes on them for the 4 sound types of bass, percussion, melody and voice banks. So intriguing that I actually took a photo of Olve and Jon playing with it.

David Sackstein presenting (with apologies for image quality)

David Sackstein presenting (with apologies for image quality)


Day 3:
David Sackstein’s presentation on Coroutines was given to a packed audience. Although it was fascinating for its content, I found it more so for its effect on the audience. The coroutine idea is not new, as anyone who used to use setjmp and longjmp will know.

When David explained that a coroutine handed off control to another context (or stack) while the initiating one was held, there were the inevitable cries of – but that means things are not being done in a multi-threaded way! The noise of hearing the pennies drop was almost deafening as he explained: “But that is what the operating system is doing for you anyway in a multi-threading environment! It simplifies your code to be more explicit about the handover points.”.

Classic! Yeah I know we have multiple cores but if you don’t grok how schedulers work on a single processor you are asking for trouble before you get anywhere near parallel processing.

The great thing here is that there are great simplifying techniques to make the scheduling far more explicit in people’s heads – which is wonderful for educating folk about multi-threading. In this case coroutines simplify the thinking needed to cope with processing in two different contexts, which means I may be able to simplify all my ugly callback code.

This thread (pun intended) during the conference was repeated in other presentations, so it seems like the community is getting its head around asynchronous programming. Maybe I will get more people who survive my interviews when we reach the multi-threading questions! I can hope.

There was also a great, and courageous, talk by Peter Hilton about how to name things. A great reference here was to George Orwell’s essay, Politics and the English Language.

Day 4:
On the final day I really enjoyed Roger Orr’s talk on Coding without Words questioning when we should name things rather than make use of C++ features such as lambdas and auto. This talk helped me realise that using names instead of implicit language constructs is important if the name actually denotes an important piece of knowledge in the application domain or surrounding code segment context. For me this presentation epitomised the link between technology and philosophy really well.

Roger’s talk also allowed me to unbend my mind after listening to Jonathan Wakely talk about the importance of Application Binary Interfaces (or ABIs). Really interesting, really important and really good – but Ouch! Oh yeah – for the programmers out there – in his lightning talk he said PLEASE do NOT use leading underscores on your #ifdef names for header file include guards – as a library writer that is HIS namespace you are encroaching on! Good one.

The final keynote by Chandler Carruth of Google was an exposition of the set of tools, or “ecosystem”, around the clang compiler.

All in all a great conference. Now all I need to do is go and get my head back into normal mode again – whatever that is!
Until the next time…

Comments welcome. Let me know what you think...

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s