EC++/3E is Finished

Just a quick note to let you know that I sent final camera-ready copy of
the third edition of Effective C++ to my publisher last week. I expect
physical books to exist in bookstores around the end of May. Between now
and then, there will be sample Items posted at various locations, and it
looks like at least one will appear as an article in DDJ. I'll make
announcements here when those things happen.

Sample Items and magazine articles are part of a marketing campaign
designed to whip you into a buying frenzy, but if you're already gripped by
frenzy and like to order books from Amazon, I'd appreciate it if you'd do
it via the following link, because then I get a small kickback from Amazon.
(The cover image, ISBN, and ordering information for the book is correct,
but most of the textual information (e.g., reviews) at that site is for the
second edition, not the third, sigh.)


http://www.amazon.com/exec/obidos/tg/detail/-/0321334876/ref=ase_scottmeyersho-2\
0/103-3864411-8060659?v=glance&s=books

I can't in good conscience fail to note that you can buy it for less at the
Addison-Wesley web site, where I don't get a kickback, but where the
supporting information corresponds to the new edition. The URL for that is

http://www.awl.com/cseng/titles/0-321-33487-6/

I hope you enjoy the third edition of Effective C++. It's a significant
update, as you'll be able to see from the information at the AW web site.

Scott

Partnership with DevelopMentor; September Talks in Germany

Two things:
- New training partnership with DevelopMentor.
- September talks in Ludwigsburg, Germany.

TRAINING PARTNERSHIP

For some time now, demand for my training services has outstripped my
availability, and I've been looking for a way to address this mismatch
without compromising quality. I ultimately decided to enter into a
partnership with DevelopMentor, a training company I've known since
1995. I've worked with the DevelopMentor people as a class instructor, as
a class attendee, and as a provider of training materials, and I've always
been impressed with their way of treating people (well), the quality of the
training they provide (high), and their commitment to maintaining these
ideals (consistent). As a result of the partnership, DevelopMentor will
have exclusive access to my training materials and will be able to offer my
courses using instructors I've personally approved. Their web site is
http://develop.com/ and their main page for my courses is
http://develop.com/us/technology/technology.aspx?tech=7


SEPTEMBER TALKS IN GERMANY

As I've done for the past several years, I'll be giving a week of talks in
Germany in the fall. The talks themselves will be in English, though, if
you are particularly unlucky, I may try to speak to you in German if you
are there. You'll find a list of the talks at the usual place:

http://www.aristeia.com/seminars.html

Scott

Updated Errata for MEC++ and ESTL

I just updated the errata pages for MEC++ and ESTL. You'll find them at
the usual places
(http://www.aristeia.com/BookErrata/mec++-errata_frames.html and
http://www.aristeia.com/BookErrata/estl1e-errata_frames.html), but the new
entries are as follows:

For MEC++:

DATE DATE
REPORTED WHO PAGES WHAT FIXED
-------- --- ----- ------------------------------------------------ --------
9/16/04 fb Many Many single-argument constructors in the book
would best be declared explicit. [This bug
report should be combined with sk's existing
3/5/96 Interesting Comment on the same topic.]

1/22/05 tk 54 As noted above by cc about page 50, fully
constructed objects will be automatically
destroyed if an exception is thrown, but this
guarantee applies to local (i.e., auto) objects
only if the exception is caught. Add a footnote
alluding to the footnote on pg. 50.

10/27/04 ms 67 In 1st para, should also mention that a catch
clause for runtime_error can also catch
underflow_error exceptions.

9/12/04 nd 70 In code at bottom of page, both "what" member
functions should be declared const.

9/12/04 nd 71-2 Once the decision to catch by reference has been
made, a decision must be made about whether to
catch by refernce-to-const. As always, const
should be used unless the handler needs to be
able to modify the exception object.

8/24/04 ms 155 HeapTracked::operator delete incorrectly throws
an exception if asked to delete the null pointer.
It should do nothing in that case.


For ESTL:

DATE DATE
REPORTED WHO PAGES WHAT FIXED
-------- --- ----- ------------------------------------------------ --------
9/18/04 dxm 44 The comment next to the call to remove_copy_if
near the bottom of the page could suggest that
values are removed from c before copying them to
goodValues. In fact, c is not modified at all;
undesired values are simply skipped during the
copy. Reword.

12/21/04 nds 67 In the description for resize, it's not true that
if n is less than the current size, new
default-constructed elements will be added.
Rather copies of a single
default-constructed element will be added.


Scott

New book in my Series; Updated "Upcoming Talks" List

The latest book in my Effective Software Development Series, Bill Wagner's
Effective C#, has recently been published, leading me to hope that people
will stop asking me when I'm going to write it :-) I learned a lot from
reading it, and I think you will, too. For details on the book, check it
out at AW (http://www.awprofessional.com/title/0321245660) or Amazon
(http://www.amazon.com/exec/obidos/tg/detail/-/0321245660/qid=1105253646/sr=8-1/\
ref=pd_ka_1/104-5668479-8651933?v=glance&s=books&n=507846).

You might also want to check out my updated "Upcoming Talks" page at
http://www.aristeia.com/seminars_frames.html, because there are five new
listings for March (four at the Software Development conference).

I wish you all a happy, healthy, and prosperous 2005,

Scott

New Open-Enrollment Seminars Scheduled

After I announced the existence of my new training course, "What's New in
Effective C++?", several people wrote to ask when it would be available for
enrollment. One thing led to another, and now I've scheduled two new
open-enrollement seminars at OGI (in Beaverton, Oregon) in January:

18 Jan 2005: Better Software -- No Matter What
19 Jan 2005: What's New in Effective C++?

You'll find links to all the details on these seminars (as well as to the 15
December offering of "Effective C++ in an Embedded Environment") at my "Upcoming
Talks" page, http://www.aristeia.com/seminars_frames.html

I hope to see you at one or more of these seminars.

Scott

Wanted: Candidate reviewers for EC++/3E

I'm making decent headway on the next edition of Effective C++, but I have
a problem: I need to find a few good pre-publication reviewers to read my
draft and tell me how I can improve it. Now, I know all kinds of C++
experts, but the target audience for my book isn't experts, it's practicing
programmers who are at roughly an intermediate level of knowledge and
experience with the language. As somebody who subscribes to this mailing
list, it is highly likely that you do NOT qualify; you already know too
much. However, perhaps you know somebody who might qualify, somebody who
is comfortable with the basics of C++, but who is interested in knowing
more. If you do, and if that person would be willing to undertake the hard
work of reading 250-300 pages of not-fully-refined prose and offer detailed
suggestions on how the book could be improved (without regard for whether
they will hurt my feelings -- I *need* to know the bad stuff), and if that
person would be available for the task beginning sometime in January and
ending no more than about a month later, I'd appreciate it if you'd have
them contact me.

I don't need very many people for this -- maybe 2 or 3. My preference is
to have a small number of high-quality reviewers rather than a large number
of poorer-quality reviewers. But my need for this small number of
high-quality reviewers is great, because I can't produce a book that's
truly useful to its target audience if I don't get advance feedback from
people in that audience. Experts can help me identify subtle coding or
reasoning errors, but non-experts can tell me "I have no idea what you are
talking about in this paragraph," and that's the kind of thing I really
need to know.

There's no monetary compensation for this work. Rather, people who do it
get (1) a chance to make a real impact on the final version of the book,
(2) an autographed copy of the final book, possibly with a custom cover
that only a few people will get (I'm not sure about that last part, I have
to work it out with my publisher), and (3) my sincere gratitude.

People who are interested should contact me directly.

Thanks very much for your help with this.

Scott

New Training Course; Updated Projects List

I've added a new course to my "Training" page
(http://www.aristeia.com/whatsNewInEC_frames.html). It's a much more
detailed description of the "What's New in Effective C++?" seminar, which I
debuted last month in Germany. Good course, in my opinion, but I can't
claim to be fully objective :-)

BTW, if you took a look at my "Project Ideas" page
(http://www.aristeia.com/projects_frames.html) immediately after I sent out
the announcement about it, you may have missed the "Lint with autofix" and
"Detailed Exhibit Information" ideas that I added a few hours later. If
so, I encourage you to check out those projects now, as I'm especially
eager to see somebody pursue them.

Scott

New "Project Ideas" Page

From time to time, I come up with ideas for projects or articles that I'd
like to pursue, but which I know in my heart of hearts I'll never find time
for. Rather than let the ideas wither and die in my "Stuff I'd like to do
but never will" folder, I decided to put them at my web site, with the hope
that somebody else will pursue them and write up the results. You can find
the initial list of project ideas at
http://www.aristeia.com/projects_frames.html. Have at it!

Scott

"Double-Checked Locking" Article now online

The DDJ article that Andrei Alexandrescu and I wrote for DDJ is now
available at my web site. It's the first entry listed at
http://www.aristeia.com/publications_frames.html. I recommend the
"slightly updated" version, because it's, um, slightly updated, but you'll
definitely want to print it to read it, because the LaTeX-derived PDF is
really ugly on-screen.

Scott

New Series Book, "Effective Enterprise Java"

The latest book in my "Effective Software Development Series" is now out:
Effective Enterprise Java, by Ted Neward. I don't pretend to be a
hard-core Java or Enterprise guy, but I really enjoyed watching this book
unfold as it was being written. It's filled with pragmatic advice from a
guy with lots of experience who knows how to explain what he is talking
about. If you're a Java developer in an enterprise environment, or if you
just like a well-written book that's filled with useful insights about
programming enterprise systems, I encourage you to give this book a look.
Right now, it's on sale at Amazon for about 1/3 off
(http://www.amazon.com/exec/obidos/tg/detail/-/0321130006/qid=1095719933/sr=8-1/\
ref=pd_csp_1/104-5668479-8651933?v=glance&s=books&n=507846),
and no, I don't get a kick-back if you buy via that link :-)

As long as I have your attention, let me remind you about my upcoming talks
in Germany (Stuttgart and Berlin) and Canada (Vancouver at OOPSLA). There
are links to all the talks at http://www.aristeia.com/seminars_frames.html,
but at the time I wrote those descriptions, the talks existed only in my
head. I'm now done with two of them ("Better Software -- No Matter What"
and the revamped "Design Patterns, Templates, and Policy-Based Design"),
and I have to say that I'm very pleased with the way they came out. If
you'd like to see a description of one or both of these talks that was
written after the talk was done (so I *really* knew what would be in it),
let me know, and I'll happily send you an updated description. One of
these days the new descriptions will make it to my web site, but I'm
holding off on that until I finish the last new talk I'm working on for
Germany, "What's New in Effective C++?"

Scott

Minor update to EC++ Errata

In response to the latest reprint request from Addison-Wesley, I updated
the errata list for EC++. Below are the latest changes (in my usual "sort
of HTML" format).

Scott


DATE DATE
REPORTED WHO PAGES WHAT FIXED
-------- --- ----- ------------------------------------------------ --------
5/16/04 md 77 "an intuitive semantics" ==> "intuitive
8/15/04
semantics"

5/16/04 md 83 "minimalness" ==> "minimality"
8/15/04
244

7/ 7/04 al 205 valueDelimOpen and valueDelimClose should be
8/15/04
declared private in MyPerson, because clients
should not be able to call them. They're just an
implementation detail of the class.

Interesting Comments:

DATE
REPORTED WHO PAGES WHAT
-------- --- ------- ----------------------------------------------------------
7/21/04 am 179-180 Another way to deal with the need to downcast if you can't
redefine allAccounts or BankAccount is to declare
something like NewBankAccount as a sibling class to
SavingsAccount and CheckingAccount, then adopt a policy of
deriving new classes only from NewBankAccount. You'll
still have to downcast from BankAccount to Savings-,
Checking-, or NewBankAccount, but once you're in
NewBankAcount, you can use a virtual creditInterest.

Request for comments on extended "Easy to use correctly, hard to use incorrectly"

I'm working on materials for my upcoming full-day seminar, "Better Software --
No Matter What," (see http://www.aristeia.com/seminars_frames.html for scheduled
offerings) and I've put together a draft of the portion of the seminar on the
guideline, "Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly."
This is essentially an extended version of the arguments I advance in my recent
IEEE Software article (
http://www.aristeia.com/Papers/IEEE_Software_JulAug_2004.pdf).

The materials include a number of examples of interfaces that violate the
guideline, but I'm interested in other examples, because too many of mine are
drawn from C++ and Windows. (The talk is language- and platform-independent.)
If you have time and interest, I'd appreciate it if you'd take a look at the
materials at http://www.aristeia.com/Personal/easyhard.pdf and let me know if
you have any other examples that would reinforce my points. If you have other
comments on the materials in general, I'd welcome those, too.

Thanks very much for your help in my campaign to identify ways for programmers
to improve software quality.

Scott

ESTL Errata Updates

It turns out that ESTL is ready for a reprint, too, so I've updated the
ESTL errata page at
http://www.aristeia.com/BookErrata/estl1e-errata_frames.html. The new
additions (not all of which I fixed for the upcoming printing -- the errata
page shows which ones I did) are as follows:

Bugs:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- ------------------------------------------------
6/ 4/04 tb Item 7 Item title should make clear that this applies
only when the container owns the pointers.
Containers of pointers not owned by the
containers should of course not use delete on
them.

6/28/04 he 197 The statement in the 2nd prose paragraph that
"equal_range not only does the job of find for
sorted ranges, it also replaces count" is
incorrect, because this part of the Item is
discussing STL algorithms, and the equal_range
algorithm is based on equivalence, while the
find and count algorithms are based on equality.

7/20/04 gc 228 Regarding reference [24], the article appeared in
December 2000 (not November), and the URL for that
article is now
http://www.cuj.com/documents/s=8000/cujcexp1812austern/

2/28/04 mp 257 Add an index entry under "set" pointing to page
199 for "idiomatic test for membership."

Interesting Comments:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- -----------------------------------------------------------
3/29/04 df 74 An alternative to "&v[0]" is "&v.front()". df argues
that this is "the most explict way to do it." To me,
"&v[0]" is equally explicit, but both work.

1/ 4/04 or Item 24 Another advantage to a function like efficientAddOrUpdate
vis-a-vis operator[] is that use of operator[] requires
that the value type of the pair (i.e., the mapped_type)
support default construction for insertion, but
efficientAddOrUpdate does not.

Scott

MEC++ Errata Updates

I just got word that MEC++ is up for another reprint, so I took the
opportunity to update the errata list. There are only three new entries:

DATE DATE
REPORTED WHO PAGES WHAT FIXED
-------- --- ----- ------------------------------------------------ --------
! 4/19/04 cc 50 The para after the first code fragment says that 7/24/04
the window will always be destroyed, even if an
exception is thrown, but this this true only if
the exception is caught. If it's never caught,
there is no guarantee that local objects will be
destroyed.

! 6/ 9/04 jw 70 In 3rd para, bad_typeid isn't thrown when a null 7/24/04
pointer is used with dynamic_cast, it's thrown
when a null pointer is dereferenced in a call to
typeid.

Interesting Comments:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- -----------------------------------------------------------
1/18/04 sdm Item 34 A topic related to this Item is how to link object code
generated from different C++ compilers. For one take on
that topic, consult Karsten Hoof's February 2004
CUJ article, "GNU & Native Compilers." For another,
see Joe Goodman's March 2004 CUJ article,
"Interoperability & C++ Compilers."

Scott

DDJ Article Conclusion; Seminars in Germany and at OOPSLA

Part 2 of the article by Andrei Alexandrescu and me on double-checked locking is
now out in the current (August) issue of Dr. Dobbs Journal. If you're not a DDJ
subscriber, I believe that you can download a PDF copy of the magazine from
DDJ.com. If not, the full article (both parts) will be available at my web site
in mid-October. Check in with http://www.aristeia.com/publications_frames.html
at that time for links.

During the first week of October, I'll be giving seminars in Stuttgart and
Berlin. The Stuttgart seminars should be especially fun, because they're either
new and improved or just plain new. Briefly, here are the topics for Stuttgart:

- DESIGN PATTERNS, TEMPLATES, AND PBD. This will be a revision of my current
course on this topic to focus more on variations of well-known patterns instead
of on GOF patterns themselves.

- WHAT'S NEW IN EFFECTIVE C++? I'm working on the third edition of the book
now (a significant rewrite), and this brand new seminar will cover material new
to the third edition.

- BETTER SOFTWARE -- NO MATTER WHAT. A language-independent seminar on things
programmers can do to improve software quality. This includes my keyholes work
as well as a lot more. This will be a full-day version of a seminar that has
never been longer than a half-day before.

In Berlin, I'll be presenting my two-day STL seminar based on Effective STL.

At OOPSLA in late October, I'll be reprising BETTER SOFTWARE--NO MATTER WHAT.
OOPSLA attendees should benefit from the feedback I get from the world premiere
in Stuttgart :-)

For details on all my upcoming seminars, consult my Upcoming Talks Page,
http://www.aristeia.com/seminars_frames.html.

Scott

Guest Column in current IEEE Software

Some 18 months ago, Martin Fowler asked me if I'd be interested in
guest-writing his "Design" column in IEEE Software. I said that I would
once I figured out what I wanted to write about. I finally did, and you
can find the result in the July/August issue of the magazine. Thanks to
the kind people at IEEE Software, you can also view a PDF copy at:

http://www.aristeia.com/Papers/IEEE_Software_JulAug_2004.pdf

Scott

EC++ Errata Page Updated

I just got word that Effective C++ is due for another reprint, so I've
updated the book's errata page with the latest changes. None of the bugs
I fixed is technical in nature, but there they are, anyway:

DATE DATE
REPORTED WHO PAGES WHAT FIXED
-------- --- ----- ------------------------------------------------ --------
4/ 4/04 sdm xiii Bad line break in URL in footnote. 6/ 7/04

5/20/04 md 107 At end of 3rd para, "SHRT" is in wrong font. 6/ 7/04

6/ 1/04 md 203 In last line, "theName" ==> "name". 6/ 7/04

6/ 7/04 sdm 203 Bad line break in 2nd-to-last para in 6/ 7/04
"valueDelimOpen".

6/ 2/04 md 218 In 2nd to last line, "accidently" ==> 6/ 7/04
"accidentally". Both spellings are correct but
I use the "ally" form everywhere else in the
book, so I should use it here, too.

1/19/04 jyt 231 Arrow tail protrudes slightly into the oval 6/ 7/04
surrounding "overflow_error".

For those of you who like to keep track of such things, this will be the
book's 16th printing.

I also added this observation to the "Interesting Comments" part of the
book's web page:

DATE
REPORTED WHO PAGES WHAT
-------- --- ------- ----------------------------------------------------------
1/19/04 jyt Items There are several example base classes in the book that
16, declare nonvirtual destructors or that declare no
22, destructor at all, a violation of Item 14.
26,
40,43,
49,50

Scott

Recent Bogus Message and What I've Done About It

As many of you noticed, somebody recently spoofed my email address and sent out
a message with a subject of "Re: Hello" and a worm-laden attachment. Sigh.
I've since deleted the bogus message from the web site archives, and I've
reconfigured the mailing list so that all postings not only have to come from
me, they also have to be approved by me before they are propagated. I hope that
this will prevent further abuse of the mailing list.

As an aside, when I poked around the administrative portion of the mailing list,
I found that since starting the mailing list four years ago, I've sent out only
68 messages, but 2300 unauthorized messages have been automatically rejected.
In retrospect, I suppose I'm lucky that only one bogus message has been
propagated, but I still feel badly for wasting your time.

While I was housecleaning at Yahoo, I also deleted two bogus files in the
download area.

With luck, I won't need to bother you about this for another four years. I
apologize for the inconvenience of what has already happened.

Scott

New article in the current DDJ

Over the course of several months, Andrei Alexandrescu and I wrote what we
think is a nice article on why double-checked locking can't be made to work
portably in C++. Dr. Dobb's Journal agreed to publish it, but they decided
it was too long for a single article, so they broke it into two pieces.
The first piece just came out in the July issue. The second part will be
published in the August issue (which, in classic magazine publishing logic,
will be available around the beginning of July).

We hope you enjoy the article. If not, it'll clearly be Andrei's fault :-)

Scott

Upcoming Talks Update

Two talk-related items:

- My seminar on using C++ in embedded systems, originally scheduled for
May 6 at OGI CPD (the Oregon Graduate Institute Center for Professional
Development), has been postponed due to some newly-cropped-up
scheduling conflicts. It will be rescheduled for sometime this summer.

- My talk next Wednesday on "Double-Checked Locking, Threads, Compiler
Optimizations, and More" at the Northwest C++ Users Group in Redmond,
WA, is still on. This is just a reminder. I gave this talk at the
Software Development Conference a couple of weeks ago, and I really do
think you'll find it interesting. There's just a lot going on under
the hood in a C++ program.

For details on all my upcoming talks (including those above), visit my
talks page: http://www.aristeia.com/seminars_frames.html

Scott

New talks scheduled in Redmond, WA, and Beaverton, OR

In addition to the four talks I'll be giving at the Software Development
(SD) Conference in Santa Clara, CA, next week, I've scheduled two new
presentations:

April 14 in Redmond, WA: Double-Checked Locking, Threads, Compiler
Optimizations, and More

May 6 in Beaverton, OR: Effective C++ in an Embedded Environment

The April 14 talk (which is the same as my first SD talk next Wednesday) is
the result of joint work with Andrei Alexandrescu over the course of
several months as we struggled to figure out the interaction of threads,
volatile, lazy initialization, instruction reordering, cache coherency, and
other topics. I think the material is quite interesting.

The May 6 talk on using C++ for the development of embedded systems is one
I've given for a year or so, but I keep tweaking the material in response
to insights from embedded developers. The May 6 presentation should be the
best one yet.

As always, you'll find a summary of my upcoming public appearances at
http://www.aristeia.com/seminars_frames.html, including links to full
descriptions of each talk.

I hope to see you at one or more of my talks in Santa Clara, Redmond, or
Beaverton.

Scott

Updated Errata Lists

I've just completed my customary year-end updates to all my publications'
errata lists. The revised lists are at the usual URLs; you'll find links
to them at http://www.aristeia.com/books.html#errataLinks
As a mailing-list exclusive, below you'll find summaries of the new
entries.

As always, I hope you find the errata useful, and I apologize for their
needing to exist. Sigh.

Scott





NEW ENTRIES FOR EFFECTIVE C++:

Interesting Comments:

DATE
REPORTED WHO PAGES WHAT
-------- --- ------- ----------------------------------------------------------
11/13/03 dfc 9, The code for the String class isn't exception safe. When
73 I wrote the book, I frankly wasn't concerned about
exception safety, but I should have been. When I write
the third edition of the book, I'll be careful to pay
attention to exception safety throughout.

12/10/03 sn Item 12 As Item 11 explains, bitwise copy is virtually always
incorrect for pointer data members, but it is often
simpler to "do the right thing" via assignment vis-a-vis
initialization for pointer data members. So it may make
sense to assign to pointer data members instead of
initializing them.



NEW ENTRIES FOR MORE EFFECTIVE C++:

Interesting Comments:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- -----------------------------------------------------------
12/18/03 sdm Item 31 Nat Goodspeed's article in the January 2004 DDJ, "Double
Dispatch Revisited", contributes an interesting new
approach to implementing support for double dispatch that
also supports inheritance.



NEW ENTRIES FOR EFFECTIVE STL:

DATE DATE
REPORTED WHO PAGES WHAT FIXED
-------- --- ----- ------------------------------------------------ --------
9/17/03 hs 99 The claim in the 3rd prose para that map nodes
could be put in write-only memory is dubious.
Among other things, the value part of the pair
is generally modifiable, and the node almost
certainly has pointers to its children, which
may change over time.

9/17/03 hs 163 In the middle of the page,
DoSomething::operator() should be declared
public.

12/22/03 mc 201 I should make clearer in my discussion of
multimap::find vs. multimap::lower_bound that
only lower_bound is guaranteed to locate the
*first* element with a given key value; find
is guaranteed only to locate *some* element
with the given key value. I may want to make
this clearer in the tables on pg. 200 and the
inside front cover, too.

7/28/03 jp 206 The problem would be in agreement with the
code, and clearer, if it said simply "get rid
of all the elements in the vector whose value
is less than x and that occur after the last
value at least as big as y".

Interesting Comments:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- -----------------------------------------------------------
11/04/03 sdm 67 According to my most recent tests, the last para on the
page continues to be true, but it's worth noting that
the vector that ships with VC7.1 (Visual C++ .NET 2003)
performs 17 reallocations. Instead of doubling the
capacity each time, it appears to grow at a rate of 1.5
instead.



NEW ENTRIES FOR THE EFFECTIVE C++ CD:

DATE DATE
REPORTED WHO WHAT FIXED
-------- --- ------------------------------------------------------- --------
3/12/02 ga In the final comment preceding P12 of M2 (Item
chunking), "hierarch" ==> "hierarchy".

3/12/02 ga In P2 of M4 (Item chunking), there is an extra space in
"( Item 28)".

Advice for Prospective Book Authors

Recently, I had my nth telephone call explaining the facts of publishing
life to a prospective book author, and it finally convinced me to do
something I've been threatening to do for years: write up some comments on
the topic. 12,000 words and several rounds of feedback from authors and
editors later, you can see the result at
http://www.aristeia.com/authorAdvice.html It's my hope that prospective
authors will find the information interesting and useful, while armchair
authors will at least find it interesting.

Happy New Year :-)

Scott

Fixing EC++ CD's Display Problems under IE6

In March of last year, I posted a message to this list explaining that my
Effective C++ CD doesn't display properly with version 6 browsers, and I
solicited patches to address the problems. I got a patched set of files
for IE6 from Attila Feher, but to my frustration and disappointment, they
disappeared into the Legal Department at Addsion-Wesley and never came out,
so I was unable to make them publicly available.

Earlier this month, however, I got a note from Ian Roberts explaining what
changes needed to be made to the CD's files, so I took the opportunity to
write a program to perform the edits automatically. This program, CDFix,
is now available at http://www.aristeia.com/BookErrata/CDFix.zip
I'm adopting a "Don't Ask, Don't Tell" policy with respect to AW's Legal
Department: I'm not telling them about the program, and I'm hoping they
don't tell me to stop distributing it :-)

I encourage you to give it a try if you'd like to use the CD with IE6. If
it works, great. If not, you can always delete the edited files and fall
back on the originals on the CD. And if you find ways to improve CDFix,
e.g., to make it also edit the CD's files so that they work better with
other browsers, please let me know.

Scott

Upcoming Talks

I've updated my "Upcoming Talks" page with new conference talks in February
and March. In February, I'll be giving a tutorial at the Embedded World
Exhibition & Conference in Nürnberg, Germany. In March, I'll be giving
several talks at the Software Development Conference in Santa Clara,
California. One of those talks (the one on double-checked locking) is
based on new work that Andrei Alexandrescu and I have been doing. For
links to the details on all these talks, consult
http://www.aristeia.com/seminars_frames.html

Also, this is a final reminder that next Monday I'll be giving a full-day
seminar at OGI in Beaverton, Oregon, on making effective use of C++ in
embedded systems. If you're interested in how compilers treat different
language constructs, the ins and outs of avoiding code bloat (especially as
regards templates), how to effectively model memory-mapped IO, or how to
make sure you don't run into trouble by confusing units like miles/hour
with different units like kilometers/second, you might want to consider
attending, because these topics and more are on the docket. You'll find a
link to details on this talk at the same page I mentioned above.

I hope to see you at one or more of these talks. In the meantime,
Happy Holidays :-)

Scott

Upcoming Seminar on using C++ in an Embedded Environment

During the course of the past year, my most popular C++ seminar has been my
new one on making effective use of C++ in an embedded environment. For
whatever reason, I've offered this as an open-enrollment course several
times in Europe, but never as an open-enrollment course in the USA. Until
now. On Monday, December 15, I'll be presenting this seminar in Beaverton,
Oregon, and if you're working with embedded systems and are interested in
how to use C++ in that environment or how to *better* use C++ in that
environment, I encourage you to consider attending.

For details on the seminar, consult the web page at
http://cpd.ogi.edu/courseSpecific.asp?pam=1399. I hope to see you in
December.

Scott

Updated Book Errata Lists

EC++ and MEC++ are up for new printings (the 15th and 17th, respectively,
on the off chance you care), so I took the opportunity to update the errata
lists for both them and ESTL. You'll find the updated errata lists at the
usual locations:

EC++: http://www.aristeia.com/BookErrata/ec++2e-errata_frames.html
MEC++: http://www.aristeia.com/BookErrata/mec++-errata_frames.html
ESTL: http://www.aristeia.com/BookErrata/estl1e-errata_frames.html

Below I've appended the new entries for each list. These are easier to
peruse to see if you care about any of the changes.

I haven't actually made the changes for the new printings yet, but when I
do, I'll update the EC++ and MEC++ errata lists to show the fix dates for
the changes that will appear in the next printings. That should be done by
next week, so check in with the errata lists then if you're interested in
how the new printings will differ from the current ones.

Scott

PS - Interested in a glimpse at new functionality being added to C++'s
standard library? Check out
http://std.dkuug.dk/jtc1/sc22/wg21/docs/library_technical_report.html


****************************************************
* NEW ENTRIES FOR EFFECTIVE C++ *
****************************************************

Errata:

DATE DATE
REPORTED WHO PAGES WHAT FIXED
-------- --- ----- ------------------------------------------------ --------
9/18/03 ss 99 The function returnStudent is dangerously
declared on this page, because it returns a
reference to what could be a temporary object.
For details, consult FAQ 32.08 of C++ Faqs by
Cline, Lomow, and Girou.

8/13/03 mc 222 There is more to the Singleton pattern than I
describe in this Item. In particular, I make no
mention of how to limit instantiation of a
singleton class to one. The technique is
clearly related to Singleton, but as mc notes,
"You can't spell 'singleton' without spelling
'single.'"

Interesting Comments:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- -----------------------------------------------------------
6/17/03 wk 77 There are pathological cases where pass by value is
accomplished by instantiations of "copying constructors"
rather than by the class' copy constructor. For details,
consult the
href="http://groups.google.com/groups?hl=en&lr=lang_en|lang_de&ie=UTF-8&oe=UTF-8\
&threadm=3eba7ee4%40news.microsoft.com&rnum=1&prev=/groups%3Fsourceid%3Dnavclien\
t%26ie%3DUTF-8%26oe%3DUTF-8%26q%3DI%2Bfound%2Bevidence%2Bto%2Byour%2Beducated%2B\
guess%2Bmostly%2Bin%2B12.8%252F8%2B(recursive"
target="_top">comp.lang.c++.moderated thread on the topic.

7/ 1/03 sv 108 The last sentence says you *must* use overloading, but if
you are willing to change the API, you have other choices,
e.g., you could pass a vector of values.

5/19/03 sdm Item 34 Because it's not possible to declare nested classes
without defining the class in which they are nested,
nested classes can lead to unnecessary compilation
dependencies. An alternative design is to unnest the
class and include both classes in the same namespace.
However, this is viable only when the nested class is
public, because namespaces offer no encapsulation.

6/11/03 sf Item 38 A drawback to the advice in this Item is that callers
going through the derived class interface must specify
all parameter values; the default parameter values
apply only via the base class interface. An
alternative design is to respecify the (same) default
value in each derived class, but then if the default is
changed in the base class, all derived classes must be
updated with the new value, too.

8/13/03 mc Item 43 Slightly edited, mc writes: "You are not completely
fair in this Item. The trick with auxillary classes is
needed in order to allow overloading of any
functionalities involved in the name clash, but the
clumsiness and the lack of virtual behavior are not
valid arguments. Explicit qualification is clumsy, but
so is explicit upcasting of pointers (it takes more
than one line, compare upper page 196 with middle page
197). So clumsiness is not the argument here. Moreover,
calling pls->draw(); on page 197 would still be an
error just as on page 196, so don't bad-mouth the first
approach on that account. Reversely, applying the
pointer upcast trick on page 196 instead would conserve
the virtual behavior. So the only argument left is that
only one of the methods can be overloaded, the other
will be lost (this is reason enough to apply the
technique you offer). In the end, there's no error in
your text, but I think that the code and the
formulation makes the reader focus on the wrong aspects
of the problem."




****************************************************
* NEW ENTRIES FOR MORE EFFECTIVE C++ *
****************************************************

Errata:

DATE DATE
REPORTED WHO PAGES WHAT FIXED
-------- --- ----- ------------------------------------------------ --------
! 4/30/03 mh 209 RCIPtr::init should test oldValue against NULL
before dereferencing it.

6/ 8/03 sdm 265 Bad line break: AbstractA-nimal ==> Abstract-
Animal

! 6/ 7/03 mh 266 2nd and 3rd paras discuss the assumption that
base classes have no data. The correct assumption
is that *derived* classes have no data.


Interesting Comments:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- -----------------------------------------------------------
6/ 3/03 sxb 202 The bug for these pages reported by ct on 9/16/98 is
206 incorrect, because when RCPTR::operator= is called with
a raw pointer as an argument (e.g., p->next), a
temporary RCPtr will be created from the raw pointer,
hence the reference count won't go to 0 when
removeReference is called. (I'll keep the code in the
book as is, because it behaves correctly, and I don't
want to mess with code in the book any more often than
I have to.)




****************************************************
* NEW ENTRIES FOR EFFECTIVE STL *
****************************************************

Errata:

DATE DATE
REPORTED WHO PAGES WHAT FIXED
-------- --- ----- ------------------------------------------------ --------
8/ 1/03 lfr 51 In 2nd-to-last para, "unsigned integral value"
==> "unsigned integral type"

5/19/03 drm 168 My claim that "Declaring operator() const in
predicate classes is necessary for correct
behavior, but it's not sufficient" is too strong.
E.g., it would be safe to modify data members that
don't affect the outcome of the predicate. Reword.

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- -----------------------------------------------------------
9/30/03 mp 188 In the operator() implementation at the top of the page, it
might be preferable to write the test this way,
return lowVal < val && val < highVal;
so that val is both numerically and *physically* between
the bottom of the range on the left and the top of the
range on the right. mp finds this clearer and also nearer
to the mathematical notation "lowVal < val < highVal." (mp
attributes this idea to either Steve Maguire's "Writing
Solid Code" or "Debugging the Development Process."

5/16/03 drm Item 26 "The advice of this Item seems kind of strong. Counting
in my last bit of code: 49 const_iterators, 3 iterators, 0
problems (so far). I think a better slant to the Item
might be: be careful, const_iterators have certain
restrictions. I don't see that those restrictions
necessarily lead to the recommendation to prefer iterator."

Upcoming Talk at OGI next Thursday (Oct. 16)

The Oregon IEEE Computer and Communications societies asked me to be their
October speaker, so next Thursday (October 16) I'll be giving a talk on
"The Keyhole Problem" at OGI in Beaverton. You can find all the details at
http://www.ieee-or.org/events/EventDetails.asp?eventid=187 and
http://cpd.ogi.edu/class.asp?n=04-IEEE-1016

I hope to see you at OGI on Thursday evening!

Scott

"Effective XML" is now out

The second book in my Effective Software Development Series has just come
out, Elliotte Rusty Harold's "Effective XML." Many books have been
published that mimic the format of my "Effective" books, but this is the
first one to come out where I offered advice to the author on how to better
make the book "work." Rusty is an established author, so he knows how to
write, and his knowledge of XML is outstanding. I think you'll find that
"Effective XML" offers exactly what the subtitle promises: "50 Specific
Ways to Improve Your XML."

You can read more about the book at
http://www.awprofessional.com/catalog/product.asp?product_id={8E524FFF-F58B-4C5A\
-BBC8-6E02DC159996}&session_id={0994EFB6-20AC-468B-8C72-2603CCFD9EBF}

Scott

"The Keyhole Problem" and other books

For over a year now, I've been interested in what I call "keyholes" in
software: gratuitous restrictions on what can been seen or expressed.
Keyholes arise in software written in any language and for any domain; they
exist in both web-based and native applications. As a result, this
research is separate from my work on C++ programming.

I've decided that my next book will be about keyholes. In particular,
about why they are harmful and how programmers can avoid them. I've set up
a web site devoted to the project, "The Keyhole Problem." I'll post
chapter drafts there for people to offer feedback on. In addition,
Artima.com has graciously offered to host a mailing list devoted to
discussion of the book material in particular and keyholes in general.

If you're interested in learning more about this project and/or signing up
for the Keyholes Mailing List, please visit the project's web page,
http://www.aristeia.com/TKP/ There you'll find a draft paper from last
summer that gives a good overview of what I mean by keyholes, and you'll
also find a draft book chapter. If you're interested in reading the
chapter, I suggest you wait a few days, because I plan to post a revised
version of that chapter by the end of the week. (When the revised chapter
is available, I'll post to the Keyholes mailing list, not to this list.)

Speaking of writing books, you may recall that in March, I announced that I
was going to work on a new edition of Effective C++. That's happening,
too. When there's more to say on that front, members of my mailing list
will be the first to know, but for now, I'll just say that that project is
proceeding concurrently with my keyholes research.

Also on the writing front, the next book in my Effective Software
Development Series is nearing publication: Elliotte Rusty Harold's
"Effective XML." It's organized like my "Effective C++," and I think that
Rusty does a great job of applying that format to XML development. The
book is slated for publication in September. When it comes out, I'll let
you know. In the meantime, you can get a flavor for the book at
http://www.ibiblio.org/xml/books/effectivexml/

Scott

First ESDS Book: "Code Reading"

A little over a year ago, I announced that I was working with Addison
Wesley on a new book series, the Effective Software Development Series.
Now I'm pleased to announce that the first book in the series has come out.
It's "Code Reading" by Diomidis Spinellis, and I think it's really good.
(Duh. It wouldn't be in the series if I didn't.)

The subtitle of the book is "The Open Source Perspective," and at one
point, I remarked to Diomidis that the most accurate title for the book
would actually be something like "Everything you need to know about
examining open source software projects."

Fundamentally, the book is about how to go about making enough sense of
unfamiliar software systems so that you can modify or extend them. All of
the examples are from Open Source projects, and the book ships with a CD
containing the full source of everything the book mentions. That's some 7
millions lines of code on the CD.

You can find more information about Code Reading at
http://www.awprofessional.com/catalog/product.asp?product_id={DE5EA6BB-1743-406B\
-A680-D1B335BA7EA2}

I hope you like this opening salvo in the Effective Software Development
Series.

Scott

Talks in Germany September 22-26

I'll be in Germany giving talks on various aspects of C++ during the week of
September 22-26. For details (topics, locations, etc.), please consult my
Seminars page, http://www.aristeia.com/seminars_frames.html. All the talks will
be in English, but during breaks, etc., es ist moeglich, dass ich versuchen
werde, ein Bisschen auf Deutsch zu reden :-)

I hope to see you in Germany in September.

Scott

Updated EC++ Errata; 11/02 CUJ Article now Available

Two things:
- Effective C++ Errata Updated
- My November 2002 CUJ Article is now Online

I just updated the errata list for Effective C++. As always, it's at
http://www.aristeia.com/BookErrata/ec++2e-errata_frames.html A detailed
list of changes (in the usual pseudo-HTML I use internally) is listed
below. In conjunction with the recent updates I made to the errata pages
for ESTL and MEC++, I'm pleased to report that all the problems I know
about in my books are now listed online.

Also, you can now find a PDF copy of my November 2002 CUJ article, "Class
Template, Member Template -- or Both?" at
http://www.aristeia.com/Papers/CUJ_Nov_2002.pdf

Enjoy!

Scott


[New EC++ Errata Entries]

DATE DATE
REPORTED WHO PAGES WHAT FIXED
-------- --- ----- ------------------------------------------------ --------
10/12/02 bj 12 Clarify whether the "ISO/ANSI sanctified version
of C" I refer to in the book is now C99, not C89.

4/10/03 wk 77 The final bullet point on the page is misleading.
C++ imposes constraints on how copy constructors
behave, so rather than writing that a copy
constructor defines what it means to pass by
value, I should say that it defines how an
object is passed by value.

10/20/02 kk 125 In final sentence of 2nd-to-last paragraph,
clarify that callers must use the array form of
delete.

9/26/02 mh 127 It would be better if someFamousAuthor returned
a const String instead of just a String. This
would be consistent with the advice of Item 21.

10/12/02 bj 135 In first para, note that the "C philosophy that
variables should be defined at the beginning of
a block" is for C prior to C99.

! 10/12/02 bj Item 41 The first design problem includes the ability to
create "stacks of stacks of strings," but the
given solution has a private copy constructor,
making it impossible to create a Stack of Stacks.


Interesting Comments:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- -----------------------------------------------------------
2/17/03 dyx Items "Our programming guidelines now recommend implementing
16-17 assignment operators like this:

T const& T::operator=( T other )
{
swap( other ); // non-throwing operation
return *this;
}

My reply:

This is fine (except for the const return type :-}), as
long as you make clear that this approach may be
needlessly expensive. For example, if all your data
members are of built in types, their assignments can't
throw, so doing swaps instead of assignments just burns
cycles needlessly. For large objects, you're talking
about duplicating an object's contents on the heap in
order to be able to perform the non-throwing swap.
There's nothing wrong with that, but my experience has
been that people advocating this approach to implementing
operator= often overlook the cost that it incurs. It's
exception safe, but it's often not cheap.

12/30/02 ma Item 19 It's true that virtual functions must be members, but one
can get virtual-acting behavior by having a non-virtual
function (possibly a non-member) call a virtual function.
This can be especially useful for functions like operator<<,
which must be non-members but can be made to act virtual by
internally calling a virtual function, e.g., one named
"print" or "write".

2/17/03 dys Item 19 Regarding the last bullet on page 88, dys writes:

The same rule should be used for other operators that
require a different class as a left-hand operand. For
example, CORBA uses "Any <<= Type", and for all classes
besides Any, operator<<=(T) is a non-member. I propose
the following change to your algorithm. Instead of

else if (f is operator>> or operator<<)

write

else if (f is an operator and needs another class as
its left-hand operand)

6/15/02 sdm Item 33 Randy Meyers (no relation) has a nice article on inlining
in C99, including an explanation of how the C99 rules differ
from those in C++, in the July 2002 issue of the
C/C++
Users Journal.

10/13/02 ya Item 36 ya writes: "Nonvirtual functions may call other functions
which are virtual. In that case, derived classes are indeed
presented with mandadory implementation, but only in the
highest, close-to-the-surface level. By overriding virtual
functions, the overall behavior of the nonvirtual function
can change in derived classes. Such usage of nonvirtuals is
very useful and is the basis for the 'template method'
design pattern."
This is true, but it's important to note that the
externally observable behavior of any function is defined by
its specification (i.e., it's interface), not by its
implementation. A nonvirtual implemented using template
method may behave differently for different derived classes,
but its behavior is still bounded by its specification.
Callers don't care whether the function is virtual or
nonvirtual. All they care about is that the function they
call exhibits the behavior its specification promises.
For implementers of derived classes, it's a different
story. They care very much about whether a base class
function is virtual or nonvirtual, because that affects what
they are allowed to vary. In Item 36, my remarks are
focused on the relationship between authors of base and
derived classes, not on the relationship between authors of
a class and clients of that class.

ESTL and MEC++ Errata Pages Updated

I just updated the errata pages for Effective STL (ESTL) and for More
Effective C++ (MEC++). Here are links:

ESTL: http://www.aristeia.com/BookErrata/estl1e-errata.html
MEC++: http://www.aristeia.com/BookErrata/mec++-errata_frames.html

New entries for both books are below.

I hope to update the errata page for Effective C++ by the end of this
month. I'll let you know when I do.

Scott


----------------------------------------------------------------------
NEW ENTRIES FOR ESTL
----------------------------------------------------------------------
Bugs:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- ------------------------------------------------
2/ 1/03 fr 90 Missing colon at end of page. (The missing colon is
actually deliberate, but replacing "try" with "try
this:" will probably be clearer, so that's the change
I'll make.)

1/31/03 fr 91 Include an xref to Item 7 near the definition for
DereferenceLess for readers who are confused about
why DereferenceLess is a non-template struct
containing a templatized operator().

4/18/03 lz 157 In 1st line, "many elements" ==> "many elements
with a particular value"

2/26/03 shh 166 In the third bullet point on the page, "returns
true or false" ==> "returns true or false (or
something that can be implicitly converted to
true or false)."

2/26/03 shh 211 In line 5 of 4th prose para, "do this is with"
==> "do this with"


Interesting Comments:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- -----------------------------------------------------------
7/16/01 sdm Item 4 If you're interested in the technical and standardization
issues surrounding list::size, check out the July 2001
href="http://groups.google.com/groups?hl=en&lr=lang_en|lang_de&ie=UTF-8&oe=UTF-8\
&threadm=uZj47.33018%24WS4.5267300%40news6-win.server.ntlworld.com&rnum=1&prev=/\
groups%3Fhl%3Den%26lr%3Dlang_en%257Clang_de%26ie%3DUTF-8%26oe%3DUTF-8%26selm%3Du\
Zj47.33018%2524WS4.5267300%2540news6-win.server.ntlworld.com"
target="_blank">comp.std.c++
thread discussing the matter.

12/ 2/02 jr 46 The code at the bottom of this page has two shortcomings:
(1) though it works when iterating over an entire container,
it's incorrect if given an arbitrary end iterator, because
the call to erase will invalidate the end iterator; and (2)
because each call to erase shifts all succeeding elements
down by one, the linear-looking loop really runs in
quadratic time.

Here's code that addresses both problems, where endIt is the
arbitrary end iterator to be used and, for consistency,
beginIt is an arbitrary begin iterator to be used:

vector::iterator i = beginIt;
while(i!=endIt && !badValue(*i)) ++i;
vector::iterator j = i;

while(i!=end){
if(badValue(*i)) {
logFile<<"Erasing "<<*i<<'\n';
} else {
*j=*i;
++j;
}
++i;
}

c.erase(j, end);

Note that the second while loop is essentially a variant of
remove_if (see Item 32).

jr reports that in simple tests he performed comparing the
performance of this code with that on the bottom of page 46,
he saw speed improvements of 2-3 orders of magnitude.

2/22/03 fr Item 34 When using an algorithm expecting a sorted range (e.g.,
includes, set_union, etc.) on a standard associative
container (especially a map or multimap), it's important to
pass the correct comparison function. The easiest way to do
this is to pass the result of the value_comp member
function:

typedef multimap map1, map2;
...
bool subMultiset = includes(map1.begin(), map1.end(),
map2.begin(), map2.end(),
map1.value_comp());

This works for sets and multisets, too, because for those
types, value_comp returns the same thing as key_comp.
However, as noted in Item 44, for operations like
lower_bound, etc., it's generally better to use member
functions instead of algorithms when both are applicable.

2/20/03 fr 156 Because postincrement is less efficient than
preincrement, the if statement may be better
implemented as follows:

if (p(*begin)) {
*destBegin = *begin;
++destBegin;
}

2/26/03 shh 159 In order to make sure that the initial summary value
passed to accumulate is of the appropriate type, shh
suggests using this form:

Y sum = accumulate (
begin, // acts like a T*
end, // acts like a T*
static_cast(initValue) // initValue need not be of type
Y
);



----------------------------------------------------------------------
NEW ENTRIES FOR MEC++
----------------------------------------------------------------------

Bugs:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- ------------------------------------------------
8/14/02 sdm 66-67 The inheritance-based conversions described on
these pages apply only to public inheritance.
For non-public inheritance, things get a bit more
complicated. For details, including a rationale
for the behavior, consult the July 2001 CUJ
column by Jim Hyslop and Herb Sutter,
target="_blank">"Baseless Exceptions."

1/ 6/03 ais 67 In the examples near the top of the page, it
would be good to note that catch-by-value can
lead to the slicing problem, a topic that is
discussed on page 70 in Item 13.

12/ 6/02 ddg 99 In last sentence "When countChar returns," ==>
"When the statement containing the call to
countChar finishes executing,"

The Next Edition of Effective C++

I'm beginning to work on the third edition of Effective C++. The second
edition was a fairy conservative sprucing up of the original, but for the
third edition, I expect to make more extensive changes.

I constrained the second edition to follow the Item breakdown of the first
edition fairly closely, but this time I plan to start with a reasonably
clean slate and ask myself, "What are the 50 most useful pieces of advice
for professional developers NOW?" Without a doubt, some of the current
Items will make the cut, but it's time to include new topics, almost
certainly including design and implementation in the presence of templates;
dealing with issues related to exception safety; the impact of threading,
etc. At the same time, I want to continue to avoid undue overlap among my
three books, so there's little chance I'll devote significant space to
topics I already treat in More Effective C++ or Effective STL.

I'll also maintain what I consider to be fundamental strengths of the book:
Items that are short, specific, to the point, and that take both the
Standard and real compilers/libraries into account.

I have plenty of ideas on what EC++/3E should contain, but I'm hoping
you'll offer suggestions, too. What Items or parts of Items are no longer
needed? What new topics should be addressed? What did I do right that I
should avoid breaking? What needs fixing? Are there any things I did or
didn't do in More Effective C++ or in Effective STL that I should be sure
to copy or be sure NOT to copy? Are there ideas from other books I should
steal? In short, how can I make EC++/3E the best EC++ ever?

I hope to receive a lot of email in response to this message, so please
don't be offended if all you get is a pro forma reply. I have only so much
time and energy, and I hope we agree that it's more important for me to
work on the book than to send everybody a personalized reply to each
suggestion. Actually, if you squint just right, you can think of the
revised book as a personalized reply to each of you, because I'll take all
your feedback into account as I work on it.

If would be most convenient for me if you'd send all suggestions to
EC++3E@....

Thanks in advance for all the help I know you'll offer.

Scott

New Seminars: Patterns & PBD; C++ in Embedded Systems

I've recently developed two new C++ seminars and added descriptions of them
to my web site. Currently, they are available only for on-site
presentations, though it would not surprise me if I end up presenting one
or both at open-enrollment seminars in Germany in September.

Here are brief descriptions. Please consult their respective web pages for
details.

PATTERNS AND POLICY-BASED DESIGN. I've been getting a lot of inquiries
about design patterns recently, but it seems that few people know that
C++ is uniquely capable of generating flexible and efficient pattern
implementations. This seminar is my way of covering the patterns
material people want to know along with the C++ design techniques they
need to know in order to really exploit patterns in C++. As far as I
know, there's no other course like this, and I'm very excited about it.
I taught it for the first time last week, and it was a big hit.
Full Description: http://www.aristeia.com/patterns-and-pbd_frames.html

EFFECTIVE C++ IN AN EMBEDDED ENVIRONMENT. I mentioned the imminent
arrival of this seminar in a mailing last September, and I'm pleased to
say that it's now fully here. I'm even more pleased to report that the
embedded programmers who've attended the seminar have found the material
to be well suited to the concerns they confront. Short on bytes, cycles,
or a conforming C++ compiler, yet still want to take advantage of C++'s
modeling power, flexibility, efficiency or availability of outside tools?
Ask me how!
Full Description: http://www.aristeia.com/c++-in-embedded_frames.html

I also have a bunch of new talks I need to add to my Short Courses page
(http://www.aristeia.com/short-courses_frames.html). When I get them
added, I'll let you know.

Scott

Impending Effective STL Errata List Update

Later today, I'll update the online errata list for Effective STL. As a
mailing list exclusive, here are the changes I'll be making. By the time
these make it to the web site, they may have been massaged somewhat, but
this is what I'll be working from.

Please note in particular the entry for page 91, because it seems to have
been confusing a lot of people recently.

Thanks,

Scott


DATE DATE
REPORTED WHO PAGES WHAT FIXED
-------- --- ----- ------------------------------------------------ --------
11/29/02 gm 44 Regarding the paragraph after the first code
example, the call to erase can't take
logarithmic time in general, because a multi
container might consist entirely of elements
with the value to be removed. gm notes that
"The correct statement, guaranteed true by the
Standard, is: it takes time O(log(n)+k) where n
is the size of the container and k is the number
of items to be erased."

9/ 4/02 ga 46 In the for loop in the first code example,
"AssocContainer" should be entirely in italics.

11/ 6/02 wb 57 In the second code example, the
SpecificHeapAllocator template is missing the
word "class" at the beginning of the template
definition.

7/13/02 ckl 91 In first code example, ssp's type should be
declared to be set.

1/12/03 as 108 Regarding the second-to-last paragraph on the
page, as points out that "only the assigment
operator is 'unnecessary', a temporary Widget is
going to be constructed anyhow, so you have in
balance a (useless) construction/destruction
plus an assigment OVER a (useful)
construction/destruction.'

9/ 4/02 ga 141 At end of second prose paragraph, "...you should
probably be calling partition..." ==> "...you
should probably be calling partition or
stable_partition..."

9/25/02 pn 171-172 Some examples here fail to explicitly state that
inheritance from e.g., std::binary_function is
public. This is inconsistent with what I do
elsewhere in the book, e.g., on pp. 178-179. I
should check all the examples to make sure I'm
consistent.

11/ 2/02 cb 253 In column 1, the entry for istream_iterators
mentioning operator<< should mention operator>>.

11/ 2/02 cb 255 In column 2, the entry for operator<< should
mention operator>>.

Interesting Comments:

DATE
REPORTED WHO PAGES WHAT
-------- --- ----- -----------------------------------------------------------
7/15/01 sdm Item 1 For another discussion of the pros and cons of different
containers, check out Andrew Koenig's and Barbara Moo's
column, "Which Container Should I Use?," in the August 2001
C/C++ Users Journal

8/26/02 sdm Item 7 Several people have written to ask about why
DeleteObject::operator() takes a pointer to const, even
thought it's going to delete the pointer. The answer is
that if I did not, it wouldn't be possible to use
DeleteObject on containers such as vector.
There has been much debate in the C++ community over
whether deleting pointers-to-const should be legal, but it
is and it can be useful, so it's important to me that
DeleteObject support it.

8/18/02 apl 69 apl argues that credit for notion that "God is in the
details" should go to Mies Van Der Rohe, not Einstein. He
points to href="http://www.theatlantic.com/issues/2000/01/001wordcourt.htm"
target="_blank">a column in The Atlantic online to bolser his
argument.

9/ 4/02 ga 117 Five lines from the bottom, "const" should be
capitalized, because it is the first word in a sentence.

8/27/02 jcj Item 28 When using the range form of erase, there is no need to
adjust a reverse_iterator's base if it marks the end of the
erase range. Consider:

vector v;
... // Put 1-5 in v

// Remove 2-4 from vector in example [1, 2, 3, 4, 5]
vector::iterator ifirst = // ifirst points
find(v.begin(), v.end(), 2); // to the 2
vector::reverse_iterator rilast = // rilast points
find(v.rbegin(), v.rend(), 4); // to the 4
v.erase(ifirst, rilast.base()); // erase 2-4,
// inclusive

9/ 4/02 ga 133 Writes ga, "Another variation: reserve, move away/copy the
elements that would be moved one by one in one chunk and
then transform on the gap that we are left with." I
believe that in some cases, this will be more efficient
than resize/copy.

9/ 4/02 ga 161 for_each is also faster.



I'm also going to update some of the "Interesting comments" about Item 37,
but those updates are not shown here, sorry.

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.

Interview with me available at artima.com

In August, I was interviewed by Bill Venners. Bill's a Java guy, but he's
a *nice* Java guy :-) He's decided to post the interview in six weekly
installments, starting today. You can find the first installment at
http://www.artima.com/intv/abcs.html. The primary topic is multiple
inheritance.

Enjoy,

Scott

Benefit Talk near Portland, OR, December 17

On Tuesday, December 17, I'll be joining two other noted consultants in the
Portland area, Karl Wiegers and Rebecca Wirfs-Brock, in a software
engineering benefit for Norm Kerth. You can read all about the event at
http://cpd.ogi.edu/class.asp?n=03-CPD-1217

The cause is a very good one, and the talks promise to be top-notch, so I
hope you'll attend. Here's a description of the topic I'll be addressing:

NOTHING WORKS AND NOBODY CARES

Every industry falls short of the mark from time to time, but in the PC
industry, horrific customer experiences are endemic. At least that's been
Scott's experience. Marketing materials are misleading, documentation
lies, products don't work, and customer support is variously incompetent,
condescending, surly, or nonexistent. In other words, nothing works and
nobody cares.

In this talk, Scott summarizes some of his experiences with products from
several major hardware and/or software vendors, demonstrating how each
often conveys a message to prospective and current customers that
satisfaction, far from being a goal, isn't even on the radar screen. He
also offers practical suggestions for improving the situation, starting
with a radical idea: when a customer complains that your product fails to
live up to his or her expectations, (1) say you're sorry and (2) mean it.

Ambitious attendees may wish to perform a simple experiment before the
talk: choose two or three products you use regularly, then, using the
product documentation, determine how users are supposed to report bugs.

Scott

New CUJ Article; TCS3; gcc 3.2 for Windows

Three things:
- New CUJ article by me.
- Status Report on THE C++ Seminar later this month.
- EZ gcc 3.2 for Windows (thanks to Leor Zolman).

NEW CUJ ARTICLE
---------------
The current CUJ (November 2002) has an article by me on how combining class
templates, member functions templates, and total specialization of a class
template can lead to STL-compatible function objects that are a lot easier
to use than the ones in the STL. Unless you saw me present this material
at THE C++ Seminar in March or at Software Development in April, this will
probably be new to you. Personally, I think it's kind of neat. For the
time being, the article will be available only in the print magazine, but I
expect to make an electronic copy available sometime in December.

I don't know why, but I can't help but point out that with this
publication, I have published new material every year since 1989. That's
nothing compared to many columnists, some of whom have produced new
material every week or month for decades, but I've done the columnist
thing, and there's a qualitative difference between writing to meet a
deadline (as columnists must do) and writing only when you think you have
something interesting to say. If you'd like to see a summary of when I've
thought that, mosey on over to http://www.aristeia.com/publications.html.

THE C++ SEMINAR (TCS3)
----------------------
Andrei, Herb, Steve, Dan, and I are putting the finishing touches on THE
C++ Seminar, to be held at the end of this month in Vancouver, Washington
(near Portland, Oregon). More than one speaker took advantage of the
opportunity to change talk topics until literally the day we had to commit
the notes to CD, so I encourage you to check out the as-final-as-it-gets
schedule at http://www.thecppseminar.com/03/index.htm.

Regarding TCS3, I'm going to tell you two things I probably shouldn't.
First, I can't resist quoting a message -- without permission -- I recently
got from Andrei about work he's been doing and which he plans to present:

Scott, I have dynamite new material. Blood will shed on the streets!
Heads will roll!

Coding standards will change forever. Here's an example: I have strong
proof that the following classic implementations:

X& X::operator=(const X& rhs)
{
X copy(rhs);
copy.swap(*this);
return *this;
}

and

const X operator+(const X& lhs, const X& rhs)
{
return X(lhs) += rhs;
}

are about the WORST and UNRECOMMENDED signatures and implementations.

I now have a set of COMPLETELY NEW RULES on how to implement such
functions. The reward? ZERO UNNECESSARY TEMPORARY OBJECTS CREATED.

I don't know about you, but I want to be there when the blood starts
flowing, the heads start rolling, and the coding standards start changing.

The other thing I probably shouldn't tell you is that as things stand now,
we probably won't sell out. (Attendance is limited to 95.) From a
business point of view, that's bad news for us, but if you're an attendee,
it's great news. It means less contention if you want to sit and talk with
each of us, ask us questions, bounce design ideas off us, etc. I can't
make any guarantees, because we might end up selling out after all, but
currently it looks like TCS3 will honestly be the best opportunity there
has ever been to spend relatively uncrowded time with the five of us to
talk serious C++.

The TCS Home Page is at http://www.thecppseminar.com/index.htm.

GCC 3.2 FOR WINDOWS WITHOUT TEARS
---------------------------------
Speaking of quoting mail without permission, just today I got mail from
Leor Zolman describing how to get gcc 3.2 running under Windows without
Cygwin. This is important, because the current Mingw32 distribution
includes only gcc 2.95, yet gcc 3.2 has significant additional
capabilities. Until Leor figured out how to do it, getting gcc 3 installed
on non Cygwin Windows machine was a black art. But Leor wrote me:

I've updated my cheat sheet with the 3.2 information:

http://www.bdsoft.com/dist/MinGW-gcc3-install.txt

It also talks about how to code for multi-platform extended container
support with the right conditional compilation symbols.

HUGE DISCLAIMER: I haven't tested Leor's information myself, primarily
because I'm staring down the barrel of a bevy of very unforgiving
deadlines right now. But if the past is any indication, if you do what
Leor says, things will go swimmingly for you. If they don't, please TELL
LEOR, not me!

Scott
--------------------------------------
All new! THE C++ Seminar: Oct. 28-30 in Vancouver, WA.
http://www.thecppseminar.com/

TCS3 Reminder; New Talk Topic; Oct-Nov Talks Schedule

This issue's news:
- TCS3 early-bird registration deadline is this Sunday!
- New talk on C++ and Embedded Systems.
- Talks in England and Ireland in October.
- Talks in Germany in November.
- Talks in Boston in November.

TCS3 UPDATE
-------------------------------------
This October's "THE C++ Seminar" is filling up nicely, and I wanted to
remind you that the early bird registration deadline for this event is
Sunday. Unless you'll be attending as part of a group of four or more from
one company, you'll save $455 if you register by Sunday. (The official
rule is that you have to *pay* by Sunday, but the registrar is a friend of
mine, so I think I can get him to bend that rule by a few days as long as
you are registered by Sunday.) You can register at
http://www.thecppseminar.com/03/registration.htm.

BTW, I recently got inspired, so I changed my talk agenda a bit. You'll
find details on all the talks at the TCS3 page with the prospective
schedule (http://www.thecppseminar.com/03/index.htm), but here are the
topics I plan to address:
- False friends in C++
- Rvalues in C++
- Approximating Named Parameters in C++
Andrei seems to think that the false friends talk is a good one :-)


NEW TALK ON C++ IN EMBEDDED SYSTEMS
-----------------------------------
Software developers for embedded systems are increasingly interested in
using C++, so I'm putting together a new talk on making effective use of
C++ in embedded systems. This talk isn't listed at my web site yet,
because it's still in beta, but I'll be giving it in England, Ireland, and
Germany this autumn (see below). You can get an overview of the talk's
contents at http://www.programmingresearch.com/pressroom/scottmeyers.htm.
If you're involved in embedded development and think you might like to have
me come present the talk at your company, let me know.


TALKS IN ENGLAND AND IRELAND IN OCTOBER
---------------------------------------
In conjunction with Programming Research (http://www.programmingresearch.com/),
I'll be giving my new talk on C++ in embedded systems (see above) in
London, Manchester, Edinburgh, and Dublin on October 14-17, respectively.
You'll find links to each talk at my seminars page,
http://www.aristeia.com/seminars.html.


TALKS IN ULM (GERMANY) IN NOVEMBER
----------------------------------
I'll be working with QA Systems (http://www.qa-systems.com/) again this
year for a full week of talks (November 4-8 in Ulm): two days on class
design and efficiency, one day on C++ in embedded systems (see above), and
two days on effective STL programming. You'll find links to the details
for all these talks at my seminars page,
http://www.aristeia.com/seminars.html. Ich hoffe, Sie in Ulm zu sehen!


TALKS IN BOSTON IN NOVEMBER
---------------------------
I'll be speaking at the Software Development conference in Boston on
November 20-22. Two of the talks will be on C++, one on library design,
one on static initialization and policy based design. The other two talks
are on language-independent issues I consider important to all software
developers. One is on my current focus of research (and probably the topic
of my next book), "The Keyhole Problem." The other is on general
approaches to improving software quality. You'll find details by following
the links to these talks at my seminars page,
http://www.aristeia.com/seminars.html.


Between London, Manchester, Edinburgh, Dublin, Portland, Ulm, and Boston, I
hope to see you *somewhere* in October or November to discuss embedded
systems programming, false friends, rvalues, approximations to named
parameters, class design, efficiency, use of the STL, policy-based design,
general approaches to usability and other aspects of software quality, or
anything else that strikes your fancy :-)

Scott
--------------------------------------
All new! THE C++ Seminar: Oct. 28-30 in Vancouver, WA.
http://www.thecppseminar.com/

List policy change; TCS3 Schedule; Sep. 9 Talk in Bellevue, WA

Here's the docket:
- Modification to mailing list content policy
- TCS3 schedule now available
- Talk September 9 at WSA Developer SIG


Modification of Content Policy for this Mailing List
----------------------------------------------------
I'm fortunate that a lot of very smart people are on this mailing list.
Unsurprisingly, you know things that I don't know. As my professional
interests broaden beyond pure C++ programming, I increasingly find myself
with questions I can't answer and that my traditional contacts can't
answer, either. In many cases, I suspect that people on this mailing list
can answer them with ease. As a result, I've added the following paragraph
to the Contents and Policies section of the page that describes this
mailing list (http://www.aristeia.com/MailingList/index_frames.html):

Scott issues Requests for Assistance (RFAs) when he is looking for
specialized technical information and believes that one or more members
of the mailing list are likely to be able to help him find it. RFAs are
never mixed with announcements, and the subject of such messages always
begins with "RFA". Subscribers who wish to see announcements only should
configure their mail client(s) to filter out RFAs.

For example, as part of the research for my recent work on "Keyholes" (see
below), I'll need to get some practical information about how certain
changes in schema field types affect the size and performance of commercial
database systems, especially systems used by web servers. I expect a
question on that topic to be my first RFA. If you're a database person, I
hope you'll be willing to help me out.


TCS3 Schedule Now Available
---------------------------
Herb, Andrei, Dan, Steve, and I have put together a draft schedule of what
we expect to talk about at the October THE C++ Seminar. Everything is
brand spanking new, meaning we're all presenting material that we've never
published or presented publicly before. In addition, we've tinkered with
the seminar format a bit to allow more talks covering more topics, so this
TCS will likely cover more aspects of C++ than either of its predecessors.
Interestingly, I'm giving four talks this time instead of my customary two,
so this will be an especially good chance to, well, to see me drone on
twice as often as usual.

Descriptions of all the TCS3 talks and panels are available at
http://www.thecppseminar.com/03/index.htm#schedule, but here are my talk
topics. (They don't all match the official talk titles, because we often
try to choose cute titles, sometimes at the expense of clarity. The
following topic listing is designed to be clear, not cute.)
- Rvalues in C++
- Conveniently displaying the contents of STL containers
- False Friends in C++
- Using Smart Pointers with Incomplete Types
I don't mean to brag, but I think the rvalue talk will be really good. In
my experience, the differences between rvalues in C++ and their
counterparts in C lead to lots of confusion, and I'm hoping that this talk
will be able to clear things up.

BTW, please remember that the TCS3 deadline for early bird discounted
registration is September 15.


Talk September 9 for WSA Developer SIG in Bellevue, Washington
--------------------------------------------------------------
My most recent work has not been in C++. Instead, it's been on trying to
identify general "things" that lead to poor software quality. I'm
currently focusing on what I call the Keyhole Problem, and this talk
explains what that is, why it's important to everybody who does software
development, and practical approaches to solving it. Here's the talk
description I submitted to WSA:

THE KEYHOLE PROBLEM

Using a computer is an experience fraught with frustration and irritation,
and there's no good reason for it. Many of the most annoying aspects of
modern software systems stem from a single underlying problem: it's a big,
wide, wonderful world out there, but your computer refuses to let you see
more than a tiny bit at a time. It's like trying to see a room through a
keyhole, hence Meyers' name for the problem: The Keyhole Problem.

Keyholes are everywhere. A fixed-size window is a keyhole. A web input
form accepting a limited amount of text is a keyhole. A restriction on the
characters that can be used in a password is a keyhole. Using a signed
integer for a value that can never be negative is a keyhole. Most software
systems contains dozens of keyholes. All keyholes are harmful. Most are
easy to eliminate.

In this talk, Meyers describes the keyhole problem, shows dozens of
manifestations you encounter (and impose on the people who use your
software) every day, divides keyholes into several categories, and
explains how you can improve your software by eliminating keyholes
*without doing a lot of extra work*.

If you are involved in software development in any way, you need to know
about keyholes. They affect user interfaces, web site design, database
schemas, even the choice of variable types in programs. They are
relevant to software written in every language, running on every
platform, targeted at every domain, and employed by every type of user.
Come to this talk to see software systems through new eyes, eyes that
reveal not only how awful things are, but just how easy it would be to
make them a whole lot better.

The WSA Developers SIG web site is
http://www.wsa.org/events/sig/detail.asp?sigID=28, and I assume that
they'll post details on the when/where of the talk in the next few days.
If you'll be in the Bellevue area, I hope to see you at the talk. I expect
to cause a fair amount of controversy.

BTW, this talk is essentally the same as my keynote address at Software
Development in San Jose in April, so if you saw that talk, you won't see
too much in this one that's new. There is a new keyhole type I'll be
introducing, however...

Scott
--------------------------------------
All new! THE C++ Seminar: Oct. 28-30 in Vancouver, WA.
http://www.thecppseminar.com/

TCS3 Registration is Now Open!

Andrei Alexandrescu, Herb Sutter, Steve Dewhurst, Dan Saks, and I will be
hosting an all-new incarnation of THE C++ Seminar (TCS) on October 28-30 in
Vancouver, Washington (just across the river from Portland, Oregon). If
you're not familiar with "THE C++ Seminar", you can read about the idea
behind it at http://groups.yahoo.com/group/scott_meyers/message/17 and can
get detailed information about it at http://www.thecppseminar.com/.

Our first TCS sold out at about 85 people, so for TCS2, we reserved more
space and accepted a lot more people. Afterwards, we decided that one of
the things we liked best about TCS1 was the intimate feeling and the chance
to spend time chatting with attendees, so for TCS3, we're limiting
enrollment to 95. More than ever, we encourage attendees to track us down
at TCS and talk/argue/brainstorm with us about interesting problems. We
wouldn't be doing this if we didn't thrive on that kind of thing!

Technically, my claim above of "all-new" is not quite true, because
although Andrei, Herb, Steve, and Dan have all promised to present material
they've never published or publicly spoken about, I'm being a deadbeat and
playing my cards a bit closer to the chest. One of my talks will
definitely be new, however, and I even know what it will be about:

Faux Amis in C++

English speakers learning French quickly encounter faux amis: French
words that look like English words, but that have different
meanings. Developers who progress from C to object-oriented C++ to
templates to the STL and then to generic programming also encounter faux
amis: new constructs that look like old ones, but that behave
differently. In this talk, Scott identifies a number of important faux
amis 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.

I'm still mulling over the topic of my second talk. There is some chance
that it will include some material I'll be debuting in the UK earlier in
October (I'll post about that in a few days), and that's why I can't
guarantee that what I present at TCS3 will be ALL new. I can guarantee
that it will be mostly new, and I can also guarantee that it will cover
material I've never published. Unless you attend one of my UK talks this
October, my TCS3 talks will definitely cover material you have never seen
me cover before. (If there's a topic you'd like to see me address, send me
mail and let me know about it. I'm very supceptible to the powers of
suggestion.)

To learn more about TCS3, visit http://www.thecppseminar.com/03/. Be sure
to check out the link to the hotel (The Heathman Lodge), which is one of
the nicest places in the Portland metropolitan area. I should know: I
scouted out dozens of venues before choosing The Heathman. You can
register for TCS3 at http://www.thecppseminar.com/03/registration.htm.
Earlier is better than later, not only because we have an early bird rate
that expires on September 15, but also because of the enrollment limit of
95.

I hope to see you in Vancouver at the end of October.

Scott