C++ and Beyond

To get the most out of my talks at this year’s C&B, it will be helpful to acquire some background information in advance.

For Adventures in Perfect Forwarding, I’ll essentially assume you know the fundamentals of move semantics, i.e., lvalues vs. rvalues, rvalue references, and the behavior of “T&&” parameters in function templates.  (The talk actually contains what I call a “micro-review” of these topics, but it’s very short.)  There is lots of information about move semantics and its underlying technology scattered about the Internet, but one source I like to point people to is Thomas Becker’s C++ Rvalue References Explained.  Another good choice is Stephan T. Lavavej’s blog entry devoted to the topic.

My talk on the C++0x Memory Model doesn’t really assume much background beyond a familiarity with the existence of multithreaded code, but if you’d like to familiarize yourself with some of the key motivating issues I’ll be addressing, I recommend the article on Double-Checked Locking that Andrei and I wrote in 2004.  That article will also introduce you to the double-checked locking pattern, which I’ll briefly discuss in the talk.

See you soon!

Scott

PS - It has occurred to me recently that C++ doesn’t seem to have a name for “T&&” parameters in function templates.   Sometimes I see people refer to them as rvalue reference parameters, but that’s both wrong and misleading:  they may or may not be rvalue reference parameters in the functions generated from the template.  Orally, I tend to refer to them as “T ref ref” parameters, and you can see that I refer to them in writing as “T&&” parameters, but I think we really need a standard term for them.  Maybe “universal reference parameters” (because they become either T& or T&& parameters in functions instantiated from the template)?  What do you think?

The full C++ and Beyond Schedule has been finalized, updated, and posted.

Download the schedule in PDF format here.

Also, just a reminder that tomorrow (Sunday, July 31st) is the deadline to purchase your ticket - we have 9 spots remaining.

I look forward to meeting you all in Banff!

Lisa

Session update: It turns out there’s a lot to say about both C++0x best practices and optimal GPGPU coding once you get going. So my talks on C++0x (C++ Renaissance, and How To Teach C++) and GPU programming (C++ and the GPU… and Beyond) have grown considerably longer and in-depth than I initially expected. There’s only so much speaking time, so something had to give, and I’ve chosen to defer the “Exceptional C++0x” talk itself to a future event.

The good news is that I found a way to have most of the cake and eat it too — I’ll still cover much of the material I intended for that talk in the context of “How To Teach C++” which targets C++0x, and the main difference will be that the examples won’t be drawn directly from my Exceptional C++ books this time. I look forward to revisiting the Exceptional C++ material itself at a future event.

The registration deadline for C&B in Banff is less than a week away: it’s this coming Sunday, July 31.  (You know, the end of the month.)  At this moment, there are 11 spots remaining, so there’s still space for you, but time is of the essence.  If you’re a last-minute registration kind of person, well, the last minute is pretty seriously nigh.

The registration page for C&B is here.

Andrei, Herb, and I look forward to seeing you in Banff.

Scott

Variadic templates are arguably the most profound change in the core language brought about by C++0X. Curiously, however, the C++ community still tiptoes carefully around them: variadic templates enjoyed less coverage than features such as “auto” or lambdas. Part of the reason is that more popular features simplify expression of existing designs, which makes said features easier to understand and use. Variadic templates, however, not only simplify design and use of advanced libraries such as Boost MPL, but also enable a host of new uses.

This class provides a solid coverage of variadic fundamentals, including typelists, the archetypal “safe printf” mechanics, and tuple construction and access. It also discusses more advanced uses, such as structured argument lists.

A function with a structured argument list accepts variadic arguments that have a structure to them, most often expressible as a regular expression. For example, a function may accept argument lists of the form (string, string, int, string, int, string, …), i.e. two strings followed by any number of int and string pairs. Structured argument lists are very useful in supporting implementation of fast, expressive algorithms and for defining a variety of useful abstractions.

Reply to this post if there are any particular aspects of variadic templates you’d like to see covered. Also don’t forget there are only a few seats left, so register soon if you haven’t. See you all soon!

C&B 2011 is now 90% sold out, meaning there are only 10 seats remaining.  As I’ve said before, the number of slots will not be increased, so 10 seats remaining means just that:  only 10 more places.   Registration is slated to run through the end of the month, but a sellout looks likely; we’ll probably run out of available places before we run out of days to register.  I therefore encourage you to register as soon as possible.

Scott

With the C++ Renaissance gathering steam, I’ve personally noticed a growing need to train developers who are now turning or returning to C++. These developers don’t need to be taught how to program, but they aren’t familiar with how clean it is to write code using today’s C++. The key is: What is the best and clearest way to teach the essentials of today’s C++ — both what to teach, and what not to teach?

This session shows that it is possible to show a very clean path through today’s C++ that is available to production developers right now, including use of key C++0x features already supported in many compilers, that shows how clean C++ code can be and how it compares favorably to code written in managed languages while still retaining its longstanding efficiency advantage.

Many attendees coming to C++ and Beyond are experienced developers, often in senior or leadership positions. Your company may look to you to define or personally provide training in the best development techniques, whether through team brownbags or formal training sessions. As developers continue to come back to C++, you will find yourself increasingly called upon to help them quickly learn what “modern C++” really means today, and how clear and compelling it can be. This “train the trainers” session is intended to provide the foundation for that training, and give you the tools you need to train others, as we welcome them (and welcome them back) to our good friend C++.