ACCU Home page ACCU Conference Page
Search Contact us ACCU at Flickr ACCU at GitHib ACCU at Google+ ACCU at Facebook ACCU at Linked-in ACCU at Twitter Skip Navigation

pinACCU Conference 2019: Reports

Letters to the Editor + Overload Journal #151 - June 2019   Author: Felix Petriconi, Stefan Turalski, Ori Ben-Shir, Mathieu Ropert, Anthony Williams
ACCU holds an annual conference. Several attendees tell us what they learnt there this year.
Abstracts for most of the sessions are available at: https://conference.accu.org/2019/sessions.html Recordings of the sessions are available on the ACCU Conference YouTube channel at: https://www.youtube.com/channel/UCJhay24LTpO1s4bIZxuIqKw Visit https://conference.accu.org for details of other conferences planned for 2019 and 2020.

From Felix Petriconi

What a great week has just passed. I attended the ACCU conference in Bristol, UK for the fifth time. On my flight back, I started to make these notes. I am still overwhelmed by all the information and the impressions.

For me, the conference started one day before the actual sessions. I attended one of the offered one day tutorial workshops. My choice was the ‘Introduction to Rust’ workshop by Katharina Fey. She clearly described the differences from other languages like C++, so the introduction was quite easy. Piece by piece, she guided us through our first programming tasks. From that day, I received a good overview of the language, and the advantages of the extreme strong type system and its focus on value semantics.

The Agile Bath & Bristol User Group again held their meeting in the evening at the conference’s location, and Giovanni Asproni [Asproni19] talked about ‘One Team, Two Teams, Many Teams: Scaling Up Done Right’. It was an excellent talk where he emphasized that scaling up teams only works in a limited way and that problems that already exist in a single team are increased disproportionately when more teams work on the same project. It would be great if more project manager or other leads in companies could know this too.

For the very first time, we had a small intro video five minutes just before the conference. Dom Davis [Davis19] created an usual boot sequence, including a funny animation by Dylan Beattie of Eric Holscher’s Pac-Man rule and the schedule of the day. After a welcome from the Chair, Russel Winder, the conference was opened by Angela Sasse, formerly a professor at the Department of Computer Science, University College London, UK and now of Human-Centric Security at the Ruhr-University Bochum, Germany. In her keynote, she emphasized the importance of the need to communicate between the security department of an organization and the users of the IT infrastructure. If users are not convinced by the importance of certain security measures, they will bend the rules as much as possible to make them work in their environment. As well, I learned that there are already organizations out there that offer – beside intrusion or hacking tools – first-class full support with help desks etc. for their ‘customers’.

The first regular session that I attended was given by Vittorio Romeo on higher-order functions. He gave an overview of higher-order functions that already exist in the C++ language in this very well structured talk. In the second half, he explained the concept of a function_ref that he is currently proposing for the C++ standard. This is a construct for referencing functions and function objects, similar to string_view for character sequences.

Unfortunately, I could not attend any session after lunch even they were all very interesting, because I had to go to my own. Here I spoke about the enormous number of traps that one can step into when one uses low-level synchronization primitives likes atomics, mutex etc. and that high-level abstractions take away most of the pain. At this point I want to thank John Lakos for the engaged discussion within the session. This is the way that I wish more sessions would be, because the word ‘conference’ comes from Latin ‘conferre’, to compile, to discuss, to debate, to confer.

The last session of the first day that I attended was given by Patricia Aas about the ‘Anatomy of an Exploit’. The given example was based on exploits that were ten or more years old because of the time limit of 90 minutes for the session. She described very clearly the way of thinking that is necessary to understand how exploits work. I very much liked her illustration of ‘Programming the Weird Machine’. Here one leaves the intended state machine of a program via the vulnerability and goes into a new, weird state machine.

The first day closed with a set of very entertaining and informative lightning talks hosted by Chris Oldwood and assembled by CB Bailey. At this point, many thanks again for their work assembling the presentations between the sessions. I especially recall Dom Davis’ one, ‘Where is Kevlin Henney’.

After an hour of 5-minute presentations, all attendees could discuss their first impressions during the welcome reception sponsored by mosaic.

The second day was opened with a keynote by Herb Sutter in which he presented a proposal for the C++ Standard. This proposal has the purpose of removing one of the biggest hurdles that many C++ users have to using the complete feature set – including exceptions – by extending the language with the keyword throws (throw was marked as deprecated with C++11 and its functionality better expressed with noexcept). The central idea is to use the existing return channel of a function for two different purposes: like a union, either for the regular return value or, in case of an error, for a std::error_code, or everything similar to boost.outcome that has become available with the recent release 1.70. As two years ago, when Herb presented his Meta Class proposal, this was a great and very successful session.

Before lunch I attended Timur Doumler’s talk about a low-level audio interface that he and a group of contributors are currently proposing for the C++ Standard. Before he went into the technical details, he gave a very good introduction to buffers, channels, sampling rate etc. The extension to the standard will provide a unique interface for audio devices over different platforms. It will remove the diversity of the approaches currently needed to bring audio signals into or out of the machine. From my point of view, it looks both very promising and like it could go into the one of the next versions of the standard.

After lunch, Ahto Truu gave a good introduction into hash trees and possible use cases of them in his presentation.

I hosted a ‘C++ Pub Quiz’ as one of the last sessions on that day. It was held in the hotel bar with free beverages sponsored by the conference headline sponsor, Bloomberg. Many thanks again! The nearly 80 attendees had to figure out or guess what eleven pieces of code would print to the console. The format was developed by Olve Maudal several years ago and he allowed me to continue it. Never before have so many nice terms like ‘twisted mind’, ‘sadist’ and similar been said to me :-). But that was fine, I deserved probably it.

The day ended again with a set of entertaining and instructive lightning talks.

Friday, the third day of the conference, was opened with a keynote by Paul Grenyer. He gave an historic overview of how he and a group of supporters were able to create an active developer community in Norfolk that even today has its own developer conference, nor(DEV):con.

After lunch I listened to Dom Davis’ entertaining and informative parable of creating a presentation with graphics that needed to be done by an external contractor. The parallels to a software development process were obvious and intended.

After lunch, I attended a set of 20 minutes presentations.

At the end of the day, I listened to Niall Douglas on ‘Elsewhere Memory’. He led the audience through an expert-level set of proposals to change the C++ Memory Model in a way that e.g. shared memory is regularly supported by the C++ Standard. Today this works ‘by accident’ because of the individual machine assumptions of the compiler and the underlying hardware. It is a pity that this would be Niall’s last presentation at ACCU for a long time, but his engagement on the C++ Standard’s committee consumes most of his spare time.

After a final set of lightning talks, the conference dinner was served. Here we had again the rule that all the speakers had to enter the room first and distribute themselves among the tables with at least one seat empty between them. This meant that the non-speakers, who came in afterwards, sat between two speakers. Such nice conversations could emerge. After each course, the non-speakers had to switch places to give themselves the opportunity of sitting beside a different speaker and having a chat. After the desert, we were entertained by Echoborg [Echoborg], when several members of the audience had to try to make contact with an artificial intelligence by talking to it. The first approaches e.g. by trying the Voight-Kampff test (from the film Blade Runner) on the AI or by just repeating everything the AI has just said were very entertaining but not very successful. Later, with different strategies, we managed to ‘re-program’ the AI’s core routines, which ended the 90-minute session. It was really an intelligent entertaining evening.

On the last day, the conference did not start with a keynote, but with regular sessions. For me, it was Kevlin Henney asking ‘What do You Mean?’. He explained, in an excellent way, why meaning is so important in all aspects of software!

After lunch, I attended two 40-minute sessions by James Cain and Dom Davis. To both, again our thanks that they stepped into the gap on very short notice after a speaker could not give his presentation. James introduced an open source project that he is working on. It offers a virtual file system running in Windows user mode. It is something that I want to look into when my time permits. Dom later gave a live-programmed introduction to the Go language.

After Russel, the Conference Chair, expressed his thanks to Archer-Yates, the organizers of the conference, all the speakers, the sponsors and all attendees, Kate Gregory gave her closing keynote. She made it clear to us that code is emotional and that we really should take care about how we keep our code clean and how we name things.

Conference after conference, I feel more a part of a family that cares for each other. Each year is a reunion. Summing up, this year it made it clearer for me that the sessions make up about 50% of the conference. The other 50% is the direct interaction between the other attendees. While discussing problems of my domain and listening to problems of other domains, I learned so much that I am already looking forward to ACCU 2020!

Disclaimer: I want to add that I am somewhat biased, because I am a member of the conference committee and I am the Deputy Chair for 2020.

From Stefan Turalski

This year’s ACCU 2019 conference was my first ACCU gathering since the conference moved to Bristol. I had really missed the unique vibe and the opportunity to grow through thought-provoking conversations. A chance to learn, equally, from people on the forefront of software development, those who are fighting daily fires in mature code-bases and those few with incompatible views who always open up your mind. Therefore, when an opportunity arose to leave the office for a few days of ‘training’, I knew instantly where I must be headed. It actually helped that ACCU publishes its sessions, as having watched these dutifully for the last couple years, I could easily secure sign-off. (Un-)Surprisingly, I haven’t got much of a problem convincing higher-ups that ACCU is still the best place to: catch-up on recent developments in C++ (obviously), identify the maturity of alternatives (with Swift and Rust under scrutiny this year), discover new tools (or things I’d never expect are possible with tools I’ve used for years) and learn; learn tons!

Now, as the dust settles and ACCU 2019 is a thing of past, I can only report that I was evidently correct. Seeing so many familiar faces around, I felt at home almost instantly. By the second day, I’d fulfilled my goals and – with my mind blown – I can safely spend another year catching-up. It was bliss.

Going into details, by now I’ve got a chance to re-watch some of the sessions and I think I can recommend a few for your attention. Let me start from these I’d say are ‘must’:

  • Herb Sutter on ‘De-fragmenting C++: Making exceptions more affordable and usable’, with Herb stirring up some debates with a few ideas that are captured in P0709 R2 [Sutter18]. As far as I know, it’s the first time Herb has presented this argument. If you find time to watch just one talk, I guess it would be this one. It’s a must if you want to know in which direction the discussion about error-handling in C++ is headed. For a pragmatic approach and a healthy, balanced view on the subject, I’d definitely recommend Phil Nash’s ‘The Dawn of A New Error’.
  • Stephen Kelly on ‘Extending clang-tidy in the Present and in the Future’. Stephen is the person who contributes to CMake and now clang-tidy, clang-query; I watched ‘Refactor your codebase with Clang tooling’ from code::dive, but I probably wasn’t paying enough attention. I recommend it for anyone who has never heard about clang-tidy and clang-query. It’s amazing what can be done with these tools.
  • Greg Law on ‘More GDB wizardry and 8 other essential Linux application debugging tools’, which I missed during the conference (as I went for Anthony Williams’ talk on callbacks). Watching it now, I can only say that Greg’s talks are getting better and better, and as far as I know Greg is the gdb guru (god?). By the way, Greg started up undo.io. Sadly not open-source, but clearly a great tool for recording what your system is/was doing. Chatting with some Microsoft guys, it seems they are trying to provide something similar [Microsoft], but that’s behind a VS Enterprise licence and it still doesn’t work nowhere near as smoothly. Regardless, if you ever run gdb, you need to see Greg’s session.

As always there were a few talks that are worth checking out to keep up to date and learn how others are solving theirs problems. In this category I’d put:

  • Björn Fahller on ‘Programming with Contracts in C++20’, as there is a version available from the new-comer conference Cpp on Sea. During ACCU 2019, I was sitting in the next room (where the talk on C++ package management concluded with a recommendation of conan for dependencies management). However, the noise next door was so inspiring that I’ve watched Björn’s talk, twice. I’d say it’s definitely worth the time put into it: it’s about contracts after all.
  • Arne Mertz on ‘Clean(er) Code for Large Scale Legacy Applications’ was one of the talks that I missed (as I’ve seen a year-old version from Meeting C++ and I went to an entertaining, as always, talk by Kevlin Henney instead). Corridor chats recommended it to me and indeed it’s definitely worth a watch, especially if you are looking for ideas to curb a code-base getting a little out-of-hand.
  • John Lakos on ‘Allocator-Aware (AA) Software’, which I’d say watch at ×2 speed, go have a drink, watch again… actually no, this talk is one of the most approachable of the John Lakos presentations I’ve seen so far. Allocators are coming to C++, so I guess there is no excuse for ignoring the subject.
  • Follow that up with Vittorio Romeo on ‘Higher-order functions and function_ref,’, which I’ve seen recorded at C++ on Sea, and which works perfectly in tandem with Ivan Čukić on ‘Ranges for distributed and asynchronous systems’. Ivan wrote Functional Programming in C++ and clearly demonstrated a set of rather interesting pattern(s). Such code styles, applied together with approach outlined by Vittorio, might leave you with a rather particular, functional?, style of C++: you were warned.

There are also the talks which you would probably see because these belong to your area of interest. Here I’d put

  • Hubert Matthews on ‘Optimising a small real-world C++ application’, which I’ve seen recorded at NDC. ACCU 2019 received a slightly improved version (and questions were, of course, on much higher level). On the subject of questions, one could easily justify going for the ACCU conference just for the Q&A. These are always brilliant!
  • Felix Petriconi (taking over the organisation of the ACCU conference from Russel) on ‘An Adventure in Race Conditions’, talking about concurrency [Parent] and executors, handling of std::future etc
  • Patricia Aas’ interesting talk on ‘The Anatomy of an Exploit’.

I’m sure you would find something for yourself in this category among the overwhelming number of ACCU 2019 talks published on YouTube only a few weeks post-conference.

Finally, there are the best talks, the esoteric ones, like:

  • Simon Brand and Peter Bindels on ‘Hello World from Scratch’, which you know you won’t find useful, until you do (it’s just a crazy talk about all that happens before the hello world is actually printed).
  • Alisdair Meredith on ‘How C++20 Can Simplify std::tuple’, which – as far as I’m aware – Alisdair presents at every C++ Standard revision to demonstrate why things are changing and what’s possible.
  • Jim Hague on ‘It’s DNS, Jim, but not as we know it’, which introduced me to the changing world of DNS. Here, please make sure you know what DNS over HTTPS is. It’s all going to be very confusing when browsers switch to it.
  • Last (but definitely not least), I recall Roger Orr on his adventures in ‘Windows Native API’.

I’m sure that everyone who has picked up this edition of Overload is more than capable of building their own list of best-picks from ACCU 2019. I’m looking forward to lively discussions in YouTube comments – hopefully until ACCU 2020! Happy watching.

From Ori Ben-Shir

First published on Ori’s blog ‘Afternoon Rusting’ on 20 April 2019: https://oribenshir.github.io/afternoon_rusting/blog/ACCU-Summary

I attended this year’s ACCU conference, and I am very eager to share my impression of the conference. ACCU is an annual conference located in the lovely city of Bristol. The conference is mostly dedicated to C++ developers. While C++ developers are the focus, the conference is not limited to C++ material, and it includes talks for various topics and even some other programming languages. Yes, there was a Rust talk and even a workshop this year.

It was the first time I had attended a big conference. And I must admit it was a great pleasure! I’m in love with the concept of technical talks. I find them to be the most effective learning method for me. The opportunity to meet a lot of tech enthusiasts is both fun and enriching. Wrapping it all with a vacation in such a lovely city such as Bristol is immensely satisfying. If you have the opportunity, I encourage you to attend this conference next year. I also think the organizers did a great job. I genuinely like the extra social session. The pub quiz, for instance, was perfect, though some of the code samples from it were as far from perfect as possible.

I have a lot to say about the content itself. I tend to believe I have more to say than you want to read. So let’s focus on some of the talks I think are most relevant:

C++ ranges and functional programming

The first session I want to discuss is about ranges in C++. Ivan Čukić gave an incredible talk. He demonstrated some splendid functional programming with C++. Ranges are actually quite simple. It is a struct containing an iterator and a sentinel value which mark where the iteration should stop. As a concept, we can already use it today, although it is planned to be a part of the standard library in C++ 20. While the idea is simple, it provides us with the capability to implement a very complex functional system, which was very enjoyable to see. I was impressed with the pipeline he demonstrated, and how flexible it is. It can support both async and sync programming. Even more impressive, he managed to introduce a process or even a machine boundary in the middle of the pipeline. A point I’m still not sure about yet is how simple it is to create an entirely lazy iterator. Meaning, we want to pay the price of computation only when the pipeline is actually being executed, and not during its declaration.

C++ error handling

The second talk by Herb Sutter. He discussed a new proposal for error handling. Today C++ error handling is painful, there aren’t any real best practices, and the community is greatly divided by various methods, which does not play nicely with each other. Making it one of the reason it is so hard to integrate libraries in C++. This issue alone is one of the major reasons I wanted to investigate Rust. The talk has shown a new suggestion Herb is working on making exception useful. I enjoyed hearing the exact points that bother me so much about C++ error handling today:

  1. Lack of conformity: Some use exception, some use types (similar to Rust ‘Error’ Type), and many still use plain old integer with error code (and out parameters for the real output blah!).
  2. Too many errors: Today, too many of the errors in C++ are not actual errors. Some errors should be caught by the compiler (e.g., out of boundary, lifetime issues), others should panic instead (failing to allocate an int with the global allocator). Some of those issues will be solved with the contract feature of C++.
  3. Lack of visibility of exception: Neglecting all other problems with exception (and there are many of them) exceptions suffers from a severe lack of visibility. It is not always obvious what can go wrong when integrating a new code. And it might be tough to handle all (mostly invisible) error flows.
  4. Performance – Exception today introduces performance penalty (Even if not being used).

The second and third points integrate poorly together. A program in C++, even in modern C++, suffers from an extreme number of hidden code path, representing error states, which just shouldn’t be there. These code path can’t be tested and usually are invisible to the programmer!

Herb’s suggestion was very interesting. I think it might actually work. First, he wants us to be explicit when a function can throw, with the throws keyword. Second, he wants to allow easy propagation of errors with the try keyword. He also wants to improve the performance of exceptions by making them statically allocated, and caught by value. Seeing the full suggestions, it looks very similar to Rust error handling. I assume that unlike Rust, the compiler won’t force us to handle the error case. Due to backward compatibility, I don’t think it would be mandatory to state if a function returns an error. The only hope is that those two features will be integrated into static analyzers, like clang tidy. Which is far from optimal, yet I think it can work, and finally allow a reasonable error handling for C++.

Monotron

The last talk for this post, given by Jonathan Pallant. It was about Rust, embedded Rust to be precise. The talk was about his monotron project, a simple 1980’s home computer style application [Pallant]. It involved two of my favorites topic: Rust and system programming. The talk started with the state of embedded rust, evidently making considerable strides to maturity. And it continues with his effort to add more and more features to a very limited hardware. A small spoiler, the results are amazing. This project is the ultimate proof of power for Rust. It demonstrates that Rust can be as fast as the hardware it runs on allows it to be. The kind of property any C++ developer looks when he considers an alternative programming language.

On Rust & C++

I must admit this conference set me thinking ab out the interaction between C++ and Rust. Yes, modern C++ is not news anymore, and I don’t believe it emerged because of Rust. I do think some Rust ideas manage to trickle into C++, yet I believe the actual impact on code abstraction itself is small. But C++ is going through additional change, one of mentality. It seems the community finally understands that, even with the right abstraction, a 1000-pages book of best practices just won’t do. We are human after all, as the wonderful Kate Gregory reminded us. It feels like the community is more and more open to breaking backward compatibility in order to simplify C++ and increase its safety. And weirdly, I think it is managing to find a way to break backward compatibility without breaking it. It seems like a Turing complete compile-time abstraction, together with a configurable compiler, is the answer. A very complicated answer to be sure, yet one where the average developer doesn’t need to be aware of its details. To sum it up, I have the feeling that the question: ‘Should I write my new project in C++ or Rust?’, is becoming more and more relevant every day. And the answer is getting more and more complex.

See the talks!

One last thing, the talks from the conference are uploaded to YouTube. Strongly recommended!

From Mathieu Ropert

First published at https://mropert.github.io/2019/04/19/accu_2019/

This year I was ready. I had prepared a stock of jokes about Britain, its food, its weather, the absence of good wine and the tumultuous relationship with the EU. It was time for ACCU 2019.

This year’s edition of the ACCU conference was held from April 10th to April 13th, in Bristol as always. I arrived a day earlier from Paris after a short stop in France, which was supposed to offer a supply of good weather and trips to a few winemakers in preparation for the harsh conditions of Great Britain.

From the start, things went awry as I could only spare half an hour for a visit to a winemaker in Vouvray who turned out to be quite forgettable, not to mention the weather that was only barely keeping it together. Still, I didn’t immediately notice that something was off, having spent the pasts months enduring the cold winter of Sweden. It took a second flight from Paris to Bristol to realize it: spring is there (although a couple of Bristol locals apologized for the weather being unexpectedly non-terrible).

Many meetings

My arrival was pretty unremarkable. It was, of course, raining and people still drove on the wrong side of the road. I had come across my former colleague Jonathan Boccara (of Fluent C++ fame [Boccara]) while waiting at my gate. We traded some war stories and he told me about his book, which he would be showing at the conference. I haven’t had the time to read it yet but I have already heard some positive feedback about it.

ACCU is, like most conferences, a good time for me to spend some time face-to-face with friends from the C++ community living around the world. It is sometimes said that there is more value in the discussions with the people you meet at conferences than with the conference content, and I would partly agree. Depending on the circumstances, I do feel like the bulk of the value falls slightly one side or the other. At times there’s a presentation that justifies the whole ticket in itself; sometimes I meet someone and have a discussion that is as valuable to me as the sum of all the talks I attend.

The other reason I often see so many familiar faces is that, in my opinion, people don’t try to attend conferences nearly enough. After asking around a bit, it does seem like I’m not the only one to have noticed that. Regardless of the company, there will be a small minority who ask their manager to be sent there, and a large majority who will never do so. I am not sure how to explain it. Not feeling like it’s worth the time? Thinking it’s only for some ‘elite’? Maybe simply too focused on the day-to-day job, on the next deadline?

I don’t claim to have the answer, but I will certainly encourage anyone who never asks to go to do so, and those who do to encourage their colleagues to do the same. We are always happy to see new faces, meet new people and buy them a drink at the conference bar at the end of the day.

Keynotes

As I mentioned in my trip report last year [Ropert18], I was a bit disappointed by ACCU 2018’s opening keynote. This time was quite the opposite. ACCU 2019 opened with M. Angela Sasse telling us about security. The key takeaway was that the human, the user, will always be the weak link regardless of the technology deployed. More importantly, the fact that security is everyone’s business and not just the IT department’s means it must offer a good UX else it will be badly used or worked around. This was pointed out in the 90s and it still hold true today, with sadly little progress to show for it.

The great Herb Sutter travelled from his Redmond office to England to tell us about his vision for the future of error handling in C++. While I already knew about his work on the matter (it was sent to SG14 for review a couple months back), it was nice to have a refresher in front of the whole conference. In short, the direction is toward better exceptions, with bounded, predictable throw and catch times. No more need for dynamic allocation. No extra cost when no exceptions occur (this is already mostly the case on x86_64) and a push for noexcept becoming the default unless otherwise specified.

The closing keynote was given by none other than Kate Gregory, who walked us through a nice lecture on code empathy, or how to read the previous programmer’s emotions through existing code, trying to understand what triggered those emotions and how to react when confronted by them. I have a hunch that it will be a nice complement to Jonathan’s book on how to deal with legacy code, as the two seem closely related.

Talks

At the rate of three talks a day outside keynotes, there was a total of 12 I could potentially attend during the conference. Subtract one because I had to attend mine and perhaps another one where I was busy writing slides and we get a rough estimate of about 10. While that number could make for a nice clickbait section (‘10 ACCU talks you won’t believe I attended’), I will stick to my boring routine of mentioning the ones I remember the most. Also keep in mind that there were 5 tracks, meaning I saw roughly 17% of the conference content.

The two talks that made the biggest impression on me were Vittorio Romeo’s ‘Higher-order functions and function_ref’ and Andreas Weiss’ ‘Taming Dynamic Memory – An Introduction to Custom Allocators’. The first one did a good job of explaining what higher-order functions are and also the content and benefits of the function_ref proposed addition to the C++ standard, all in one session. The second one offered a good tour of custom allocators, how they work and when they can be considered to replace the standard ones. Both presenters also had to accomplish their tasks while fending off the many questions coming from John Lakos, who sat on the first row each time (a victory he congratulated them for at the end).

The next two talks that come to mind are Peter Bindel’s and Simon Brand’s ‘Hello world from scratch’, and Andy Balaam and CB Bailey’s ‘How does git actually work?’. Both explained things we do every day by taking a very simple use case (building a very simple program and committing some changes to a VCS) and showing what happens under the hood. They also both ran out of time before showing all they had planned because it turns out abstraction is no myth: even our simplest tasks are actually fairly complex when you look at how they are done. I think they both did a good job of it and would gladly schedule both in a ‘how does XXX work’ track. That is a good theme that I would suggest having at every conference.

Next up is Kevlin Henney’s ‘What do you mean?’. Kevlin is quite the celebrity in Bristol and I really liked his talk at the previous conference. While perhaps not as remarkable (I would have appreciated a clearer outline to follow), this one was still quite interesting. The main point was that meaning is derived from both what is said or written and the context that surrounds it. The latter being subjective, it implies a bunch of assumptions by both parties that, when not in line, lead to quite a misunderstanding. The main obstacle to solving that problem is that assumptions are, by definition, implicit and so can only be discovered when proved wrong (‘Oh, but I assumed that…’). This of course brings us back to the software craftsmanship practices of frequent iterative deliveries and testing.

Finally I’d like to mention Christopher Di Bella’s ‘How to Teach C++ and Influence a Generation’. Last year, Christopher started SG20, a study group in the standard committee focused on education. Education and teaching is an important subject to me, partly because of my own personal experience of learning C++ in school, then learning another language also called C++ around 5–10 years later. As you may guess, the first one was more in the line of ‘C with classes’ while the second looked more like the C++ we know and recommend today. To that end, the group has worked on some guidelines on how to write teaching materials. They also run polls to better understand how and when people learn C++. A good complement to this talk would be Bjarne’s keynote at CppCon 2017 Learning and Teaching Modern C++.

Lightning talks

One of the best things at ACCU is how the lightning talks sessions are organized. They are simply done in the keynote room as the closing session of each day. That way, most of the conference attends before going out for beers or dinner. The programme is usually decided between the day before and a couple hours before the session, meaning last minute entries are definitely an option.

It’s a great opportunity to bring up a point you had in mind but couldn’t get in as a talk, respond to a previous talk (or lightning talk) or simply raise awareness in the community on a particular matter. For example, upon arriving in Bristol on Tuesday I learnt that the great people from the Paris meetup were planning to announce a new conference [CPPP]. I put a few slides together, slipped in a joke or two about English food and Brexit, then went up on stage on Wednesday to tell everyone about CPPP.

Of all the C++ conferences I go to, I think this formula works best and is one of the reasons ACCU feels like a big family gathering. If you are a conference organizer and have some lightning talk sessions, I strongly suggest you consider this option. It might feel intimidating to step up on stage in front the entire conference, but then again, I feel the familial atmosphere helps in reducing the pressure.

Until next time

On Friday I gave my talk, ‘The State of Package Management in C++’. Frequent readers of my blog will probably be familiar with the topic. I gave a tour of package management in C++, why we want it and how far we’ve come yet (spoiler warning: enough for you to try it). As you can see, the ACCU has made a fantastic job of uploading the recording on YouTube in less than a week.

But the greatest learning of all for me came after the conference, when I discovered that airlines will now charge you £50 when boarding your plane for bringing a laptop bag with your carry-on luggage. I used to do that all the time, but today it appears you can be charged extra depending on the mood. I suppose next time I will have to put my stuff in cargo .

Do not let that stop you from attending conferences though, I still hope to see you there!

From Anthony Williams

First published on Anthony’s ‘Just Software Solutions’ blog on 22 April 2019 at https://www.justsoftwaresolutions.co.uk/news/accu-2019-report.html.

I attended ACCU 2019 a couple of weeks ago, where I was presenting my session ‘Here’s my number; call me, maybe’. Callbacks in a multithreaded world.

The conference proper started on Wednesday, after a day of pre-conference workshops on the Tuesday, and continued until Saturday. I was only there Wednesday to Friday.

Wednesday

I didn’t arrive until Wednesday lunchtime, so I missed the first keynote and morning sessions. I did, however get to see Ivan Čukić presenting his session on ‘Ranges for distributed and asynchronous systems’. This was an interesting talk that covered similar ground to things I’ve thought about before. It was good to see Ivan’s take, and think about how it differed to mine. It was also good to see how modern C++ techniques can produce simpler code than I had when I thought about this a few years ago. Ivan’s approach is a clean design for pipelined tasks that allows implicit parallelism.

After the break, I went to Gail Ollis’s presentation and workshop on ‘Helping Developers to Help Each Other’. Gail shared some of her research into how developers feel about various aspects of software development, from the behaviour of others to the code that they write. She then got us to try one of the exercises she talked about in small groups. By picking developer behaviours from the cards she provided to each group, and telling stories about how that behaviour has affected us, either positively or negatively, we can share our experiences, and learn from each other.

Thursday

First up on Thursday was Herb Sutter’s keynote: ‘De-fragmenting C++: Making exceptions more affordable and usable’. Herb was eloquent, as always, talking about his idea for making exceptions in C++ lower cost, so that they can be used in all projects: a significant number of projects currently ban exceptions from at least some of their code. I think this is a worthwhile aim, and hope to see something like Herb’s ideas get accepted for C++ in a future standard.

Next up was my session, ‘Here’s my number; call me, maybe. Callbacks in a multithreaded world’. It was well attended, with interesting questions from the audience. My slides are available [Williams19] and the video is available on youtube. Several people came up to me later in the conference to say that they had enjoyed my talk, and that they thought it would be useful for them in their work, which pleased me no end: this is what I always hope to achieve from my presentations.

Thursday lunchtime was taken up with book signings. I was one of four authors of recently published programming books set up in the conservatory area of the hotel to sell copies of our books, and sign books for people. I sold plenty, and signed more, which was great.

Kate Gregory’s talk on ‘What Do We Mean When We Say Nothing At All?’ was after lunch. She discussed the various places in C++ where we can choose to specify something (such as const, virtual, or explicit), but we don’t have to. Can we interpret meaning from the lack of an annotation? If your codebase uses override everywhere, except in one place, is that an accidental omission, or is it a flag to say ‘this isn’t actually an override of the base class function’? Is it a good or bad idea to omit the names of unused parameters? There was a lot to think about with this talk, but the key takeaway for me is ‘Consistency is Key’: if you are consistent in your use of optional annotations, then deviation from your usual pattern can convey meaning to the reader, whereas if you are inconsistent then the reader cannot infer anything.

The final session I attended on Thursday was the ‘C++ Pub Quiz’, which was hosted by Felix Petriconi. The presented code was intended to confuse, and elicit exclamations of ‘WTF!’, and succeeded on both counts. However, it was fun as ever, helped by the free drinks, and the fact that my team ‘Ungarian Notation’ were the eventual winners.

Friday

Friday was the last day of the conference for me (though there the conference had another full day on Saturday). It started with Paul Grenyer’s keynote on the trials and tribulations of trying to form a ‘community’ for developers in Norwich, with meet-ups and conferences. Paul managed to be entertaining, but having followed Paul’s blog for a few years, there wasn’t anything that was new to me.

‘Interactive C++: Meet Jupyter / Cling – The data scientist’s geeky younger sibling’ was the next session I attended, presented by Neil Horlock. This was an interesting session about cling, a C++ interpreter, complete with a REPL, and how this can be combined with Jupyter notebooks to create a wiki with embedded code that you can edit and run. Support for various libraries allows to write code to plot graphs and maps and things, and have the graphs appear right there in the web page immediately. This is an incredibly powerful tool, and I had discussions with people afterwards about how this could be used both as an educational tool, and for ‘live’ documentation and customer-facing tests: ‘here is sample code, try it out right now’ is an incredibly powerful thing to be able to say.

After lunch I went to see Andreas Weis talk about ‘Taming Dynamic Memory – An Introduction to Custom Allocators’. This was a good introduction to various simple allocators, along with how and why you might use them in your C++ code. With John Lakos in the front row, Andreas had to field many questions. I had hoped for more depth, but I thought the material was well-paced, and so there wouldn’t have been time; that would have been quite a different presentation, and less of an ‘introduction’.

The final session I attended was ‘Elsewhere Memory’ by Niall Douglas. Niall talked about the C++ object model, and how that can cause difficulties for code that wants to serialize the binary representation of objects to disk, or over the network, or wants to directly share memory with another process. Niall is working on a standardization proposal which would allow creating objects ‘fully formed’ from a binary representation, without running a constructor, and would allow terminating the lifetime of an object without running its destructor. This is a difficult area as it interacts with compilers’ alias analysis and the normal deterministic lifetime rules. However, this is an area where people currently do have ‘working’ code that violates the strict lifetime rules of the standard, so it would be good to have a way of making such code standards-conforming.

Between the sessions

The sessions at a conference at ACCU are great, and I always enjoy attending them, and often learn things. However, you can often watch these on Youtube later. One of the best parts of physically attending a conference is the discussions had in person before and after the sessions. It is always great to chat to people in person who you primarily converse with via email, and it is exciting to meet new people.

The conference tries to encourage attendees to be open to new people joining discussions with the ‘Pacman rule’ – don’t form a closed circle when having a discussion, but leave a space for someone to join. This seemed to work well in practice.

I always have a great time at ACCU conferences, and this one was no different.

References

[Asproni19] Giovanni Asproni, ‘One Team, Two Teams, Many Teams: Scaling Up Done Right’, https://www.meetup.com/Agile-Bath-Bristol/events/260202604/

[Boccara] Jonathan Boccara, Fluent {C++}, https://www.fluentcpp.com/

[CPPP] CPPP Conference, 15 June 2019, Paris: https://cppp.fr/

[Davis19] ‘The Pac-Man Rule’: https://conference.accu.org/pacman_rule.html

[Echoborg] Echoborg: http://www.echoborg.com/

[Microsoft] ‘Introducing Time Travel Debugging for Visual Studio Enterprise 2019’, https://devblogs.microsoft.com/visualstudio/introducing-time-travel-debugging-for-visual-studio-enterprise-2019/

[Pallant] Jonathan Pallant, ‘Monotron’, https://github.com/thejpster/monotron

[Parent] Sean Parent, Foster Brereton and Felix Petriconi (date unknown), ‘Concurrency’ on the stlab website: http://stlab.cc/libraries/concurrency/

[Ropert18] Mathieu Ropert, ‘ACCU 2018 trip report’, posted 20 Apr 2018 at https://mropert.github.io/2018/04/20/accu_2018/

[Sutter18] Herb Sutter, ‘Zero-overhead deterministic exceptions: Throwing values’, P0709 R2, http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0709r2.pdf

[Williams19] Anthony Williams, ‘Here’s my number; call me, maybe. Callbacks in a multithreaded world’ (slides), https://www.justsoftwaresolutions.co.uk/files/heres_my_number.pdf

Felix Petriconi Felix studied electrical engineering and has been a programmer since 1993. He is a programmer and development manager at the MeVis Medical Solutions AG in Bremen, Germany, where he develops radiological medical devices. A regular speaker at the C++ user group in Bremen and a member of the ACCU’s conference committee.

Stefan Turalski Stefan is a software developer who, contrary to common sense and fond memories of working for a software house, still makes bits flow between various financial institutions. Incurable optimist, mechanical sympathiser, who believes it’s possible to learn to play piano, Clojure, Haskell or even C++ one day, hence takes it easy coding in C#.

Ori Ben-Shir Ori is currently a C++ software engineer at SentinelOne. Learning the Rust programming language, and documenting the experience in his blog, ‘Afternoon Rusting’. Passionate about programming languages, exploring their implementation and how language authors shape the way we code with their design choices.

Mathieu Ropert Mathieu has worked in various areas, ranging from kernel programming to web development, financial software, databases and videogames. His current favourite subject is package management, and he thinks the lack of it has been holding back C++ for years now..

Anthony Williams Anthony is the author of C++ Concurrency in Action. As well as working on multi-threading libraries, he develops custom software for clients, and does training and consultancy. Despite frequent forays into other languages, he keeps returning to C++. He is a keen practitioner of TDD, and likes solving tricky problems.

Letters to the Editor + Overload Journal #151 - June 2019