Public Talks in 2003

I just updated my Seminars page (http://www.aristeia.com/seminars.html) to
reflect the talks I've agreed to give at conferences in the first half of
2003. Briefly, I'll be in Santa Clara, CA, for Software Development in
March; in New Orleans, LA, for VS.NET Connections in May; and in Orlando,
FL, to give a keynote at STAREast, also in May.

Some of the conference sites don't have talk descriptions up yet, so not
all of my talk titles are currently linked to an abstract. I'll take care
of the links when I can, but as a mailing list exclusive, below I've listed
the talk descriptions I submitted to the various conferences. Please bear
in mind that what they print is not always what I sent them, sigh. All the
listed talks are for approximately 60-90 minutes except for "Effective STL
Programming," which is an abbreviated version of my standard seminar
described at http://www.aristeia.com/estl/index_frames.html; the conference
version will be only half the usual length (the usual length is two days),
so I'm going to have to chop a bunch of stuff out.

It's not official yet, but there's a very good chance I'll be back in
Germany (probably in Berlin and elsewhere) the second half of September.
I'll keep you posted on that and anything else that develops.

I hope to see you sometime, somewhere in 2003!

Scott


Library Design and the C++ Standard Library

One of the goals of the standard library is to demonstrate good library
design. Scott's been studying and critiquing class and library designs
for many years, and in this talk, he turns his attention to the standard
library. After promulgating several principles of good design, he looks
at the standard library to see how it measures up. The goal of this talk
is to learn some things about library design in general as well as the
standard library in particular. This talk focuses on the STL parts of
the library.


Better Software -- No Matter What

Traditional development methodologies preach one way to produce quality
software; agile methodologies preach something quite different. XP
advises developers to implement things as simply as possible, but it also
discourages sacrificing quality. Web site designers have to worry about
supporting multiple browsers and about minimizing round-trips to the
server, but native application developers worry more about runtime
performance. This talk argues that there are software development
practices that improve softare quality, regardless of the domain of the
application, the platform on which it runs, or the users it is intended
to serve. It further argues that there are minimal quality standards
that virtually all software should adhere to, regardless of its purpose.
In short, the talk is about improving software quality, no matter what
the software does, how it does it, or whom it does it for.


False Friends in C++

When learning a foreign language, it's common to encounter "false
friends:" constructs that look like things in your native language, but
that have different meanings. C++ developers moving from C to ARM C++ to
Template C++ to STL C++ to Exception-Safe C++ also encounter false
friends: new C++ constructs that look like old ones, but that behave
differently.

In this talk, Scott identifies a number of important false friends in
C++, explaining the differences between the pairs, why the differences
exist, and how to know which of the false friends should be used
when. Specific topics include declaring symmetric binary operators for
class templates, the interaction of implicit template instantiation and
implicit generation of special member functions, rules for overloading
resolution versus those for template parameter type deduction, passing
parameters to STL-compatible templates, testing for assignment to self in
exception-safe code, using swap on strings, and more.


Approaches to the Static Intialization Problem

Nonlocal static objects defined in different C++ translation units may be
initialized in any order. This becomes problematic when one such object
is dependent on another, i.e., when the order of initialization is
important. This talk recaps the static initialization problem and
describes the advantages and disadvantages of the three most common ways
of addressing it: the "nifty counter" trick, the GOF Singleton, and the
Meyers Singleton. The talk ends with a description of the Alexandrescu
Singleton, a new approach based on template metaprogramming.

This talk offers a nice mix of practical, down-to-earth information as
well as a glimpse into how work on template metaprogramming is beginning
to lead to workable approaches to real problems. It also offers a chance
to see how template templates can be used. You read that right: template
templates :-)


Rvalues in C++

In C, rvalues act much like const objects, and this is true for the C
subset of C++, too. Move beyond C, however, and the rules change. Rvalues
no longer arise in all the expected places, and even when they do, they
don't always act like their C-subset counterparts.

This talk starts with an overview of rvalues and lvalues in C, then shows
how the concepts apply in C++ and why what you know from C is unlikely to
help you much in C++. Scott then explores the relationships among
rvalues, const, assignment, member functions, references, and temporary
objects, focusing on how the interactions among these things affect C++
program behavior. As long as he's in the neighborhood, he also looks at
the related STL notions of iterators vs. const_iterators, constant
vs. mutable iterators, and, of course, the meaning of non-const constant
iterators.


Testing and Implicit Requirements: Expanding the Unwritten Spec

Some software requirements are so obvious, we don't even bother to write
them down. Words should be spelled correctly. Button labels should fit
within the boundaries of their buttons. The system should not freeze,
crash, or burst into flames. Such requirements are implicit, but they're
important. Though we rarely create test cases for them, we routinely
note when they are violated.

Both internal and external software quality would improve if the software
community would agree on additional implicit requirements, requirements
that grow out of a small number of fundamental quality principles. This
talk will introduce a few such principles and will examine the implicit
requirements they lead to.

Attendees of this talk will walk away with:

- An understanding of the importance of implicit requirements in software
testing.

- An awareness of software quality principles that give rise to implicit
requirements.

- Specific examples of things to test for (or at least to note during
testing) that will help enforce the new implicit requirements.


Effective STL Programming
(One Day Tutorial)

C++'s Standard Template Library is revolutionary, but learning to use it
well can be a significant challenge. This seminar, based on Scott's
latest book, Effective STL, reveals the critical rules of thumb employed
by the experts -- the things they almost always do or almost always avoid
doing -- to get the most out of the library. The seminar is divided into
the following modules:

Containers

The many technical issues that determine which container is best for the
job; the folly of trying to write container-independent code; why range
member functions are preferable to their single-element counterparts;
avoiding resource leaks when storing pointers; why containers should
never hold auto_ptrs; choosing the correct eraseing option.

vector and string

Why vector and string are preferable to dynamically allocated arrays;
using reserve to avoid unnecessary reallocations; using vector and string
with legacy APIs.

Associative Containers

The importance of equivalence, and how it differs from equality; why
comparison functions should always return false for equal values; issues
involved in in-place modification of set and multiset elements.

Algorithms

Choosing among sort, stable_sort, partition, stable_partition, and
nth_element; the true behavior of remove and remove-like algorithms and
how this interacts with containers of pointers.

Functors, Functor Classes, Functions, etc.

Why functor classes should be designed for pass-by-value; why predicates
should be pure.

Programming with the STL

Why algorithm calls are usually preferable to hand-written loops;
choosing among count, find, binary_search, lower_bound, upper_bound, and
equal_range; why function objects are more efficient than functions.

Recommended Reading

Useful books, articles, magazines, web sites, and newsgroups.

Audience

Systems designers, programmers, and technical managers involved in the
design, implementation, and maintenance of production libraries and
applications using the STL. Participants should already know the basic
features of the STL (e.g., containers, iterators, algorithms, and
function objects), but expertise is not expected. People who have learned
the STL recently, as well as people who have been programming with it for
some time, will come away from this intensive seminar with useful,
practical, proven information.

Difficulty Level

Primarily intermediate, with some more elementary and some more advanced
material.

Format

Lecture and question/answer. There is no hands-on programming.

Length

One full day.