Download the slides.

Abstract:

This session in one word: Deep.

It's a session that includes topics I've publicly said for years is Stuff You Shouldn't Need To Know and I Just Won't Teach, but it's becoming achingly clear that people do need to know about it. Achingly, heartbreakingly clear, because some hardware incents you to pull out the big guns to achieve top performance, and C++ programmers just are so addicted to full performance that they'll reach for the big red levers with the flashing warning lights. Since we can't keep people from pulling the big red levers, we'd better document the A to Z of what the levers actually do, so that people don't SCRAM unless they really, really, really meant to.

Topics Covered:

• The facts: The C++11 memory model and what it requires you to do to make sure your code is correct and stays correct. We'll include clear answers to several FAQs: "how do the compiler and hardware cooperate to remember how to respect these rules?", "what is a race condition?", and the ageless one-hand-clapping question "how is a race condition like a debugger?"
• The tools: The deep interrelationships and fundamental tradeoffs among mutexes, atomics, and fences/barriers. I'll try to convince you why standalone memory barriers are bad, and why barriers should always be associated with a specific load or store.
• The unspeakables: I'll grudgingly and reluctantly talk about the Thing I Said I'd Never Teach That Programmers Should Never Need To Now: relaxed atomics. Don't use them! If you can avoid it. But here's what you need to know, even though it would be nice if you didn't need to know it.
• The rapidly-changing hardware reality: How locks and atomics map to hardware instructions on ARM and x86/x64, and throw in POWER and Itanium for good measure – and I'll cover how and why the answers are actually different last year and this year, and how they will likely be different again a few years from now. We'll cover how the latest CPU and GPU hardware memory models are rapidly evolving, and how this directly affects C++ programmers.

Part 1 -> Optimizations, races, and the memory model; acquire and release ordering; mutexes vs. atomics vs. fences

Download the slides.

Abstract:

This session in one word: Deep.

It's a session that includes topics I've publicly said for years is Stuff You Shouldn't Need To Know and I Just Won't Teach, but it's becoming achingly clear that people do need to know about it. Achingly, heartbreakingly clear, because some hardware incents you to pull out the big guns to achieve top performance, and C++ programmers just are so addicted to full performance that they'll reach for the big red levers with the flashing warning lights. Since we can't keep people from pulling the big red levers, we'd better document the A to Z of what the levers actually do, so that people don't SCRAM unless they really, really, really meant to.

Topics Covered:

• The facts: The C++11 memory model and what it requires you to do to make sure your code is correct and stays correct. We'll include clear answers to several FAQs: "how do the compiler and hardware cooperate to remember how to respect these rules?", "what is a race condition?", and the ageless one-hand-clapping question "how is a race condition like a debugger?"
• The tools: The deep interrelationships and fundamental tradeoffs among mutexes, atomics, and fences/barriers. I'll try to convince you why standalone memory barriers are bad, and why barriers should always be associated with a specific load or store.
• The unspeakables: I'll grudgingly and reluctantly talk about the Thing I Said I'd Never Teach That Programmers Should Never Need To Now: relaxed atomics. Don't use them! If you can avoid it. But here's what you need to know, even though it would be nice if you didn't need to know it.
• The rapidly-changing hardware reality: How locks and atomics map to hardware instructions on ARM and x86/x64, and throw in POWER and Itanium for good measure – and I'll cover how and why the answers are actually different last year and this year, and how they will likely be different again a few years from now. We'll cover how the latest CPU and GPU hardware memory models are rapidly evolving, and how this directly affects C++ programmers.

Part 2 -> Restrictions on compilers and hardware (incl. common bugs); code generation and performance on x86/x64, IA64, POWER, ARM, and more; relaxed atomics; volatile

See part 1: Name Lookup
See part 2: Template Argument Deduction
See part 3: Overload Resolution
See part 4: Virtual Functions
See part 5: Explicit and Partial Specialization
See part 6: New C++11 features added to the Visual C++ 2012 compiler (CTP)
See part 7: Usual Arithmetic Conversions and Template Metaprogramming

Table of contents

[00:00] GoingNative(); //Ale and Charles talk about the status of the VC++ 2012 CTP and introduce the show's topic,  the 3D Starter kit written by our guest, C++ developer Roberto Sonnino.
[02:55] Ale and Charles interview Roberto Sonnino about his 3D Starter Kit.
[30:16] ~GoingNative();// Ale and Charles destruct the show.

Get Herb's slides for this session.

Herb says:

I've spoken and written on these topics before. Here's what's different about this talk:

• Brand new: This material goes beyond what I've written and taught about before in my Effective Concurrency articles and courses.
• Cutting-edge current: It covers the best-practices state of the art techniques and shipping tools, and what parts of that are standardized in C++11 already (the answer to that one may surprise you!) and what's en route to near-term standardization and why, with coverage of the latest discussions.
• Blocking vs. non-blocking: What's the difference between blocking and non-blocking styles, why on earth would you care, which kinds does C++11 support, and how are we looking at rounding it out in C++1y?

The answers all matter to you – even the ones not yet in the C++ standard – because they are real, available in shipping products, and affect how you design your software today.

Abstract:

You can't do a better job if you don't change what you're doing, but change is hard.  It's especially hard when what needs to change is your colleagues' approach to software development. Moving your team forward often requires persuading your peers to change their behavior, sometimes to do something they're not doing, other times to stop doing something they've become accustomed to.  Whether the issue is to embrace or avoid C++ language features, to adopt new development tools or abandon old ones, to increase use of or scale back on overuse of design patterns, to adhere to coding standards, or any of the plethora of other matters that affect software creation, moving things forward typically requires getting your colleagues to buy into the change you're proposing.  But how can you do that?

In this panel session, Andrei, Herb, and Scott share how they go about convincing their colleagues to change and take questions from the audience. 

This was filmed at C++ and Beyond 2012

Download Herb's slides for this session.

Abstract:

In addition to the many new C++11 features that everyone's listing, it has dawned on me over the winter that there's actually another major change that isn't being talked about anywhere, or even being listed as a change in C++11 at all as far as I know, because I and other key experts and committee members I've asked didn't fully realize that we altered the basic meaning of not one but two fundamental keywords in C++. It's a change that has profound consequences, that rewrites and/or invalidates several pieces of pre-C++11 design guidance, and that's directly related to writing solid code in a concurrent and parallel world. This isn't just an academic change, either — everyone is going to have to learn and apply the new C++11 guidance that we'll cover in this session.

I plan to talk about it first at C&B, in a session tentatively titled as above — I'll fill in the keywords later. You may already guess a few keyword candidates based on the description above, and here's a final hint: You'll hardly find two C++ keywords that are older, or whose meanings are more changed from C++98 to C++11. (No, they aren't auto and register.)

See part 1: Name Lookup
See part 2: Template Argument Deduction
See part 3: Overload Resolution
See part 4: Virtual Functions
See part 5: Explicit and Partial Specialization
See part 6: New C++11 features added to the Visual C++ 2012 compiler (CTP)

Abstract:

Writing code that is resilient upon errors (API failures, exceptions, invalid memory access, and more) has always been a pain point in all languages. This being still largely an unsolved (and actually rather loosely-defined) problem, C++11 makes no claim of having solved it. However, C++11 is a more expressive language, and as always more expressive features can be put to good use toward devising better error-safe idioms and libraries.

This talk is a thorough visit through error resilience and how to achieve it in C++11. After a working definition, we go through a number of approaches and techniques, starting from the simplest and going all the way to file systems, storage with different performance and error profiles (think HDD vs. RAID vs. Flash vs. NAS), and more. As always, scaling up from in-process to inter-process to cross-machine to cross-datacenter entails different notions of correctness and resilience and different ways of achieving such.

To quote a classic, "one more thing"! An old acquaintance—ScopeGuard—will be present, with the note that ScopeGuard11 is much better (and much faster) than its former self.

Tune in. Learn. Thanks to Andrei, Herb and Scott for inviting C9 to film these wonderful sessions, rife with practical technical information for modern, professional C++ developers.

Get the slides.

[00:00]  GoingNative();\\ Charles and Ale discuss C++ at Build 2012 and introduce Profile Guided Optimization.

[04:09]  Charles interviews VC++ back end compiler team members Ten Tzen (lead developer) and Amit Mohindra (PM) about VC++'s implementation of PGO. Whiteboarding included. This is a long interview, so make some time.

[01:04:15]  ~GoingNative(); // Charles and Ale reflect on PGO, Charles answers Herb Sutter's question (that Herb asked Charles during his Build 2012 C++ session (in his intro remarks). Hi Herb!

We really want to hear from you, so please tweet feedback to @C9GoingNative (follow us!) and send your requests, ideas, complaints, praises, hate mail, and love letters to C9GoingNative at hotmail com. We will read and respond to all messages! That's how we roll, brothers and sisters. If you are a Facebook user, then please join our C9::GoingNative Facebook group.

Go native!

This compiler is now available as a Customer Technology Preview release to everyone. If you want to test-drive this new compiler too, download it from here: http://aka.ms/vc-ctp. More details on this release are available on Visual C++ Blog (http://blogs.msdn.com/vcblog/).

Make sure to watch Herb Sutter's C++ keynote at BUILD 2012.

See part 1: Name Lookup
See part 2: Template Argument Deduction
See part 3: Overload Resolution
See part 4: Virtual Functions
See part 5: Explicit and Partial Specialization

From Scott's recently published article in the October 2012 edition of ACCU's Overload:

Given that rvalue references are declared using "&&", it seems reasonable to assume that the presence of "&&" in a type declaration indicates an rvalue reference. That is not the case:

Widget&& var1 = someWidget; // here, "&&" means rvalue reference

auto&& var2 = var1; // here, "&&" does not mean rvalue reference

template<typename T>

void f(std::vector<T>&& param); // here, "&&" means rvalue reference

template<typename T>

void f(T&& param); // here, "&&" does not mean rvalue reference

In this article, I describe the two meanings of "&&" in type declarations, explain how to tell them apart, and introduce new terminology that makes it possible to unambiguously communicate which meaning of "&&" is intended. Distinguishing the different meanings is important, because if you think "rvalue reference" whenever you see "&&" in a type declaration, you'll misread a lot of C++11 code.

Tune in. Scott's an incredible presenter and it's well worth your time to both read his article and watch his presentation on the subject. Great stuff!

Download slides

So, go get this free Windows 8 app, make some art (mix different oil colors, zoom in, check out the realistic fluid dynamical effects). Then, come back and learn about what's going on inside of Fresh Paint and meet the developers who wrote it.

[00:00] GoingNative(); //Very quick ctor this month.
[01:34] Charles interviews the Fresh Paint development team
[40:04] ~GoingNative(); // Meet the new Visual C++ Community PM, Eric Battalio!!

Andrei Alexandrescu, Scott Meyers and Herb Sutter take questions from attendees. As expected, great questions and answers!

Tune in!

Table of contents (click the time codes ([xx:xx]) to hear the answers...):

Message passing primitives in future versions of the standard... [00:00]
Standardized unit testing framework... [02:55]
std::async... [04:30]
Standard modules proposal... [08:14]
Keyword additions and the standard library... [09:35]
Problems (and solutions) with exceptions... [12:50]
Future of concepts... [22:34]
std::thread and thread interruption... [23:03]
When to use the auto keyword (and when not to...)... [25:03]
More on auto (benefits of reduncancy, type conversion issues with bool to int?)... [29:31]
const and multithreaded programming, in C++11 const means thread safe, too... [35:00]
Yet more on auto (impact on rampant use and code readability/comprehension)... [42:42]
Compiler type deduction information (compiler switch that prints out auto deduced type information)... [50:18]
Printing out code for review that replaces auto with the actual type... [53:30]
auto and dynamic memory allocation... [54:59]
Useful, broadly-used concurrency libraries... [57:00]

[00:00] GoingNative(); // VC++ Dev Manager Ale Contenti joins the cast!

[07:09] Charles interviews VC++ leaders Steve Teixeira and Tarek Madkour about VC11 RTM and beyond. Congratulations to the VC team for shipping a stellar release!!

[38:04] ~GoingNative(); // Ale and Charles talk about the industry's movement towards more cohesive standard modern libraries. See you next month! Go native! Ciao Ale!

Huge thanks to Andrei, Herb, and Scott for their time and wisdom. Thanks, too, to the Niners who asked great questions!

Here's what happened:

[00:00] Themes for C++ in 2012 and beyond (and C++ and Beyond 2012)
[07:00] C++11 Efficiency and Concurrency/Parallelism (Standardization)
[12:12] dot_tom asks: When can we expect standardized modern libraries like, XML, File system, Web Services?
[15:00] ZippyV asks: Standardized modern libraries: What has the response been? Any unexpected requests?
[17:17] static if
[26:26] Matt_PD asks: Future of template metaprogramming? Standardizing static loops?
[40:07] More on template metaprogramming (and static if and enable_if)...
[50:05] async/await language feature in C++ would be nice, C&B 2013?

As STL says: "I walk through why foo(const T&) beats foo(const T *), when given int *. The reason is surprisingly subtle."

Tune in.

Tune in. Learn.

See part 1: Name Lookup

Here's a trivial example employing C++ LINQ:

vector<int> some_primes(size_t howMany)
{
       auto xs = from(int_range(0, INT_MAX))
                      .where(is_prime)
                      .take(howMany);
       return xs.to_vector();
             // or: vector<int>(begin(xs), end(xs));
}

Table of Contents:

[00:00] GoingNative(); //Charles flies solo for this episode. Make sure you check out the sessions from Developing Windows 8 Metro style apps with C++ event. This is the only place to learn (deeply) about WRL and C++ + XAML + DX, for example. Herb Sutter's keynote is excellent, of course.

[03:00] Charles interviews software developer Aaron Lahman. Aaron explains (whiteboard and demo included) the work he's doing building a LINQ library for C++ and Reactive Extensions for C. Aaron is great at explaining what he's doing (and why he's doing it). Thank you, Aaron! Go Rx!!

[39:58] ~GoingNative();

All sessions are available for on demand viewing.

Whether you are a new C++ developer ready to learn about writing Metro style apps, an intermediate developer who wants to honeyour code and skills, or an experienced C++ developer eager to squeeze every ounce of performance out of your Metro style app, this event is for you.  We present pragmatic advice for every developer writing Metro style apps and games with C++, XAML and DirectX. Talks contain VC++ compiler extensions and ISO C++. The Windows Runtime Library is introduced, demoed and explained.

Agenda (All times PDT):

Remember Herb Sutter's great GotW post (#30, to be precise) on Name Lookup? Here's the problem from that post, to refresh your memory (Thanks to Herb for providing information like this on GotW!):

In the following code, which functions are called? Why? Analyze the implications?

namespace A {
      struct X;
      struct Y;
      void f( int );
      void g( X );
}

namespace B {
       void f( int i ) {
            f( i );   // which f()?
        }
        void g( A::X x ) {
             g( x );   // which g()?
        }
        void h( A::Y y ) {
             h( y );   // which h()?
        }
 }

We recommend you watch this entire episode before playing around with Herb's sample above (and don't read the GotW answer, either! That's cheating. Learn from STL. He's an outstanding teacher, as you know.)

Please supply feedback on this thread, especially as it relates to what you'd like STL to focus on in subsequent episodes. For part 2, STL will focus on Template Argument Deduction.

Tune in. Enjoy. Learn.

These Windows-specific talks will use both portable ISO C++ and Visual C++-specific compiler extensions; for brevity below we'll refer to both as "C++" (i.e., this day is about Visual C++, not Visual C# or JavaScript).

We will have pragmatic advice for every developer writing Metro style apps and games with XAML and/or DirectX and C++.

This event is sold out.  However, it will stream live right here on Channel 9! Tune in on May 18, 2012, 8:00AM PDT.

Agenda:

• VC++ for Windows 8, Keynote by Herb Sutter
• Building Windows 8 apps with XAML and C++
• Building Windows 8 games with DirectX and C++
• Introduction to the Windows Runtime Library  (WRL)
• Writing Connected apps: Writing networking code with C++
• Combining XAML & DirectX in a Metro style apps
• Writing WinRT components to be consumed from any language
• VC11 compiler flags for getting the most out of C++

With Casablanca, you get support for doing things like developing REST services for Azure, or accessing them from clients via an HTTP library, sending JSON data, accessing Azure blob and queue storage, and using TCP for flexible networking needs, all in a library that takes advantage of modern C++.

Casablanca also gives you a convenient model for composing asynchronous operations. C++ 11 offers a whole new set of capabilities that can make dealing with asynchronous operations easy, and Casablanca takes advantage of that throughout.

Another aspect of Casablanca is its implementation of the actor programming model, which has proven itself useful in building reliable and scalable systems. (not familiar with the Actor Model, well, learn from the inventor of it here).

Table of Contents:

[00:00] GoingNative(); //Charles flies solo for this episode (Diego is on vacation). Quick chat about what's coming (new STL series (the person, not the library)), introduction to Casablanca, a modern C++ API (incubation) for asynchronous client/server computing (so, modern C++ for the cloud and the client)
 
[01:49] Charles has a conversation with Casablanca engineering team members Niklas Gustafsson and Steve Gates.

[44:20] ~GoingNative(); //Charles talks about Casablanca - please download the libraries and experiment, provide feedback, help vet this new (experimental) API.

And here are a few additional links to more information about C++ that will help you learn how to use it in your projects:

• TechEd PreConference Seminar: "C++ In Visual Studio 11: Modern Readable, Safe, Fast"
  Kate Gregory will be doing a day long intensive seminar at both TechEd North America (June 10^th in Orlando) and TechEd Europe (June 25^th in Amsterdam).
  You can register for TechEd North America here: http://northamerica.msteched.com/registration
  And TechEd Europe here: https://register.europe.msteched.com

• GoingNative 2012
  This event was held back in February, and was streamed live throughout the world. It featured industry experts discussing the importance of C++ and its proper use in modern application development. All of the sessions are available for "on demand" viewing over on Channel 9.
  You can access all of the videos here: http://channel9.msdn.com/Events/GoingNative/GoingNative-2012

• Sutter's Mill
  If you want to catch more of Herb Sutter and his thoughts on C++, you should check out his blog.
  You can find Herb's blog here: http://herbsutter.com/
  And specifically the "Elements of Modern C++ Style" reference that Herb refered to can be found here: http://herbsutter.com/elements-of-modern-c-style/

• Welcome Back to C++ (Modern C++)
  For Visual Studio 11, MSDN has prepared details on the advancement and use of C++ which includes examples, reference material, and information on the currently supported features. It is definitely worth checking out to get up to speed.
  The MSDN C++ content starts here: http://msdn.microsoft.com/en-us/library/hh279654(v=vs.110).aspx