Back by popular demand with all new topics & material!
SD is proud to present this 2-day tutorial from C++ Experts Bjarne Stroustrup and Herb Sutter. The VIP with C++ Tutorial Pass or the C++ Tutorial Pass are required for attendance. Please see our Pricing & Package page for details.
The day begins with a 25th-anniversary keynote placing C++ in historical and future context and setting the stage for all that follows. Then we quickly delve into what newly ISO-adopted C++ libraries are available today and how to get the most out of them now, how best to leverage C++'s multi-paradigm strengths, and how the industry sea change we know as the concurrency revolution is being addressed in C++.
Welcome
8:15am - 8:30am
25 Years of C++: Evolving a Language In and For the Real World
Bjarne Stroustrup
8:30am - 10:00am
25 years since I began work on the C++ programming language, and 20 years
since its first commercial release, the C++ programming language is 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.
The New ISO C++ Libraries
Herb Sutter & Bjarne Stroustrup
10:30am - 12:00pm
The ISO C++ committee has accepted and finalized the first round of extensions
to the C++ standard library, known as the Library Extensions Technical Report #1 (TR1).
From basic building blocks like shared_ptr, tuple, and function, to new containers
and a set of advanced math functions, this is a set of facilities directly applicable
to a broad range of programmers. Many of them are available today for you to use,
via Boost and other libraries. In this talk, the presenters give a tour of TR1 and
demonstrate selected important facilities, best practices for using them, and a liberal
dose of context and commentary.
Lunch & Mingling
12:00pm - 1:30pm
Speaking C++ as a Native: Multi-paradigm Programming in Standard C++
Bjarne Stroustrup
1:30pm - 2:45pm
BEST OF S&S: A reprise of Bjarne's popular talk at the first Stroustrup & Sutter seminar
Multi-paradigm programming is programming applying different styles of programming, such as
object-oriented programming and generic programming, where they are most appropriate. This
talk 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.
The Concurrency Landscape, C++(0x), and the Concur Project
Herb Sutter
3:00pm - 4:30pm
Changes in the hardware landscape are directly affecting the way we write software:
The free lunch of ever-greater single-threaded throughput is over, and only concurrent
applications can exploit the continued exponential performance growth in modern mainstream
CPUs. Unfortunately, none of today s mainstream languages and environments deal well
with concurrency, and ISO C++ doesn t even mention threads. This talk provides a summary
of the issues, how the ISO C++ committee is dealing with them in C++0x, and how it all
fits into a context and roadmap for our industry over the next five years. The second
part of the talk will consider my Concur project: By providing active objects, futures,
and parallel loops and algorithms, the Concur project aims to: a) define higher-level
abstractions; b) for today s (imperative) languages; c) that evenly support the range
of concurrency granularities; d) to let developers write correct and efficient concurrent
apps; e) with lots of latent parallelism (and not lots of latent bugs); f) that can be
mapped to actual hardware at run time to re-enable the free lunch.
Grill the Experts: Ask Us Anything!
Bjarne Stroustrup & Herb Sutter
4:45pm - 5:30pm
Audience questions will also be taken from the floor. Both instructors will
answer as many questions as time permits. (Note: We'll talk about everything
except future directions in C++. That is the focus of the second day.)
On Tuesday, we devote the morning to genericity, specifically template evolution in C++0x with Bjarne's concepts proposal, and a detailed side-by-side comparison of three modern genericity mechanisms: C++ templates (including C++0x concepts), .NET generics, and Java generics. We'll then wrap up the seminar with best ways to use C++'s strong mechanisms for abstraction, and delve beyond the usual exception-safety topics to show the best practices to apply and the clearest ways to think for building robust and reliable C++ code.
C++0x: A "Concept"ual Overview
Bjarne Stroustrup
8:30am - 10:00am
A good programming language is far more than a simple collection of features.
My ideal is to provide a set of facilities that smoothly work together to support
design and programming styles of a generality beyond my imagination. Here, I 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, I present the new features that are
proposed or already accepted for the support of generic programming, such as the
key notion of concepts to provide a type system for template parameters (so that
we can get much better error messages and better overloading). Other proposals
include generalized initialization (initializer lists, generalized constant expressions),
auto (to avoid needless repetition of type names), decltype (son of typeof), and
template aliases (son of templated typedefs).
Genericity in C++, .NET, and Java
Herb Sutter
10:30am - 12:00pm
This talk compares and contrasts the generic type facilities of ISO C++ templates
(including C++0x concepts), .NET 2.0 generics, and Java 5 generics. We will analyze
their respective strengths and weaknesses (yes, they do all have strengths and weaknesses),
see what kinds of problems they are designed to solve, and analyze when and where each is appropriate.
We'll also put them through their paces with live code-writing and demonstrations of the
three facilities. C++ templates will be demonstrated in C++ and Java generics in Java
(of course), and .NET generics in both C++ and C#.
Lunch & Mingling
12:00pm - 1:30pm
Abstraction and the C++ Machine Model
Bjarne Stroustrup
1:30pm - 2:45pm
C++ was designed to be a systems programming language and has been used for
embedded systems programming and other resource-constrained types of programming
since the earliest days. The aim was - and is - to support elegant high-performance
code. This paper will briefly discuss how C++'s basic model of computation and data
supports time and space performance, hardware access, and predictability. If that was
all we wanted, we could write assembler or C, so I show how these basic features
interact with abstraction mechanisms (such as classes, inheritance, and templates)
to control system complexity and improve correctness while retaining the desired
predictability and performance.
Error-Safe C++: More Than Just Exception Safety
Bjarne Stroustrup & Herb Sutter
3:00pm - 4:30pm
Much has been written, especially by us, on writing exception-safe code. In this talk we'll
summarize the ground rules (some of them new) for writing exception-safe code, including
how to use exceptions, best practices of RAII, and dealing with constructor exceptions.
But we'll also cover error safety in all cases, because the main difficulty in writing
exception-safe code has little to do with exceptions in particular, but with error
handling in general: Why are the exception safety guarantees really error safety
guarantees that apply to all kinds of error reporting, not just exceptions? What
really is an error; how can we define that rigorously, in order to distinguish
between errors and non-errors? What error-safety guarantee should any function provide?
Why should you prefer to use exceptions to report errors, but when should you not
use exceptions? When should you translate error codes or exceptions to a different
error reporting model? We will answer these and other questions to provide guidelines
for writing robust, industrial-strength C++ code.
Discussion on Questions Raised During the Seminar
Herb Sutter & Bjarne Stroustrup
4:45pm - 5:30pm
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.