CPKEY1: C++: Evolving a Language In and For the Real World
Bjarne Stroustrup
The C++ programming language is now 25 years old, and used by millions of programmers. Developing such a language is a challenging business. I will present a personal view of some of the factors that were and still are critical for C++'s sustained success. Many of the key ideals and principles that were applied -- with varying degrees of success -- involve non-technical concerns. Real-world language evolution differs significantly from “green field” and "blue sky" design, especially since it requires long-term evolution in a world of shifting external pressures rather than specifying an ideal design once and for all.

CPKEY2: The Concurrency Landscape and C++0x
Herb Sutter
Starting today, changes in the hardware landscape are directly affecting the way we write software: The free lunch of ever-greater clock speeds is over, and nonconcurrent applications will no longer exploit the continued exponential performance growth in modern mainstream CPUs. Unfortunately, none of today's mainstream languages and environments deal well with concurrency. This session provides a summary of the issues for those not attending the concurrency track, and a context and roadmap for those who are.

LANGUAGE AND TECHNIQUES

CLT405: Life on the Edge: Juggling Static and Dynamic Polymorphism
David Abrahams
Dynamic polymorphism—as expressed by C++ virtual functions—is the key to most interesting object-oriented programs. By grouping different behaviors beneath a single base class, we can build complex systems whose behavior changes at runtime. Static polymorphism — as expressed by C++ function templates— is the key to generic programming. By grouping different types beneath a single concept, we can express common algorithm or type structure without loss of efficiency. In this session, we’ll explore the unique capabilities and performance characteristics of each kind of polymorphism, learning when and how they can be applied. The focus of the session, however, is a look at what happens when the two types of polymorphism are mixed: a programmer who intentionally sets the boundary between static and dynamic polymorphism often gains control over execution speed, compilation speed, and program size. We’ll also cover “type erasure,” a sophisticated technique for non-intrusively bridging the two approaches, and see how it is expressed in the Boost/TR1 Function library.

CLT302: Modeling Memory-mapped I/O
Scott Meyers
This session describes an elegant approach to modeling memory-mapped IO that provides a natural interface for users, great flexibility for implementers, maximal efficiency (in both space and time), and compile-time prevention of common client errors. The technique is based on a combination of templates, classes, inline functions, placement and custom new (without requiring dynamic memory allocation), references, bit operations, volatile memory, private member functions, and reinterpret_casts, but the generated code should be as good as that produced by the most hardcore hardware hacker.

CLT301: Reference Accounting: Patterns for Managing Non-nested Object Lifetimes
Kevlin Henney
One, two... one, two... three, two, three, four... three, two... one, two.... This could be a microphone sound check gone out of control. Or it could be the sound of an object, if it knew and spoke aloud, the number of pointers aimed at it. In C++, by default, this is at best a muffled silence: a regular object is blissfully unaware of the pointers being held in its name. Tracking references to an object is a utility offered by many libraries. The most common application of this technique is to automate the deletion of a shared heap object: one, two, one, none, gone -- rather than: one, two, one, none, leak. The goal of the session is not to demonstrate a code library but to present a design vocabulary, so that attendees will be better able to assess which style of reference counting, if any, is appropriate for a given task, and whether to use one off the shelf or roll their own, and how.

CLT303: Speaking C++ as a Native
Bjarne Stroustrup
Multi-paradigm programming is programming applying different styles of programming, such as object-oriented programming and generic programming, where they are most appropriate. This session presents simple example of individual styles in ISO Standard C++ and examples where these styles are used in combination to produce cleaner, more maintainable code than could have been done using a single style only.

CLT304: The Technical Report on C++ Library Extensions (TR1)
Matt Austern
The C++ standards committee is now working on the next version of C++, and some parts of the next-generation standard library are already available. The standards committee has published the Draft Technical Report on C++ Library Extensions, "TR1", which describes extensions to the standard library. TR1 includes many new library components that make C++ programming easier and more convenient, including hash tables, better support for STL function objects, smart pointers, and regular expressions. It is expected that most of the TR1 library will become part of the next official standard, and compiler vendors are beginning to support it. This session describes some of what's in TR1, how to use it, and what to expect in the future.

LIBRARIES

CAP301: Applications Xbox and C++: Common Performance Issues in Games
Peter Isensee
Game console programmers and C++ go together like pizza and Mountain Dew. C++ provides the perfect balance between the high-level abstraction needed to create complex games and the performance needed to maximize framerate and gameplay. The Xbox Advanced Technology Group reviews dozens of games at the source code level, analyzing performance, pinpointing bottlenecks and recommending solutions. Although the focus of these reviews is on graphics and hardware usage, it’s surprising how often C++ issues crop up in games. Even the most technically astute developers stumble when it comes to C++. By evaluating the most common C++ performance issues seen in games, we can gain an insight into how to avoid those problems in any high performance application.

CEV304: Beyond Objects: Understanding the Software We Write
Sean Parent
At the core of any software is a collection of algorithms. Every algorithm assumes a set of operations with precise semantics. We look at the most basic set of operations; those necessary to allow values to be passed to, and returned from, functions. These operations define a regular type and exist, in some form,in every software system. First, we look at how these operations manifest in the fundamental types, then at how they manifest in common object-oriented idioms. The goal of this exercise is to gain a deeper understanding of how software works and the challenges of writing reusable code.

CEV305: Chromed Metal: C++ Idioms that Are Safe and Fast
Andrei Alexandrescu
Maybe the greatest joy and satisfaction of programming in C++ is to create efficient abstractions. Layer upon layer upon layer numerous C++ features and techniques emphasize abstraction, strengthen static checking and bring the language closer to the problem domain. It looks good, and down below, it’s all tough and sturdy. It’s chromed metal. This session discusses a few idioms that foster happy coexistence of beauty and speed, features that are sadly often at conflict in other languages.

CCN301: Concurrency C++ Threading: A Generic Programming Approach
Kevlin Henney
A lot has been written about multithreading, C++, and multithreading in C++. There have a number of different higher level threading APIs written and proposed. Some are influenced by object models that are not necessarily appropriate to C++’s own idioms, and some of them suffer from looking too obviously like C API wrappers, in spite of their specific goal of API independence. In many cases the resulting object model is less expressive, although simpler and safer to use, than the underlying API. This session revisits basic principles -- threading, programming models, and generic programming techniques -- to develop a different model for threading in C++. It is simple, idiomatic, and generic, and its thinking is more obviously unchained from the view of thread objects as C API wrappers.

CAP302: Designing Classes, Components, and Libraries for Everyday C++ Use
Nevin Liber
Over the years, I’ve developed a number of small (and not so small) classes that I find being reused without modification as I move from project to project to project. This session will go into understanding the purpose of the various classes, how they are used, and the design decisions, tradeoffs and dead ends that went into developing both their interfaces and implementations. The purpose of this session is more than just presenting these classes. I want people to come away from this session armed with good design techniques that they can bring back to their various organizations to develop their own reusable classes.

CEV301: Evolution and Engineering Future Direction for C++0X
Bjarne Stroustrup
A good programming language is far more than a simple collection of features. This session will provide a set of facilities that smoothly work together to support design and programming styles of a generality beyond imagination. This session will outline rules of thumb (guidelines, principles) that are being applied in the design of C++0x. For example, generality is preferred over specialization, novices as well as experts are supported, library extensions are preferred over language changes, compatibility with C++98 is emphasized, and evolution is preferred over radical breaks with the past. Since principles cannot be understood in isolation, this session will very briefly present a few of the proposals such as concepts, generalized initialization, auto, template aliases, being considered in the ISO C++ standards committee.

CCN403: High-Level Concurrency for C++
Peter Buhr
C++’s lack of concurrency is significantly limiting the language’s future; therefore, it is imperative C++ be augmented with concurrency. It has been shown that concurrency cannot be added by a strict library approach; hence, C++ must be extended with some concurrency capabilities. While low-level concurrency extensions, which can be used to build a number of concurrency approaches, are feasible, the results are cumbersome, error prone, and do not integrate with other language features. Furthermore, most concurrent programmers would rather have a single consistent approach than a number of inconsistent ones. A proposal is presented for a high-level, integrated, expressive, and efficient concurrency approach for C++. The proposal is based on fundamental properties of control-flow and concurrency versus ad-hoc design decisions; these properties are incorporated into C++ by extending its core programming notion, the class.

CLB301: Inside the Boost Libraries
David Abrahams
The Boost C++ libraries have become a de-facto industry standard due to their broad utility and engineering quality. Ten Boost libraries have been accepted into the C++ standard library technical report, and are likely candidates for actual standardization. Because the Boost library abstractions allow programmers to work at such a high level, most articles and documentation have focused on usage and interface. This session is a unique opportunity to look at design elements of three libraries, and to see some of the advanced implementation ideas that make Boost tick. More than just a survey of code samples, the session delivers principles and insights that attendees can apply in their own code. In three segments, we’ll cover:  Type erasure and eliminating “virtual function bloat;” the design of Boost’s shared_ptr and weak_ptr; and dynamic exception handlers.

CLB304: Library-Aware Optimization of C++ Applications
Dan Quinlan
User-defined abstractions help software developers be more productive. However, the use of abstractions usually introduces a penalty in performance due to insufficient optimizations from the compilers. Manually introducing optimization avoids the performance penalty but significantly increases programming difficulty and ties the application to individual computer architectures.  Attend this session to discover a novel approach for optimizing the use of libraries within applications. Specifically, you'll learn about ROSE, a robust and easy-to-use compiler framework for constructing specialized C/C++ sourceto-source translators. ROSE allows the recognition of library abstractions and the automated optimization of their use in applications. Learn how ROSE can utilize the semantics of user-defined abstractions in libraries within the compile-time optimization of applications.

CCN402: Lock-Free Data Structures in C++
Andrei Alexandrescu
With the increase of processor clock speeds hitting a snag, we’re facing yet another silent revolution in processor architecture and programming style. Forget about writing lousy, inefficient code and then taking six months off to let Moore’s law catch up. Once again the heydays of efficient code are up, and with the new multicore, massively parallel architectures, threads are the way to go. This session presents the newest, hottest, and most addictive multithreaded technique in town: lock-free programming.

CCN304: Multithreaded C++ and TR1
Vladimir Kliatchko
Multi-threaded (MT) application development has arrived! Moreover MT programming has evolved, such that what was once considered advanced or obscure (e.g., lock-free techniques, atomic instructions, memory barriers) is now required knowledge. To date, the C++ standard elects not to address MT. This session will present several practical examples derived from real-world experience that characterize the challenges and implicit assumptions inherent in developing MT applications today. You'll learn how new components (such as tr1::function and tr1::shared_ptr) can be utilized effectively in MT applications, and how they can be enhanced to provide even better support in an MT environment.

CAP304: Reconsidering the STL Allocator Model
Pablo Halpern
Memory allocators were originally added into the Standard Template Library (STL) for the purpose of supporting Intel x86 mixed-model (near and far) pointers and other non-flat memory models. Most people, however, consider allocators to be a way to achieve type-specific memory allocation for generic containers, generally for improved efficiency. This session will first show that allocators, as defined in the STL, do not serve either purpose well. This session will suggest specific refinements that require significant changes in the way allocators work but yield tremendous payoffs in the power and usability of allocators. You'll learn how these changes were merged with the original STL model and produced a working, effective memory allocation system that retains compatibility with the 1998 standard. These experiences are the basis for a proposed enhancement to the C++ Library for the next revision of the standard.

CLB305: Security and the C++ Standard Library
Martyn Lovell
The Standard C++ Libraries provide a clean and simple abstraction for algorithms, iterators and containers. In general, this library provides much better protection against classic security problems (such as buffer overruns) than the traditional C library. Over the past  five years, Microsoft has conducted extensive and detailed security reviews and upgrades of its very large code bases. Recently we extended our implementation of the Standard C++ Libraries to try to make them apply, by default, the lessons we’ve learned from reviewing our code. The result is a much safer implementation of the Standard C++ Library with only a small amount of reduced functionality. This  session describes the changes made and their impact on application code, as well as some of the internals of the implementation. We’ll also briefly cover related changes we’ve made to the Standard C library, which many C++ programmers still use.

CEV302: The Concur Project: Concurrency Abstractions for C++
Herb Sutter
The Concur project aims to define higher-level abstractions for today’s (imperative) languages that evenly support the range of concurrency granularities. The project's goals include letting developers write correct and efficient concurrent apps with lots of latent parallelism (and not lots of latent bugs) that can be mapped to actual hardware at run time to reenable the free lunch. Herb is the designer of Concur, and the author of the widely-cited "The Free Lunch Is Over" essay that coined the term "concurrency revolution."

CAP303: The Phoenix Compiler and Tools Framework: Built from, Building, and Building on C++/CLI
Andy Ayers
Phoenix, Microsoft’s next generation compiler and tools framework, is built entirely in C++/CLI. Phoenix’s design leverages both the traditional strengths of C++ and the innovative features of CLI binding. The Phoenix framework’s flexible, and extensible components make extensive use of CLI features like ref classes, properties, events, and delegates. We’ll demonstrate how C++/CLI enables Phoenix to produce not only powerful compiler and jit components that will help implement and optimize C++/CLI programs, but also produce novel and efficient tools for C++/CLI program analysis, understanding, and manipulation.

CEV303: Tips and Tricks with the Visual C++ IDE
Martyn Lovell
Abstract not available.

CLB303: Writing Your Own STL Container
Ray Lischner
The STL has a number of useful container templates, and TR1 adds a few more. Nonetheless, you might find yourself wishing for yet other kinds of containers. This session introduces you to the joys and pitfalls of writing your own container class template, with associated iterators.

CLB302: Xpressive: Dual-mode DSEL Library Design
Eric Niebler
A Domain-Specific Embedded Language (DSEL) is a library that provides a miniature language-within-a-language for solving problems in a particular domain. This session presents techniques for increasing the power and flexibility of DSELs in C++ by unifying two complementary designs: early-bound (compile-time) and latebound (runtime). Late-bound DSELs have string-based interfaces, whereas earlybound DSELs are based on expression templates. xpressive, a new regular expression library, fuses these two approaches. This fusion, providing both a runtime and a compile-time interface, offers advantages over either approach alone. The presented unified design uses the same back end for both styles of binding, maximizing code reuse without sacrificing performance. This session covers the design of xpressive and the advantages of its dual-mode approach.

APPLICATIONS AND ENVIRONMENTS

CAE302: Introducing C++ View Objects
Gabhan  Berry
Creating a view of data is a concept used extensively by database programmers, but is rarely used in other programming fields. Views offer an alternative way of sorting, grouping and filtering your data; an alternative to keeping multiple copies of your data and an alternative to reordering your data to make it more convenient to look at. With the STL, C++ programmers have the tools at hand to utilise the view concept in their programs. Instead of the data being in databases, the data is in STL containers. This session shows how to develop your own View Objects and benefit from the efficiencies and flexibilities they bring.

CAE205: Introduction to Component-Level Testing
John Lakos
Ensuring high reliability is achieved only by design—fine-grain modular (component-based) design. Given a well-factored decomposition, it is possible to write highly effective, thorough tests at a cost that is *linear* in project size. This session begins by exploring what it means to test. We'll then survey existing and novel test data selection methods that we find useful. Next we discuss the four basic techniques we use routinely to implement our test cases. Finally, we'll discuss how to order test cases within a standalone driver program to exploit class functionality in order to boot-strap, and thereby streamline the testing process.

CAE304: Moving C++ Applications to the Common Language Runtime
Kate Gregory
Come and see how real C++ projects are moving to the CLR without a full port or rewrite. Learn how to easily migrate existing native code -- including MFC applications -- to run under the CLR. Strategies for choosing which parts of the application remain native and which are managed will be discussed. See how to take advantage of the power of the framework libraries. Finally, this session will provide guidance on how to build high-performance managed “wrappers” enabling reuse of native libraries.

CAE301: Practical Generative Programming Using C++ AND XML
Schalk Cronjé
It has been five years since the landmark publication of Generative Programming by Czarnecki and Eisenecker, yet few of those techniques have become internalized in the knowledge spheres of software engineers. In this session, I distill a number of the complex topics down to practical application advice on how to use these techniques today. This includes using XML to capture configuration knowledge, implementing components using generic programming techniques, and glueing everything together using C++ traits classes generated from configuration knowledge. Two different approaches will be shown with practical examples that can be used by nearly any team working on medium to large projects.

CAE303: Real-World Development of Large-Scale C++ Software Capital in Legacy Environments
Peter Wainwright
The creation of large repositories of reusable C++ (also called software capital) through component-based development is by now well-understood, if not universally applied. However, one of the barriers to application is the sad fact that few companies and organizations are in a position to architect their code bases according to the principles of software capital from scratch. This session will discuss the real-world problems and solutions of adopting component-based development where an existing legacy code base already exists. By extending the principal of logical-physical cohesion to manage legacy software, it is easy to achieve the benefits of sound physical design even when legacy libraries and third-party products must be incorporated.

UI DESIGN

VUI101: Tablet 100 – Ink as Graphical Medium
Charles Petzold
Abandoning content in favor of style, this session focuses on integrating Ink with GDI+, both in real time and to create permanent graphical images in metafiles.

C++ Panel Discussion

CPANEL1: 20 Years of C++ and Going Strong
Herb Sutter
Scott Meyers
Bjarne Stroustrup
Andrei Alexandrescu
Douglas Schmidt
Panel discussion.

CPANEL2: The Future of C++
Herb Sutter
Bjarne Stroustrup
Panel discussion.