GoingNative 2012: Minus 3 Days

image

Recap:

Note that because of technical limitations, watching the livestream requires Silverlight (watching the stored videos later on demand will not). Silverlight is supported by all modern desktop browsers, but it’s a short download if you don’t have it already – so if you’re watching live, check in a little early to make sure you don’t miss a thing. If you’re watching on-demand, no worries – videos will be available in various popular formats as usual for Channel 9.

 

As we count down to launch, another tidbit from the “fun facts” department:

 

Myth: Software conferences are dying. Especially C++ conferences are dead.

Fact: Number of exclusively-C++ conferences in 2012: Three.

Other conferences also include C++ content, such as April 24-28’s ACCU which has over 20 C++-specific talks.

 

C++11-fest minus 3…

GoingNative 2012: Minus 5 Days

image

Recap:

 

As we count down to launch, here’s something from the “fun facts” department about GN2012:

 

Myth: C++ is for older developers.

  • Fact: Age distribution for the live audience at my September 2011 talk on Writing Modern C++ Code: roughly half under 30.
  • Fact: Age of the youngest in-person GoingNative 2012 attendee… wait for it…: 15 years old.

 

C++11-fest minus 5…

GoingNative 2012: Minus One Week

clip_image002GoingNative 2012 is sold out for in-person attendees, but online attendance is free and unlimited – live-stream and on-demand. Watch the main page for links.

GoingNative 2012 is a 48 hour technical event for those who push the boundaries of general purpose computing by exploiting the true capabilities of the underlying machine: C++ developers. Distinguished speakers include the creator of C++, Bjarne Stroustrup; C++ standards committee chair, Herb Sutter; C++ template and big compute master, Andrei Alexandrescu; STL master Stephan T. Lavavej; LLVM/Clang developer Chandler Carruth; distributed and parallel computing expert Hans Boehm; and C++ library design expert and ISO committee member Andrew Sutton.

Although the majority of the audience will be on the web, here are some interesting statistics about the 350 people who are coming in person and will be with us in the room:

Developers attending in person will arrive from 18 countries and 23 US states. They are professional native developers from industry, from academia, from small businesses to very large corporations. They are CTOs, architects and scientists. They are students and coders. And they are all in for a real native treat!

Come join us live starting with Bjarne Stroustrup’s opening keynote on Thursday February 2 at 9:30am sharp U.S. Pacific time (here’s a World Clock meeting planner for other time zones). We have a special something extra in the first couple of minutes, so you won’t want to be late.

C++11 “GoingNative 2012”: Speakers and Sessions

imageThe speakers and sessions for GoingNative 2012 (Feb 2-3, Redmond WA USA) have now been posted. With the focus squarely on C++11 on all compilers and platforms, I think this is going to be the C++ event of the first half of 2012, and I’m very pleased with the caliber of our speakers and their technical and industry breadth.

Note: 85% Sold Out. All sessions will be publicly available online for free, both livestream and on-demand for posterity. But to attend in person and be in the (very nice) room, tickets are just $112 and currently 85% sold out; I expect the rest to go quickly now that the talks are posted, so if you’ve been on the edge, this week is a good time to register here.

Kodiak room: Click for 360-view in PhotosynthSpeakers and Sessions. Here’s a summary of the talk titles; see the page for the full session list with abstracts. The bulk of the program is all about the new C++11 standard as it exists today. On Day 2, we’ve also included a couple of forward-looking topics that C++ developers are frequently asking about and we felt were important to cover – especially with the key experts already in the building. The program also includes two interactive panels where you’ll be able to ask and tweet questions for the speakers.

Day 1 (Theme: C++11 Today)

  • Opening Keynote: C++11 Style (Bjarne Stroustrup, TAMU)
  • Threads and Shared Variables in C++11 (Hans Boehm, Hewlett-Packard)
  • STL11 – Magic && Secrets (Stephan T. Lavavej, Microsoft)
  • Variadic Templates are Funadic (Andrei Alexandrescu, Facebook)
  • Panel: The Importance of Being Native (Andrei Alexandrescu, Hans Boehm, Bjarne Stroustrup, Herb Sutter)

Day 2 (Theme: C++11 Today and Tomorrow)

  • C++11, VC++11 and Beyond (Herb Sutter, Microsoft)
  • C++11 and Clang (Chandler Carruth, Google)
  • Static If I Had a Hammer (Andrei Alexandrescu, Facebook)
  • A Concept Design for C++ (Bjarne Stroustrup and Andrew Sutton, TAMU)
  • Panel: Ask Us Anything! (all speakers)

As promised, the focus on learning and using Standard C++11 – what it is, where it’s at, and where it’s going. I’m really excited to be a part of this, and I hope you enjoy it. In my original post I listed several ways your team can benefit from this material remotely, and I encourage you to plan for it, live or otherwise. I look forward to seeing many of you there in person.

Welcome to the Jungle

With so much happening in the computing world, now seemed like the right time to write “Welcome to the Jungle” – a sequel to my earlier “The Free Lunch Is Over” essay. Here’s the introduction:

 

Welcome to the Jungle

In the twilight of Moore’s Law, the transitions to multicore processors, GPU computing, and HaaS cloud computing are not separate trends, but aspects of a single trend – mainstream computers from desktops to ‘smartphones’ are being permanently transformed into heterogeneous supercomputer clusters. Henceforth, a single compute-intensive application will need to harness different kinds of cores, in immense numbers, to get its job done.

The free lunch is over. Now welcome to the hardware jungle.

 

From 1975 to 2005, our industry accomplished a phenomenal mission: In 30 years, we put a personal computer on every desk, in every home, and in every pocket.

In 2005, however, mainstream computing hit a wall. In “The Free Lunch Is Over” (December 2004), I described the reasons for the then-upcoming industry transition from single-core to multi-core CPUs in mainstream machines, why it would require changes throughout the software stack from operating systems to languages to tools, and why it would permanently affect the way we as software developers have to write our code if we want our applications to continue exploiting Moore’s transistor dividend.

In 2005, our industry undertook a new mission: to put a personal parallel supercomputer on every desk, in every home, and in every pocket. 2011 was special: it’s the year that we completed the transition to parallel computing in all mainstream form factors, with the arrival of multicore tablets (e.g., iPad 2, Playbook, Kindle Fire, Nook Tablet) and smartphones (e.g., Galaxy S II, Droid X2, iPhone 4S). 2012 will see us continue to build out multicore with mainstream quad- and eight-core tablets (as Windows 8 brings a modern tablet experience to x86 as well as ARM), image_thumb99and the last single-core gaming console holdout will go multicore (as Nintendo’s Wii U replaces Wii).

This time it took us just six years to deliver mainstream parallel computing in all popular form factors. And we know the transition to multicore is permanent, because multicore delivers compute performance that single-core cannot and there will always be mainstream applications that run better on a multi-core machine. There’s no going back.

For the first time in the history of computing, mainstream hardware is no longer a single-processor von Neumann machine, and never will be again.

That was the first act.  . . .

 

I hope you enjoy it.

GotW #102: Exception-Safe Function Calls (Difficulty: 7/10)

JG Question

1. In each of the following statements, what can you say about the order of evaluation of the functions f, g, and h and the expressions expr1 and expr2? Assume that expr1 and expr2 do not contain more function calls.

// Example 1(a)
//
f( expr1, expr2 );

// Example 1(b)
//
f( g( expr1 ), h( expr2 ) );

Guru Questions

2. In your travels through the dusty corners of your company’s code archives, you find the following code fragment:

//  Example 2

//  In some header file:
void f( T1*, T2* );

//  At some call site:
f( new T1, new T2 );

Does this code have any potential exception safety or other problems? Explain.

3. As you continue to root through the archives, you see that someone must not have liked Example 2 because later versions of the files in question were changed as follows:

//  Example 3

//  In some header file:
void f( std::unique_ptr<T1>, std::unique_ptr<T2> );

//  At some call site:
f( std::unique_ptr<T1>{ new T1 }, std::unique_ptr<T2>{ new T2 } );

What are the semantics of this call? What improvements does this version offer over Example 2, if any? Do any exception safety problems remain? Explain.

4. Demonstrate how to write a make_unique facility that solves the safety problems in Question 3 and can be invoked as follows:

//  Example 4

//  In some header file:
void f( std::unique_ptr<T1>, std::unique_ptr<T2> );

//  At some call site:
f( make_unique<T1>(), make_unique<T2>() );