Videos from C++Now are available!
Videos of the keynotes and sessions from C++Now 2013, held in May are now available.
They are available on YouTube.
Video & On-Demand
Efficient Programming with Components -- Alexander Stepanov
A wonderful video series by the inventor of the Standard Template Library (STL).
Video Series: Efficient Programming with Components
by Alexander Stepanov
Performance is essential for infrastructure software. Modern infrastructure software depends heavily on components. Therefore, writing performant code in this environment requires deep understanding of the characteristics of such components. The course will help programmers to improve performance of their code by learning how to use these existing generic components effectively. In addition, it will teach them to extend the library with new high-performance components. Along the way, participants will learn how to use C++ as a high-performance language.The course will be taught interactively with the class discussing, discovering, and developing components together.
Scaling with C++11 -- Edouard Alligand
From the recent BoostCon/C++Now event. If you missed it there, check it out online. An updated version of this talk is also slated for the upcoming Meeting C++ this fall if you want to catch it in person.
Scaling with C++11
Edouard Alligand
As the number of cores per processor increases, software needs to be able to execute multiple tasks in parallel in order to benefit from Moore's law. This is not only a question of writing parallel algorithms, but also a matter of designing the application properly to reduce inter-thread dependencies. These dependencies may be very hard to find and are the results of decades of serial programming. Thus, writing truly scalable software is less a question of technical expertise than adopting the appropriate state of mind.
This presentation is about the design, techniques and tools used by the team who wrote the hyperscalable database "quasardb." Building upon concrete scalability challenges, the presenter will expose typical multithreading anti-patterns and how to avoid them. The topics covered include: atomics, micro locks, lock-free and wait-free containers, memory management strategies (copy on write, smart pointers, perfect forwarding...), thread local storage, asynchronous I/O, and much more!
C++11: The Future Is Here -- Bjarne Stroustrup
Stroustrup's ACCU keynote video is now available online.
C++11: The Future Is Here
Bjarne Stroustrup
Summary: Bjarne Stroustrup keynotes on what C++ is in general, how C++11 makes simple things even simpler, resource management, generic programming, and concurrency.
Core C++, 8 and 9: From do-while to variadic array sorter to lambdas -- Stephan T. Lavavej
The two latest C++ lectures by Stephan T. Lavavej, the eponymous STL, are now available:
Core C++, 8 of n
In part 8, STL digs into the do-while loop, casts, one definition rule (ODR), and his variadic template array sorter. There is a lot of information in this episode, so get comfortable, tune in, and learn.
Core C++, 9 of n
In part 9, STL digs into lambdas and other expressions. Lambdas are very useful and you've no doubt been enjoying them in your modern C++ programming. As you can imagine, STL will go deep and teach you things about lambdas that you may not know. You'll also learn a lot about order of precedence and associativity for expressions in only the way Stephan can teach you (thorough treatment). Tune in.
C++Now 2013 Keynotes now available
The keynote addresses for C++Now 2013 are now available.
Dan Quinlan: C++ Use in High Performance Computing Within DOE: Past and Future
Chandler Carruth: Optimizing the Emergent Structures of C++
We are confronted today with the increasing complexity of our C++ software systems. To manage this complexity and build larger applications and systems, C++ strives to form emergent structures (often found in nature, such as snowflakes' symmetrical structures), where simple patterns combine to form a remarkably complex and powerful system. These structures provide both a means to limit the complexity of each component and the essential economies of scale we rely on when developing software.
From handheld devices to warehouse-sized data centers, motivated by smaller devices and increased concerns over power consumption, we are relying upon C++ to deliver these complex systems with unmatched efficiency. Our optimizing compilers today are more important than ever before and are utterly opaque to most practicing programmers. Compounding matters, the very emergent structures which allow C++ systems to scale for humans often provide unique and unsolved challenges to optimization.
In this talk, I will start with a brief overview of how modern optimizing compilers work with C++ code at a very high level. I will then walk through the specific structures and patterns of C++ code, which are at the core of forming emergent structures out of simple, elegant elements. I will also address how these interactions can be effectively modeled and analyzed by a compiler to produce efficient final programs. All of this will be illustrated by a collection of real world case studies, which are broadly applicable and show up throughout modern C++ code bases. My goal is to give a framework for understanding these interactions both in the C++ code and the optimizing compiler, so that programmers are aware of the implications posed by these patterns. Finally, I will introduce a set of principles and techniques for designing and implementing C++ programs and libraries to specifically clear the way for modern optimizers while retaining the simplicity of each component and the power of the combined whole.
Stanley Lippman: yet another paradigm shift (yaps) - a Meta4 model of concurrency
We'll discuss language life cycles, particularly as they apply to C++, from a peek at some of the very early ideas and technology behind C++ to a proposal for the next step: yet another paradigm shift, not a evolution or revolution but simply a synchronizing of meta4layers — using fertilization of the multi-cell organism as an isomorph.
Clang/LLVM Conference videos and slides are now available
The recent 2013 European Clang/LLVM developer meeting talk videos and/or slides are now available here.
Here are a few of the talks of interest to C++ developers. All have videos available except the last. Check out the page for details and a full talk list.
Keynotes
Optimization in LLVM - Numbers, A Case Study, and Looking Forward
Chandler Carruth (Google)Talks
clang-format - Automatic formatting for C++
Daniel Jasper (Google)Performing Source-to-Source Transformations with Clang
Olaf Krzikalla (TU Dresden)Run-time tracking of uninitialized data with MemorySanitizer
Evgeniy Stepanov (Google)LLVM on IBM POWER processors: a progress report
Ulrich Weigand (IBM)Tutorials
How to implement an LLVM Assembler
Simon Cook (Embecosm)The Clang AST (slides only)
Manuel Klimek (Google)
For more talks, and video/slide links, head over to the site.
Functional Patterns in C++ -- Bartosz Milewski
If you're familiar with functional language styles and you want an advanced look at how your favorite functional styles are supported in modern C++, with a dash of Haskell, check out these three videos by Bartosz Milewski:
Functional Patterns in C++ (slides)
by Bartosz Milewski
Part 1, Functors: First the introduction to some common functional patterns like Functor, which, surprisingly pops up everywhere. I'll show the example of a
unique_ptrand avectoras Functors. Of course, this is only in preparation for asynchronous functors.Part 2, Currying, Applicative: A little digression to Haskell and the Maybe functor and the explanation of currying. Then I'll show you the Applicative Functor pattern. This is, of course, in preparation for for the asynchronous applicative functor pattern.
Part 3, Asynchronous API, Monoid, Monad: The encapsulation of asynchronous API that doesn't lead to inversion of control and spaghetti code. Very natural example of a Monad Pattern.
Interestingly, Bartosz' talk ends with a plea for (essentially) future.then and a C#-style await... both of which are under active consideration in the C++ standards committee as part of a potential near-term C++ technical specification on concurrency and parallelism.
Stroustrup Festschrift Panel: C++ Standards, Workshop on Quality Software
From Bjarne Stroustrup's recent festschrift. Congratulations, Bjarne!
C++ Standards: Panel -- Workshop on Quality Software
Panel moderator: Alisdair Meredith
Panelists: Matt Austern, Jonathan Caves, Lawrence Crowl, Jan Christian van Winkel.
Image Watch: C++ image and video debugging plug-in for VS 2012
We continue to see modern C++ tool development across the industry continue apace. Here's another new cool C++-oriented tool with a nice seven-minute video on Channel 9:
Introducing Image Watch - A VS 2012 Plug-In for C++ Image and Video Debugging
Image Watch is a new Visual Studio 2012 plug-in for debugging C++ image and video processing applications, for example photo or augmented reality apps. Image Watch provides a watch window that can display in-memory bitmaps during debugging, so you no longer need to litter your code with "save-this-intermediate-image-to-a-file" statements when tracking down bugs. The initial release has built-in support for OpenCV image types and can be extended for viewing user-defined image types as well.
Here, Wolf Kienzle, Senior Research Developer, Interactive Visual Media group, Microsoft Research Redmond, explains and demos this excellent new tool for C++ developers building image, video or augmented reality apps. In effect, you can step into pixels...