I’m pleased to announce that Bjarne and I are going to have another two-day event co-located with SD West in San Jose, California, this March. Most of the talks are new ones we’ve never given publicly before, along with one or two classics.
Here’s the info page on my site: Stroustrup & Sutter #3.
For convenience, here’s a cut-and-paste of the session topics and abstracts. I look forward to seeing many of you in San Jose! Best wishes,
Monday, March 19
8:15-8:30am Welcome (Herb Sutter)
8:30-10:00am Concepts (Bjarne Stroustrup)
C++ templates are immensely flexible and the basis of most modern C++ high-performance programming techniques and of many elegant library designs. They are the key language feature behind the standard library’s algorithms and containers: the STL. However, they can also be tricky to use, cause spectacularly bad error messages when misused, and sometimes require unreasonable amounts of code to express apparently simple ideas. C++0x will address these issues directly, and the key to resolving the problems with templates without loss of flexibility or loss of performance is "concepts." Concepts provide a type system for C++ types and for combinations of C++ types and values. Thus, we are able to provide what feels a lot like conventional type checking for template arguments (including simple and elegant overloading based on template arguments). This presentation explains the notion of concepts and shows how to use concepts to write clearer and more robust generic code using templates. People who can’t wait for C++0x before trying out concepts (and other new C++0x features related to generic programming) can try the proof-of-concept implementation, ConceptGCC.
10:00-10:30am Break & mingling
10:30am-12:00pm Modern C++ Libraries: The Good, the Better, and the Sublime (Herb Sutter)
Besides the C++98 standard library, the key portable C++ libraries to know about today include the draft C++0x standard library extensions, the second set of standard library extensions now under parallel development in the ISO C++ committee (aka "TR2"), and of course the Boost libraries. This talk selects and presents what we consider to be some of the most important facilities in these libraries, guidance on the best practices for using them effectively, and a liberal dose of context and commentary.
Noon-1:30pm Lunch & mingling
1:30-2:45pm How To Design Good Interfaces: The Basic Interface Principles (Bjarne Stroustrup)
So: We have classes, derived classes, virtual bases, templates, const, overloading, exceptions, and a host of other useful language features. How do we use them to produce well performing maintainable code? All too often we get seduced into using powerful language features to write clever (i.e., complicated) code rather than to simplify our interfaces and to make the organization of our code easier to understand. This presentation is a tour of the most useful C++ features from the point of view of how they can be used to express the structure of code and to define interfaces that serve basic needs such as flexibility, early error detection, acceptable compile time, performance, decent error reporting, and maintainability.
2:45-3:00pm Break & mingling
3:00-4:30pm Design Patterns and Policy-Based Design (Herb Sutter)
This talk provides an overview of the importance of patterns and their role in C++ libraries. In the course of this material we will take an insightful look at two patterns in particular, showing the many implementation choices and tradeoffs available within the single pattern design, and how to choose among them for best effect. We will also see in detail how to apply policy-based design techniques to create very flexible and efficient implementations of a pattern in the form of pluggable and reusable template code.
4:30-4:45pm Break & mingling
4:45-5:30pm Grill the Experts: Ask Us Anything! (Bjarne Stroustrup & Herb Sutter)
This is your opportunity to get "thought leader" answers to your favorite C++ questions! We strongly encourage you to submit your questions in advance, preferably by email or in writing at the beginning of the seminar. Audience questions will also be taken from the floor. Both instructors will answer as many questions as time permits.
Tuesday, March 20
8:30-10:00am C++0x Overview (Bjarne Stroustrup)
We now know the basic outline of what will become C++0x (hopefully C++09). This presentation articulates the main principles of the design of C++0x, outlines the ISO C++ standards process, summarizes the new features and libraries, and gives key examples using new features. Major features, such as concepts, the memory model, and major libraries (such as threads and regular expression matching) are covered by other tutorials, so they will be only briefly mentioned here. The focus of this presentation is the various "minor" features, such as the unified initializer syntax (including variable length initializer lists), generalized constant expressions, "strong" enumerations, the new for statement, static assertions, and rvalue references. But a language is far more than a mere list of features: My aim is to show how these features fit together and fit with C++98 features to better support programming techniques. As ever, the ultimate aim of this language design is to allow clearer expression of real-world ideas, leading to better-performing and easier-to-maintain code. Even the "minor features" can significantly affect your programming style.
10:00-10:30pm Break & mingling
10:30am-Noon Machine Architecture: Things Your Programming Language Never Told You (Herb Sutter)
High-level languages insulate the programmer from the machine. That’s a wonderful thing — except when it obscures the answers to the fundamental questions of "What does the program do?" and "How much does it cost?" The C++ programmer is less insulated than most, and still we find that programmers are consistently surprised at what simple code actually does and how expensive it can be — not because of any complexity of C++ the language, but because of being unaware of the complexity of the machine on which the program actually runs. This talk examples the "real meanings" and "true costs" of the code we write and run especially on commodity and server systems, by delving into the performance effects of bandwidth vs. latency limitations, the ever-deepening memory hierarchy, the changing costs arising from the hardware concurrency explosion, memory model effects all the way from the compiler to the CPU to the chipset to the cache, and more — and what you can do about them.
Noon-1:30pm Lunch & mingling
1:30-2:45pm C++ In Safety-Critical Systems (Bjarne Stroustrup)
C++ is widely used in embedded systems programming and even in safety-critical and hard-real-time systems. This presentation discusses how to write code in these highly demanding application areas. First the mapping of C++ code to hardware resources is reviewed and the basics abstraction mechanisms (classes and templates) are reviewed from the perspective of this kind of code. Then, the JSF++ coding rules are examined as an example of a set of domain specific rules. These rules have been and are being used for the development of millions of lines of C++. Questions addressed include: "Can I use templates in safety-critical code?" (yes, you can and must) and "Can I use exceptions in hard-real time code?" (sadly no, not with the current level of tool support). Predictability of language features and minimization of
programmer mistakes are key notions.
2:45-3:00pm Break & mingling
3:00-4:30pm Writing Robust Concurrent Code Using the New C++0x and "TR2" Concurrency Libraries (Herb Sutter)
Concurrency is "the" must-know item for the next decade in any code where CPU performance is important, because from now on only well-written concurrent applications will be able to exploit the CPU power in commodity hardware. Where C++98 didn’t even have the notion of threads, C++0x and the second set of standard library extensions (aka "TR2") are adding strong support for concurrency, including useful libraries for atomic operations, threads and thread pools, locks, futures, and other useful features. This talk is not just a tour of these features; rather, it teaches important design principles and best practices for multithreading and shows how to write code to implement them using C++0x and TR2 features.
4:30-4:45pm Break & mingling
4:45-5:30pm Discussion on Questions Raised During the Seminar (Herb Sutter & Bjarne Stroustrup)
This panel is set aside for follow-up comments and discussion on issues that are raised during the seminar. During the other talks and panels, or during between-session chats, questions often come up that the instructors want to research. Some of the resulting information will be of general interest, and this final panel provides the needed convenient opportunity to promulgate it to everyone.