BACK BY POPULAR DEMAND! UPDATED, WITH NEW CLASSES & MATERIALS.
Herb Sutter and Bjarne Stroustrup are back at SD West for their third Stroustrup & Sutter on C++ super session. They've packed this two-day tutorial with fresh talks—most never presented before—filled with informative, enlightening and highly pragmatic material. The tutorial is structured with both talks and panels, and liberal break times so that the instructors and attendees can mix and eat and chat together. Speakers bio are below.
The VIP with C++ Tutorial Pass or the C++ Tutorial Pass are required for attendance. Please see our Pricing & Package page for details.
DAY 1: Monday, March 19
Welcome
Monday, March 19, 8:15 AM - 8:30 AM
Concepts
Monday, March 19, 8:30 AM - 10:00 AM
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, can 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're 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.
Modern C++ Libraries: The Good, the Better and the Sublime
Monday, March 19, 10:30 AM - 12:00 PM
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 (a.k.a. "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.
Lunch: 12:00 PM - 1:30 PM
How to Design Good Interfaces: The Basic Interface Principles
Monday, March 19, 1:30 PM - 2:45 PM
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're seduced
into using powerful language features to write clever (i.e., complicated) code,
rather than to simplify our interfaces and make the organization of our code
easier to understand. This presentation is a tour of the most useful C++ features,
revealing 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.
Design Patterns and Policy-Based Design Herb Sutter
Monday, March 19, 3:00 PM - 4:30 PM
This talk provides an overview of the importance of patterns and their role
in C++ libraries. We will take an insightful look at two patterns in particular,
showing the many implementation choices and trade-offs 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.
Grill the Experts: Ask Us Anything!
Monday, March 19, 4:45 PM - 5:30 PM
Herb Sutter & Bjarne Stroustrup
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 e-mail 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.
DAY 2: Tuesday, March 20
C++0x Overview
Tuesday, March 20, 8:30 AM - 10:00 AM
Bjarne Stroustrup
Design Patterns and Policy-Based Design We now know the outline of what will
be C++0x (hopefully, C++09). This presentation articulates the main principles
underlying C++0x's design, outlines the ISO C++ standards process, summarizes
new features and libraries, and gives key examples using new features. Major
features—such as concepts, the memory model and major libraries—will only
be briefly mentioned as they're covered in other sessions. This presentation
focuses on 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. A language is far more than a list of features: This presentation
will reveal how these features fit together and fit with C++98 features to better
support programming techniques. As ever, the 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.
Machine Architecture: Things Your Programming Language Never Told You
Tuesday, March 20, 10:30 AM - 12:00 PM
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 we're 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 versus 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.
Machine Architecture: Things Your Programming Language Never Told You
Tuesday, March 20, 10:30 AM - 12:00 PM
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 we're 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 versus 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.
Lunch: 12:00 PM - 1:30 PM
C++ in Safety-Critical Systems
Tuesday, March 20, 1:30 PM - 2:45 PM
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.
Writing Robust Concurrent Code Using the New C++0x and "TR2"
Concurrency Libraries
Tuesday, March 20, 3:00 PM - 4:30 PM
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 (a.k.a. "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.
Discussion on Questions Raised During the Seminar
Tuesday, March 20, 4:45 PM - 5:30 PM
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.
Bios:
Bjarne Stroustrup is the creator and original implementer of the C++ programming language, and the College of Engineering Professor of computer science at Texas A&M University. He also retains a link to AT&T Labs - Research as a member of the Information and Systems Software Research Lab. Over the years, he has written a few books (including The C++ Programming Language and The Design and Evolution of C++), written a lot of papers, and given some interviews.
Herb Sutter is a leading authority on software development, and a software architect at Microsoft where he was lead architect of C++/CLI. He also serves as chair of the ISO C++ standards committee and is the author of four books and hundreds of technical papers and articles on software development topics, including the widely referenced article "The Free Lunch Is Over" which coined the term "concurrency revolution."
