Anthony Williams from Just Software Solutions Blog
I attended ACCU 2019 a couple
of weeks ago, where I was presenting my
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.
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
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 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 then went to Gail Ollis's presentation and workshop
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
First up on Thursday was Herb Sutter's
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
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
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
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
explicit), but we don't have
to. Can we interpret meaning from the lack of an annotation? If your codebase
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 was the last day of the conference for me (though there the conference
had another full day on Saturday). It started with Paul
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
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
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
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
Posted by Anthony Williams
[/ news /] permanent link
Tags: C++, accu, parallelism, callbacks, multithreading
Stumble It! | Submit to Reddit | Submit to DZone
Comment on this post
Follow me on Twitter