GoingNative 2013 will be held on September 4-6. Register soon -- in-room space is limited.

The day 1 and 2 talks have now been posted:

Opening Keynote (Bjarne Stroustrup, Texas A&M University)

Bjarne Stroustrup, creator of C++, will open the show.

C++ Seasoning (Sean Parent, Adobe)

A look at many of the new features in C++ and a couple of old features you may not have known about. With the goal of correctness in mind, we’ll see how to utilize these features to create simple, clear, and beautiful code. Just a little pinch can really spice things up.

Writing Quick Code in C++, Quickly (Andrei Alexandrescu, Facebook)

Contemporary computer architectures make it possible for slow code to work reasonably well. They also make it difficult to write really fast code that exploits the CPU amenities to their fullest. And the smart money is on fast code -- we’re running out of cool things to do with slow code, and the battle will be on doing really interesting and challenging things at the envelope of what the computing fabric endures.

So how to write quick code, quickly? Turns out it’s quite difficult because today’s complex architectures defy simple rules to be applied everywhere. It is not uncommon that innocuous high-level artifacts have a surprisingly high impact on the bottom line of an application’s run time (and power consumed).

This talk is an attempt to set forth a few pieces of tactical advice for writing quick code in C++. Applying these is not guaranteed to produce optimal code, but is likely to put it reasonably within the ballpark.

These tips are based on practical experience but also motivated by the inner workings of modern CPUs.

Don’t Help the Compiler (Stephan T. Lavavej, Microsoft)

C++ has powerful rules for dealing with low-level program structure. Before a program is ever executed, the compiler determines valuable information about every expression in the source code. The compiler understands exactly how long each object's resources will be needed (lifetime), whether each expression refers to an object that the program has no other way of accessing (rvalueness), and what operations can be performed on each object (type). Using examples from C++98 through C++14, this presentation will demonstrate how to write code that works with the compiler's knowledge to increase robustness, efficiency, and clarity. This presentation will also demonstrate the horrible things that happen when programmers think they can do tasks that are better left to compilers.

Day 1 Panel (all speakers)

Interactive panel. Topic TBD. Attendee-driven Q&A.

Day 2 Keynote: One C++ ( Herb Sutter, Microsoft)

Herb Sutter, language architect of Visual C++ and Chairman of the ISO C++ Committee, opens Day 2 with a brand new talk, "One C++."

An Effective C++11/14 Sampler (Scott Meyers)

After years of intensive study (first of C++0x, then of C++11, and most recently of C++14), Scott thinks he finally has a clue. About the effective use of C++11, that is (including C++14 revisions). At last year’s Going Native, Herb Sutter predicted that Scott would produce a new version of Effective C++ in the 2013-14 time frame, and Scott’s working on proving him almost right. Rather than revise Effective C++, Scott decided to write a new book that focuses exclusively on C++11/14: on the things the experts almost always do (or almost always avoid doing) to produce clear, efficient, effective code. In this presentation, Scott will present a taste of the Items he expects to include in Effective C++11/14. If all goes as planned, he’ll also solicit your help in choosing a cover for the book.

C++14: Through the Looking Glass (Michael Wong, IBM)

“The time has come,” the ISO said,

“To talk of many things:

Of move-capture -- and literals --

Of making lambdas sing --

And why deduction is so hot --

nd if digits should grow wings?”

So have you heard of the next C++ Standard? No, it is not C++11. Even though C++11 has just been ratified, C++14 will likely replace C++11 by next year. By now, we have enough experience with C++11 to know where we are missing various fingers and toes such as:

Why do we not have move capture in lambdas?

How about some real user-defined literal suffixes?

Why did we stop with monomorphic lambdas?

If lambda returns can be deduced, why not normal functions?

Could we get digit separators?

C++14 will be more than a bug-fix release, and will contain some important enhancements on top of C++11. It will remove some of the major annoyances from C++11, that we already know of. But more importantly, how will this change the language, library and some important idioms?