I’m writing this on the journey home after attending C++Now 2018. It’s been a long week, but also a rewarding one. This is my second time attending the conference, and like last year, it was excellent. The quality of content at C++Now is just outstanding. Conference chair Jon Kalb is fond of saying,

To hear the answer to a C++ question, go to CppCon. If you want to be part of finding the answer, go to C++Now.

C++Now is a conference like no other. There’s a unique and special quality about it that’s difficult to describe — it’s something you have to experience for yourself to appreciate. Sessions are held at the Aspen Center for Physics, and most attendees stay at the Aspen Meadows Resort, which is an easy walking distance from the ACFP. The entire site is surrounded by the mountains of Aspen, and the Roaring Fork River runs along the northeastern border of the resort. I stayed in Mallot House in a room facing toward the river, and with my room windows open, I could hear it at night. Attending C++Now is like being in college again but with only the good parts: walking back and forth to class with your backpack in what is about the most gorgeous setting you can imagine; attending the sessions you want to attend while goofing off with old friends and making new ones; and most importantly, intense learning without the hassle of exams.

Standout Talks

There are three simultaneous tracks at C++Now, and they provide an embarrassment of riches to choose from. Several times during the week I had to decide between two or three talks that I really wanted to attend; this was even the case for my own talks. Fortunately, all the sessions are recorded by Bash Films, who do a first-rate job of recording and post-production, and will be available soon on YouTube.

That being said, of the talks I attended, there were a few that really stood out in my mind.

The first was the opening keynote, The Shape of a Program, by Lisa Lippincott. Lisa has a Ph.D. in mathematics, and the subject of the talk was how one could employ the mathematics of topology to describe a program as a shape (a bitopological manifold to be precise). Lisa is a great speaker, and the diagrams and analogies she used during the lecture really made me feel like I understood the topic. This is one of those talks that left me wanting to learn more about math so that I could gain a deeper insight into the formal basis for believing that my programs work correctly.

I greatly enjoyed An Allocator is a Handle to a Heap by my friend Arthur O’Dwyer. Arthur and I have spent a fair amount of time discussing synthetic pointers and allocators, and I usually end up agreeing with him (which can be quite annoying). For me, the most important takeaway of this talk is spelled out in its title: an allocator is a handle to a memory resource, and therefore allocator classes should be implemented in terms of lightweight value types which themselves implement the handle concept. Arthur’s reasoning is impeccable, and I always learn something from his talks.

Matthew Butler is a world-class cyber security expert, and his talk Secure Coding Practices: Your First Line is The Last Line of Defense was a real eye-opener for me. I had not realized how easy it was/is for simple coding mistakes to allow attackers to gain control of a system. All eyes were glued to the screen when Matthew performed a live demo of gaining root access to a Linux VM by using a buffer overrun exploit. This is material that every C++ programmer should know about, and I strongly recommend watching his talk.

I would have to say that my favorite non-me talk of the week was Easy to Use, Hard to Misuse: Declarative Style in C++ given by Ben Deane. In this talk, Ben describes what “declarative style” means, gives a number of motivating examples, and explains why declarative interfaces provide several desirable properties that help make our software more readable, maintainable, and correct. Ben’s presentation was voted “Most Inspiring Talk” by attendees this year, and it is one that I’ll definitely watch again when it’s available on YouTube. As with Lisa’s talk, this talk has inspired me to devote time to understanding the declarative style of programming, and finding a way to use it more frequently in my day job.

As I mentioned, these are the talks I attended that really stand out in my mind, but you can bet I’ll be watching many more when they’re available on YouTube.

My Talks

As far as my talks go, I was fortunate to present three full-session talks this year, and they all seemed to be well-received (i.e., no one threw anything at, and very little blood was shed). PDFs of the slides from all of my talks, along with source code and other supporting materials are available on my GitHub site. I’ll post links to the videos here once they’ve been uploaded to YouTube.

There was some interest in my experimental UTF-8 decoding library, which I described in my Monday morning presentation. I’ve achieved some pretty good performance on typical web page decoding scenarios, ranging from a few times faster to an order of magnitude faster than iconv. I published a source code snapshot after my talk, and several people from the SG-16 Slack group were able to duplicate my results on various platforms.

Except for hardcore allocator developers and performance seekers, most people don’t have a need for synthetic pointers.  Synthetic pointers are a bit like parachutes — you don’t need them very often, but when you do…  Nevertheless, I got a nice response from the audience on Tuesday morning during a live demonstration in which I created a map<string,list<string>> in a self-contained relocatable heap, memcpy‘d the heap to a new location, and then traversed the map at the new location, printing its contents along the way.

I received some great feedback and a fair amount of hallway debate after my Wednesday morning talk, in which I pontificated for several minutes before presenting a design sketch of what a set of new standard containers might look like if I had my way. I was pleasantly surprised in the hallway discussions when some of the “more senior” engineers in the audience appreciated my comments on the importance of clear thinking and meaningful naming.

Summary and Recommendation

I highly recommend C++Now to anyone who really wants to learn more (much more) about C++. This conference provides a unique opportunity to interact with compiler writers, library maintainers, committee members, and many others with a deep and abiding interest in C++. From what I’ve experienced, all the attendees share a sense of common purpose — that we go to Aspen to learn from each other, and to help each other learn.

And finally, I’d like to extend a big thanks to Program Chair Bryce Adelstein Lelbach, for once again coordinating a stellar program; and an especially big thanks to Conference Chair Jon Kalb, for pulling it all together and making it look easy while doing so.

Thanks for stopping by.


3 thoughts on “C++Now 2018 Trip Report

  • 2018-05-30 at 2:53 pm

    Hi Bob,

    Great result on your UTF conversion performance! Enjoyed your talk.

    I noticed that when your SSE goes bad it is still pretty good, within a factor of 2, of your base. I added a double look-ahead plus an NVRO length from the SSE conversion and this improved the mean across your g++ suite of 8->32 UTF by about 5% with the same O3 Westmere setup. Interestingly, some larger improvements were in Japanese_wiki (>10%), stress_test_2 (> 40%), and z1_kosme (>20%).

    A lookahead of three or four wasn’t as good across the set though some individual tests liked it, FWIW.

    HTH. All the best,

    KEWB_ALIGN_FN std::ptrdiff_t
    UtfUtils::SseBigTableConvert(char8_t const* pSrc, char8_t const* pSrcEnd, char32_t* pDst) noexcept
    const char32_t* pDstOrig = pDst;
    char32_t cdpt;
    bool OK = (*pSrc < 0x80);
    char8_t const* pSrcEnd_penultimate = (pSrcEnd – sizeof(__m128i));

    while (pSrc < pSrcEnd_penultimate)
    if (OK)
    OK = ((16 == ConvertAsciiWithSse(pSrc, pDst)) && (*pSrc < 0x80 && *(pSrc+1) < 0x80));
    if (AdvanceWithBigTable(pSrc, pSrcEnd, cdpt) != ERR)
    *pDst++ = cdpt;
    return -1;
    OK = (*pSrc < 0x80 && *(pSrc+1) < 0x80);

  • 2018-05-30 at 3:33 pm

    Matt, thanks for the kind words and also for your suggested changes! Lookahead greater than one has been on my list of things to try someday, although at a lower priority than futzing with the tables. I assumed that adding extra branches for lookahead would make things slower. If this performance gain holds across the board, then this looks to be the next big improvement.


  • Pingback: C++Now 2018 Talk: Secure Coding Best Practices – Madd Physics

Leave a Reply

Your email address will not be published. Required fields are marked *