/* */ /* */

Friday, February 9, 2001

I'm giving talks at SD in San Jose in April

I've just been scheduled to give four presentations at the Software
Development Conference (http://www.sdexpo.com/) in San Jose on April 11 and
12. They're summarized at http://www.aristeia.com/seminars_frames.html,
but I'll save you the trouble of clicking:

ON WEDNESDAY, APRIL 11

Implementing a User-Defined operator->*

Most C++ programmers know little about operator->*, but the topic is both
interesting and instructive. Especially interesting is the use of
templates, including member and partially specialized templates. This
talk begins with a review of how operator->* is generally used, then
proceeds to examine two different ways to implement it for smart pointer
classes. It ends with a tantalizing idea: smart pointers to
members. (This talk is based on material in my 1999 DDJ article on the
same topic. You can read that article at
http://www.ddj.com/articles/1999/9910/9910b/9910b.htm.)

------------------------

The Strange Tale of auto_ptr

auto_ptr is a smart pointer template in the standard library with the
simplest of conceptual specificatons: an auto_ptr is an object that acts
just like a pointer, except it deletes what it points to when it (the
auto_ptr) is destroyed. This simple description turns out to mask a
design challege of considerable proportions, one that required two
fundamental rewrites during standardization, and even the final
specification for auto_ptr has noteworthy flaws. (For example, some of
its intended uses won't compile.)

This talk describes the tortured path auto_ptr travelled from initial
concept to final specification, focusing on the design challenges that
made auto_ptr so difficult to pin down. Attendees can expect to learn not
just about auto_ptr, but also about how several features of C++ can
interact to make a seemingly simple class extremely difficult to design.


ON THURSDAY, APRIL 12

Real World C++

When Scott started consulting on C++ projects, he figured his biggest
challenges would center on the proper use of language features. He was so
naive. Over the years, he's discovered that the biggest obstacles to
success in C++ involve a little C++, a fair amount of
language-independent software engineering, and a healthy dose of decent
management. This talk presents over a dozen specific guidelines that
Scott has found to significantly improve the chances of success on real
software projects in C++. Some guidelines focus on specific language
issues (e.g., casts, virtual destructors), while others focus on broader
matters (e.g., the need to embrace abstraction, the importance of
specifications, the need to develop staged releases). Compared to Meyers'
usual talks, this seminar is less intensively technical, but it covers a
broader array of issues, and it is definitely about C++ software
development.

------------------------

Something Cool in C++

Over the years, Scott has amassed a gallery of novel ways to use C++. In
this talk, he'll discuss one or more of these techniques. Perhaps he'll
discuss functors, maybe it'll be template-based dimensional analysis,
possibly it will involve traits or variations on the Visitor pattern, but
whatever the topic or topics, it's certain to demonstrate how C++
language features can be combined in unusual ways to produce elegant
solutions to real problems. Fasten your seat belts, it's going to be a
wild ride!

For the last talk, I'm currently leaning towards covering some of the
amazing stuff in Andrei Alexandrescu's soon-to-be-out "Modern C++ Design"
(http://www.aw.com/product/0,2627,0201704315,00.html), but I might decide
to go with something from my forthcoming "Effective STL" instead. (That
book will be out in mid-June, BTW. When more details become available,
this mailing list will be the first to know.) Or I might get inspired to
cover something completely different. That's the best thing about the
"Something Cool" talk: I get to cover whatever I want to :-)

I hope to see you at Software Development in April.

Scott

No comments: