November 2010

In my October talk on move semantics, I explained that the status of the implicit generation of move operations was not yet settled.  At the C++ standardization meeting earlier this month, the rules in this area were changed somewhat.  For details, consult Anthony Williams’ post to comp.lang.c++ on this topic.  For my December presentation, I’ll update my talk to reflect this new information.  I’m also going to add some additional material on perfect forwarding, because we tinkered with the daily schedule such that I’ll have an extra 15 minutes, and I didn’t have as much time as I’d have liked to talk about perfect forwarding.

Speaking of the December C&B, registration will close this coming Monday morning (at 9:30AM Pacific Time, if you really want to do things at the last minute).  That’s right before I deliver the PDFs to the printer.  There are currently 40 people signed up, so it looks like the Encore! edition of this event will be even more intimate than the October version.  If you’re interested in being part of it, be sure to sign up by Monday morning!



Personal note: Following the C++ and Beyond seminar in October, I decided to replace the session “A Fresh Look at Containers and Iterators”. This is because the topic, albeit generous, has limited immediate applicability. Although the C++ community has considerable interest in packing iterators together in ranges and using range-oriented algorithms (per abstractions present in Boost and Adobe), mainstream use of STL remains through iterators. The new material concerns a much more immediate concern of C++ programmers.


STL’s performance has been satisfactory for a large range of applications. However, when using STL in large scale programs that have large tight performance programs, special care needs to be taken that doesn’t apply to smaller data sets. Amortized constant time is not terribly useful if multiplied by a constant that makes your application run forever. Doubling the size of a vector has unexpected effects. STL’s node allocation policy, while useful at small scale, may badly hurt performance. The allocator interface is unable to perform in-place reallocation. Even using realloc for moveable types is suboptimal. Finally, all stock allocators are very coy about releasing back memory to the operating system, which creates odd problems in long-running programs. This talk focuses on concrete tips for using STL (and C++ collections in general) scalably.

If you attended C&B last month, be on the lookout for an email message we just sent that contains a link to the PDF for updated session handouts.  These handouts reflect any changes we made to the materials either during C&B or afterwords, based on our experience with them.  The email also contains a link to a short survey about C&B, as well as information on how you can opt in to sharing your contact information with other C&B participants.

I’ll also take this opportunity to remind you that Early Bird registration for C++ &  Beyond Encore! in December expires on Sunday night, so if you want to get in under the wire, be sure to register this weekend!