"Ask Us Anything!" Session from C&B 2012 now live

The final part of each C++ and Beyond is always the wide-open "Ask Us Anything!" Q&A session. Charles Torre from Microsoft's Channel 9 was there with video equipment in hand (okay, most was on the floor, and the camera itself was on a tripod, but you know what I mean), and his recording is now available.  Andrei, Herb, and I hope you enjoy it.

Scott

C++ & Beyond Interview with me, Herb, and Andrei

At the end of the second day of C++ and Beyond, Charles Torre of Channel 9 corralled me, Herb Sutter, and Andrei Alexandrescu and pelted us with questions, some from him, others from Channel 9 viewers.  The interview is now online, the first of several videos associated with this year's C&B that will be rolled out on an ongoing basis.

Enjoy!

Scott

C&B 2012 Registration Ends Tomorrow!

Registration for C++ and Beyond 2012 ends tomorrow (Wednesday) at 11:55PM Eastern Time--roughly 36 hours from now.   For the third year in a row in this unique conference's three-year history, we've set a new attendance record, but there are still some spots available for this limited-enrollment event. 

Perhaps one reason for the unprecedented interest is the unprecedented amount of technical material we'll be presenting, much of it announced only recently.  We even extended the schedule for the first two conference days to make room for new content.  If you haven't been following the C&B blog, you may be interested in these posts from the past week and a half:

• Writing Fast Code, which describes a new double-length session (three hours total) that Andrei Alexandrescu will be presenting based, in part, on the work he's been doing at Facebook to optimize the processing of, well, lots, of data. This is not theoretical it-should-run-faster-if-we-do-this kind of stuff, it's the result of countless hours trying things out and seeing what actually works.  For performance-oriented C++ developers, it can't get more practical than this.
• A Special Announcement by Herb Sutter that gives C&B attendees a sneak preview of and an opportunity to help shape the initial rollout of a project that will be a boon to the entire C++ community.  As Herb clarified in a comment below his post, this project will be free and available to everybody when it goes live, but Herb needs a limited group of active and experienced C++ developers from whom to solicit feedback and engage in active discussion at this point in the project's creation, and C&B 2012 attendees will be part of that group.
• More C&B than ever!, which describes how each year's C&B has scheduled more time for technical content than the year before.

Those are just the most recent posts.  For all the C&B-related info, check out the full blog history.

This isn't the C&B blog, however, it's my blog, so I'll remind you of the talks I'll be giving at C&B:

• Secrets of the C++11 Threading API
• Universal References in C++11
• Initial Thoughts on Effective C++11

Having just finished the materials for these presentations, I can say I'm quite excited about them.  I think they'll help make it easier to use some of the new features in C++11 to greatest effect, while at the same time avoiding some of the potential pitfalls that accompany those features.

I hope to see you in Asheville, NC, next week.

Scott

Final C&B Talk Announced

I just announced the final talk I'll be giving at this year's C++ and Beyond. It's Secrets of the C++11 Threading API.  Like my other talks, it's a new presentation covering new information I've never written, blogged, or spoken about before. (Okay, there may be some tiny overlap.  For example, in my Effective C++11 talk, I'm going to offer a more detailed analysis of the issues I raised in my blog post, std::string, SSO, and Move Semantics.)

The full slate of talks I'll be giving at C&B in August is:

• Universal References in C++11
• Initial Thoughts on Effective C++11
• Secrets of the C++11 Threading API

In addition, I'll be participating in panel discussions and Q&A sessions with Herb Sutter and Andrei Alexandrescu on these topics:

• Convincing Your Colleagues
• Modern C++ = Clean, Safe, and Faster Than Ever
• Ask Us Anything!

For the talks Andrei and Herb will be giving, check out the C&B schedule. I think you'll find that the mix of talks this year is especially compelling, even by C&B standards.

Registration for C++ and Beyond continues through the end of July, but we're nearly 3/4th full, and once all the seats are gone, they're gone.  In addition, the discounted room rate for C&B attendees expires on July 6, so if you're interested in being part of the premier C++ event of 2012 (at least among those being held in Asheville, NC, in August :-}), I encourage you to sign up sooner rather than later.

Scott

35% Discount Code for my Digital Book Bundle

Today I got email from my publisher regarding the bundled electronic versions of my books:

Only informIT.com offers this collection in both PDF and ePub formats, together for one price. PRE-ORDER TODAY and SAVE 35% off the list price.

Enter the coupon code MEYERS8627 during checkout to receive your discount. Offer expires June 21, 2012.

The list price of the bundle is $95.99, but, from what I can tell, the "normal" pre-order price is $76.79.  The email says that with the code, the price drops to $62.40.

I don't know if I'm supposed to share this coupon code with you, but the email didn't say I shouldn't, so here you go :-)

In my original post about this digital book bundle, I noted that I had not had a chance to review the product, and that's still the case.  (They tell me I'll get a copy once they're sure it's ready to ship, which I think is quite reasonable.)  I've also not tested the discount code mentioned above.  But I have no reason to think that the bundle is anything less than it's advertised to be, nor do I have a reason to doubt the authenticity of the coupon code. 

If you're interested in having electronic copies of my books for only about $20 each, this looks like a good way to get them.

Scott

PS - My wife suggests you buy as many copies as you can afford.  My editor wonders whether it'd really be such a hardship if you were to buy a few more than you can afford :-)

New Digital Bundle of my Books

I recently received this message:

Hi Scott,

I was looking through the books at InformIT.com and was checking to see if the promotion for buying all of your Effective C++ books together was still active and found this instead:

Effective C++ Digital Collection: 140 Ways to Improve Your Programming

Are those updated versions of your books, or is that one SKU for all three existing books in that series?

I replied:

This is a single SKU for digital editions of all my existing books.  The content of the books is the same as the current editions of the printed books. I was not actually aware that this SKU had been put online, though I knew it was in the planning stages.

Shortly thereafter, I got mail from my publisher:

Your eBook digital collection is now available for pre-order. You can feel free to start pointing folks to http://www.informit.com/store/product.aspx?isbn=0133068625 now!

Consider yourselves pointed.

My books have been available in PDF for over three years (per this post from Feburary 2009), but, as far as I know, this is the first time they've been made available as a bundle of all three books in both PDF and ePub formats. I have not yet had a chance to examine this bundle myself (the author is always the last to know...), but when I announced the PDF versions in February 2009, I wrote:

[The PDFs are] DRM-free and chock-full of linked navigation in all the ways I believe you have a right to expect: tables of contents, indices, cross-references, URLs, mailtos, the whole nine yards.

To the best of my knowledge, all those features are still present.  For all I know, so are a whole bunch more.  Once I get my hands on the digital bundle and take a look at it, I'll let you know for sure. 

Scott

 

Final Week for Early-Bird Registration for C++ and Beyond

This is the final week for Early-Bird (i.e., discounted) registration for C++ and Beyond, the C++ conference-only-better event organized and put on by me, Herb Sutter, and Andrei Alexandrescu. Among the topics we'll address in our technical sessions are "universal references" in C++11 (a term I'll introduce, define, and, I hope motivate), using C++11 features to write error-resilient code, how new C++11 meanings for longstanding keywords affect concurrent and parallel code, and how to convince your colleagues to improve their software development behavior.  Additional topics are listed on the C&B 2012 Schedule Page, and there are more to come.

Every year I say the same thing about C&B, but every year I honestly believe it:  the coming C&B looks to be the best one ever. It's still the only C++ event featuring limited attendance; all-new presentations by me, Herb, and Andrei; and communal breakfasts and lunches as one of many characteristics designed to maximize the opportunity for you to talk not just with us, but also with one another.  In a year with more C++ events than probably any since the turn of the century, C++ and Beyond continues to distinguish itself as an event focusing not just on top-notch content, but also on face time with the people who developed the content and with the leading developers who will apply it.

During the Early Bird period, registration is discounted 10% for both individual and group registrations.  Group registrations (three or more) get an additional 10% off for being a group, so for the remainder of this week (i.e., through Friday), the discounts are effectively 10% for individuals and 20% for members of groups.  That's a savings of literally hundreds of dollars per registration.

Early-Bird registration won't be extended, so if you'd like to be part of C++ and Beyond 2012 (I'd certainly love to see you there), I encourage you to register no later than Friday.

Scott

Josuttis 2E has arrived!

For C++98, the standard everyday reference work for the C++ standard library was Nicolai M. Josuttis' The C++ Standard Library.  His updated version for C++11 has been eagerly anticipated, and I was pleased to receive my copy yesterday.

I was confident that the new edition would be a worthy successor to its predecessor, but I have this whole Trust-and-Verify mentality, so I forced myself to withhold judgement until I'd had a chance to check the book's content.  I wasn't disappointed.  Based on skipping around and reading here and there (primarily about functionality new to C++11, including emplacement functions, forward_list, random numbers, tuples, async, and the atomics API, not to mention an overview of new C++11 core language features, e.g., lambda expressions, rvalue references, constexpr, and more), the second edition of The C++ Standard Library looks to be to C++11 what the first edition was to C++98:  the first place to go for a readable and insightful summary of the C++ standard library.  Language lawyers will still turn to the C++ Standard itself, of course, and Josuttis' new book doesn't cover every nuance of library interfaces any more than the first edition did, but note my use of the word readable in my description of his presentation.  The Standard is definitive, but it's not readable.  Josuttis' book is readable, and, for most people most of the time, as good as definitive. I make my living studying the arcania of C++, but when I'm coding, I turn to Josuttis when I can and the Standard only when I must.

Interestingly, the physical size of the new book is no larger than the original edition, even though the standard library has become a lot bigger.  The new book has 300 more pages, however.  (Exactly 300.  The final page number in the first edition is 799, and the final page number in the new version is 1099.  How he managed that, I don't know, but it's a neat trick.)

[The following information about electronic editions has been revised since my original post.]
In terms of electronic editions, the book is available in PDF and ePub, plus there is an edition for Kindle. This information is courtesy of comments readers left on this blog entry, and I am grateful to them for it.

I encourage you to consider buying your own copy of the new edition of The C++ Standard Library.  Having it close at hand was indispensable for C++98 programming, and I think that having it close at hand for C++11 programming will be just as important.

Scott

Information on the C++11 Memory Model

I've been receiving a number of inquiries about where to turn for information about the C++11 memory model (technically the memory consistency model).  Having prepared and given a talk on the topic at last year's C++ and Beyond, I can tell you that the C++11 memory model is one of the most technically challenging topics I've ever tried to master. The good news is that if your goal is simply to write well-behaved multithreaded programs, you don't need to know any of the details of the memory model.  All you need to remember is to avoid data races in your programs, and the simplest way to do that is to follow the advice that multithreaded developers have been following for years:  access shared mutable data only when you know you have exclusive access to it, typically by acquiring a mutex before the access and releasing the mutex after the access. C++11 offers RAII classes to automate the release part of this protocol (std::lock_guard and std::unique_lock), so this is easier than ever to do. In C++11, you can also use atomic data types (e.g., std::atomic<bool>) to ensure exclusive access with often greater efficiency, but conceptually these are just data types where, on each access, C++ itself handles the moral equivalent of locking and unlocking the appropriate mutex.  (In practice, special machine instructions that avoid the need for mutexes are typically employed.) So, as I said, if your interest in the C++11 memory model is to know how to write threaded programs that will run correctly, you can essentially ignore the model itself.

If, on the other hand, you really want to understand the memory model, you have your work cut out for you.  Under no conditions should you start with the C++11 Standard!  Without the proper protective gear in place, that thing could maim you for life. Instead, I suggest you start with Anthony Williams' book, C++ Concurrency in Action.  Chapter 5 has the most comprehensible description of the C++11 memory model I have seen, and in fact it's the only one I know of that points out that C++11 actually offers three different consistency models:  sequential consistency, acquire-release consistency, and relaxed consistency.  (That alone should give you some idea of what you're in for if you decide to delve into this topic.) I own Williams' book in both electronic and paper form, and I think it's not just the best current treatment of C++11's threading facilities (including, but not limited to, the memory  model), it's likely to remain the best for some time to come.

Sources that complement Williams' coverage include the following.  Note that anything published before September 2011 may differ from the final C++11 memory model, and the longer the time before September 2011, the higher the likelihood of divergence.

• Shared Memory Consistency Models: A Tutorial, Sarita V. Adve and Kourosh Gharacholloo, digital Western Research Laboratory, September 1995. This paper has nothing to do with C++, much less C++11, but it's the granddaddy of all memory model articles, and if you wish to come to grips with memory model issues, you must understand the material discussed here.   Read it twice before proceeding.
• “A Less Formal Explanation of the Proposed C++ Concurrency Memory Model,” Hans-J. Boehm, WG21 Document N2480, 9 December 2007.
• “Foundations of the C++ Concurrency Memory Model,” Hans-J. Boehm and Sarita V. Adve, Proceedings of PLDI’08, June 2008.
• Threads and memory model for C++, Hans Boehm. This is a collection of links to various documents.
• Prism: A Principle-Based Sequential Memory Model for Microsoft Native Code Platforms, Herb Sutter,WG21 Document N2197, 11 March 2007. This does not describe the C++11 memory model. Rather, it describes a similar memory model, and the description in this document is much easier to follow than in most other places.

Good luck!

Scott

std::string, SSO, and Move Semantics

I'm becoming increasingly concerned that C++11's support for move semantics is leading some people to conclude that we no longer have to pay as much attention to the cost of copying objects as we used to.  "Many copies will silently become moves," they exclaim, "and moves are cheap!" Such reasoning is invalid in a number of ways.

First, not all copy requests can be replaced by moves.  Only copy requests for rvalues are eligible for the optimization.  Second, not all types support move operations that are more efficient than copying operations.  An example is a std::array<double, 1000>.  Third, even types that support efficient move operations may support them only some of the time.  Case in point: std::string.  It supports moves, but in cases where std::string is implemented using SSO (the small string optimization), small strings are just as expensive to move as to copy!

What it means to be "small" is up to the implementation.  Unless I'm misreading the source files, std::strings with a capacity of up to 15 are "small" in Visual C++ 11 beta, so std::string objects of up to that capacity will not benefit when copies become moves.  (The SSO buffer size seems to be hardwired to be 16 bytes in VC11, so the maximum capacity of a std::wstring that fits in the SSO buffer is smaller:  7 characters.)

gcc 4.7 seems to continue to use reference-counting instead of SSO for its std::string implementation.  This is non-conforming in C++11 (reference-counting may no longer be used for std::string), and it looks like gcc is aware that it must be changed. However, gcc 4.7 offers the non-standard __versa_string with a std::basic_string-compatible interface (other than the name of the template and the namespace in which it's located), and __versa_string offers the SSO.  In this case, the maximum capacity of "small" strings seems to be hardwired to 15 characters (not bytes).

While googling around for a good page to link to for the term "small string optimization" above, I came across John Ahlgren's blog entry of March 30 on how SSO interacts with move semantics.  He refers to the fact that short strings with the SSO move more slowly than longer strings as the "small string deterioration" :-)

Scott

C++11 is Almost Here for Real!

This entry is the first under a slightly expanded charter for this blog.  Until now, I've restricted blog entries to announcements about my professional activities.  Hereafter, entries will simply be related to my professional activities and interests. The difference is subtle, and, in all likelihood, you will rarely notice it.

---

At the beginning of my Overview of C++11, I show a simple program to compute the most common words in a set of input files.  I write the program once using "old" C++ (i.e., standard C++98/03), then again using features from C++11. 

In 2009, when I first published the C++11 program (at that time, what became C++11 was still known as C++0x), there was no compiler that could come anywhere near compiling it. Testing the code required replacing standard C++11 library components with similar components available in TR1 or from Boost or Just Software Solutions, and language features like auto, range-based for loops, lambda expressions, and template aliases had to be replaced with typically clumsier C++98/03 constructs that were more or less equivalent in meaning.

This week I tested my simple C++11 sample program with Stephan T. Lavavej's excellent  distribution of gcc 4.7 for Windows as well as Microsoft's VC11 beta.  gcc 4.7 has lots of support for C++11, but the concurrency API still seems to be largely missing, at least for Windows, so my sample program doesn't get very far with that compiler.  [Update 6 April 2012: As noted in the comments below, when invoked in the proper manner on the proper platform, gcc 4.7 compiles and runs my program without modification!]

 The situation with the VC11 beta is a lot better.  Only two lines have to be changed.  The template alias

  using WordCountMapType = std::unordered_map<std::string, std::size_t>;

needs to be replaced by its typedef equivalent:

  typedef std::unordered_map<std::string, std::size_t> WordCountMapType;

And the z length specifier in this call to printf,

  std::printf("  %-10s%10zu\n", (*it)->first.c_str(), (*it)->second);

needs to be replaced with its VC++ equivalent, I:

  std::printf("  %-10s%10Iu\n", (*it)->first.c_str(), (*it)->second);

Other than that, the demonstration program I wrote three years ago (which, in fairness to compiler writers, was two and a half years before the C++11 standard was ratified) compiles cleanly with VC11.

If you have access to a compiler that compiles my program without modification, please let me know! The program itself is below.  You can see a more colorful version of it, along with some commentary, and an example invocation and the corresponding output, on slides 13-15 of the free sample of my C++11 training materials.

Scott

#include <cstdio>
#include <iostream>
#include <iterator>
#include <string>
#include <fstream>
#include <algorithm>
#include <vector>
#include <unordered_map>  
#include <future>

using WordCountMapType = std::unordered_map<std::string, std::size_t>;

WordCountMapType wordsInFile(const char * const fileName)   // for each word
{                                                           // in file, return
  std::ifstream file(fileName);                             // # of
  WordCountMapType wordCounts;                              // occurrences

  for (std::string word; file >> word; ) {  
    ++wordCounts[word];
  }
  return wordCounts;
}

template<typename MapIt>                                            // print n most  
void showCommonWords(MapIt begin, MapIt end, const std::size_t n)   // common words
{                                                                   // in [begin, end)
  // typedef std::vector<MapIt> TempContainerType;
  // typedef typename TempContainerType::iterator IterType;
  std::vector<MapIt> wordIters;
  wordIters.reserve(std::distance(begin, end));
  for (auto i = begin; i != end; ++i) wordIters.push_back(i);

  auto sortedRangeEnd = wordIters.begin() + n;

  std::partial_sort(wordIters.begin(), sortedRangeEnd, wordIters.end(),
                    [](MapIt it1, MapIt it2){ return it1->second > it2->second; });

  for (auto it = wordIters.cbegin(); 
       it != sortedRangeEnd; 
       ++it) {
    std::printf("  %-10s%10zu\n", (*it)->first.c_str(), (*it)->second);
  }
}

int main(int argc, const char** argv)   // take list of file names on command line,
{                                       // print 20 most common words within;
                                        // process files concurrently
  std::vector<std::future<WordCountMapType>> futures;

  for (int argNum = 1; argNum < argc; ++argNum) {
    futures.push_back(std::async([=]{ return wordsInFile(argv[argNum]); }));
  }

  WordCountMapType wordCounts;
  for (auto& f : futures) {
    const auto wordCountInfoForFile = f.get();  // move map returned by wordsInFile

    for (const auto& wordInfo : wordCountInfoForFile) {
      wordCounts[wordInfo.first] += wordInfo.second;
    }
  }

  std::cout << wordCounts.size() << " words found.  Most common:\n" ;
 
  const std::size_t maxWordsToShow = 20;
  showCommonWords(wordCounts.begin(), wordCounts.end(), 
                  std::min(wordCounts.size(), maxWordsToShow));
}

My Training Courses through Other Vendors

For many years, I've allowed select outside technical trainers and training firms to use my course  materials with their clients. In cases where people approached me for training, but, due to scheduling or location or budgetary issues, etc., we were unable to work out an agreement, I'd refer them to one or more of these outside vendors.

These days, I face a challenge most people would love to have: there's more demand for my services than I can provide. Fortunately, thanks to these outside trainers and training firms, I have a viable suggestion for would-be training clients in cases where I can't do the work myself. In the past, my referrals to outside vendors have been ad hoc, but the issue arises often enough that I decided to put together a page at my web site listing the various individuals and companies who are authorized to use my training materials.

As a general rule, these vendors tend to have better scheduling flexibility than I do. I typically know the people who do the training, and I have great confidence in them. They use the exact same training materials that I use. As the person who did the research into the topics addressed by the materials and who created the materials themselves, I like to think I offer something nobody else can, but in cases where my doing a training gig is not possible, I'm pleased to be able to offer clients and would-be clients reasonable alternatives.

To view a summary of my authorized outside training vendors, please visit my Approved Outside Vendors page.

Thanks,

Scott

Open-Enrollment Seminars in May in Eindhoven, The Netherlands

In 2002—ten years ago!—I gave my first-ever presentation on the effective use of C++ in embedded systems. That presentation was sponsored by Programming Research, a firm that develops static analysis tools for C and C++. Such tools were near and dear to my heart then, and they're no less so now, so I was pleased when Programming Research asked me to collaborate with them again. The result is two seminars this May in Eindhoven, The Netherlands:

21-22 May 2012			Effective C++ in an Embedded Environment
23 May 2012			Better Software—No Matter What

The presentation on C++ in embedded systems has been substantially extended and updated since its world debut a decade ago, but the core of that talk—providing practical information about how to apply C++ to solve common problems and to address common issues faced by embedded developers—remains unchanged. For a more detailed overview of the seminar than you'll find at the page linked to above, consult my web site's description.

My Better Software seminar has a characteristic that takes many people by surprise: it doesn't focus on C++.  It was originally motivated by my observation that many C++ projects that struggle do so for reasons that have nothing to do with the choice of programming language, so I put together a presentation that focused on the extralinguistic (but still programming-based) issues I commonly encountered.  When I was done, I realized that the issues in the presentation applied regardless of..., well, let me quote from my web site's description of the seminar (which is more comprehensive than the official seminar page linked to above):

Some development practices improve software quality, regardless of the domain of the application, the language in which it's written, the platform on which it runs, or the users it is intended to serve. This seminar explores fundamental principles, practices, and standards that improve software quality, no matter what the software does, how it does it, or whom it does it for.

As a reader of this blog, you're likely a C++ developer, but while the material in the seminar is perfectly applicable to you, it's also perfectly applicable to your colleagues who use other languages.  I encourage you to let them know about it.

This will be my first time working in The Netherlands.  With luck, it won't be my last. I hope to see you in Eindhoven in May.

Scott

C++ and Beyond 2012 Registration is Open!

For the third year in a row, Herb Sutter, Andrei Alexandrescu, and I are teaming up for C++ and Beyond, a limited-attendance conference-only-better event built around the dissemination of new, timely, and practical information for serious C++ software developers. This year's C&B will take place August 5-8 in Asheville, North Carolina, at the Grove Park Inn.

A more detailed post announcing the opening of registration is available on the C&B Blog, which I encourage you to subscribe to if you're interested in C++ and Beyond. That's where most information about it gets posted. Or you can go straight to the registration page, if you like :-)

I hope to see you in Asheville at C++ and Beyond 2012.  Andrei and Herb and I are working hard to make it the best C&B ever!

Scott

Minor Update to Table Showing Compiler Support for C++11

I just added coverage of enhanced enums (e.g., enum classes) and new alignment controls (alignof, alignas, std::aligned_storage and std::aligned_union) to my C++11 training course, and during the course of my research into and testing of those features, I made some minor updates to my summary table of C++11 support in gcc and MSVC.

The new slides will be included in the published version of my C++11 training materials the next time I push out a release.  Having recently done that, I don't expect the next release to go out for a while, but in the meantime, the information sources I refer to for enhanced enums and for alignment control in my C++11 training course are listed below.

Enhanced enums:

• “Strongly typed enumerations,” Wikipedia.  Subsection of entry for “C++11”.
• “enum class -- scoped and strongly typed enums,” Bjarne Stroustrup. Subsection of “C++11 – the recently approved new ISO C++ standard.”
• “Better types in C++11 - nullptr, enum classes (strongly typed enumerations) and cstdint,” Alex Allain.
• “C++0x Forward Enum Declarations Cut Down Compilation Time and Dependencies,” Danny Kalev, 13 August 2009.

Alignment Control:

• “Probe and Modify Your Types' Alignment Programmatically,” Danny Kalev, DevX.com, 10 July 2008.
• “alignas / alignof,” George Flanagin, 17 June 2011.

Scott

September Open-Enrollment Seminars in Stuttgart, Germany

In what has in recent years become an annual pilgrimage to Stuttgart, I, in collaboration with QA Systems, will conduct three open-enrollment seminars in September.  Each is two days long.  As with all my public presentations, you'll find details at my Upcoming Talks page. To save you the trouble of clicking through that, here's the summary:

17-18 September 2012			Effective C++ in an Embedded Environment
20-21 September 2012			Fastware for C++
24-25 September 2012			An Overview of the New C++ (C++11)

The talk on C++11 will be a two-day version of my three-day training course, which means that some topics I'd normally cover will be omitted. The topics to be skipped will come out of the material covering new standard library functionality, but which library features will be omitted will be determined during the seminar, based on the interests of the attendees and the time remaining after all core C++11 language topics have been discussed.  To ensure that attendees have copies of all the materials I'll show, each attendee will receive a copy of the materials for the full three-day seminar, even though it will be clear from the outset that I won't be able to cover everything.  In other words, the handout you'll get as a seminar participant will include "bonus topics" not covered in the lecture :-) 

Last year's experiment in doing a presentation in German was, linguistically speaking, successful (people had no trouble understanding me, and I had no trouble responding to their questions and comments), but I don't speak German as quickly as I speak English, and that meant that I had to omit a couple of topics I normally cover.  The feedback I got was that covering more topics was more important than doing a presentation in German, so this year, I'm back to an all-English set of talks.  During breaks and lunch, I still plan to speak German, however, so if you're interested in hearing my funny accent and colorful grammatical constructs, don't worry. You'll have plenty of chances :-)

I look forward to seeing you in Stuttgart in September.

Scott

C++11 Training Materials now jibe with the Final Standard

I mentioned in my November announcement of an updated version of my C++11 training materials that I'd been made aware of a few places where my stuff wasn't fully in accord with the final standard.  In this most recent revision, I've addressed those issues.  To the best of my knowledge, everything in the materials now corresponds to the standard.

Achieving such conformance was my primary motivation for releasing a new set of materials so soon after the last revision, but I also clarified some explanations, fixed a few typos, and did other minor housekeeping chores. All in all, I revised things in about two dozen places. As always, people who've purchased the notes should have automatically been notified of the new release, and they should have received a list of changes I made. If you weren't notified, let me know.

Added 1/27/12: From Artima (publisher of the training materials):

You can log into Artima with the account you used to purchase the
book, click on "Your Settings", and redownload anytime. If you've
forgotten your password, you can get a reminder at
http://www.artima.com/account/mailpwd?d=%2Findex.jsp

Incidentally, I also increased the length of the free sample from 25 to 40 pages, thereby adding range-based for loops, nullptr, Unicode support, and raw string literals to the list of topics I cover there. That should make it easier for people to get a better feel for what they'll receive if they purchase the materials.

I hope you'll excuse my repeating myself from my November posting, but the following is still apt:

If you're interested in a book-like publication covering the most important parts of C++11 (both language and library), I encourage you to consider purchasing my training materials.  If you like my other publications, I think you'll like these, too.  To see exactly what you'll be getting, check out the free sample.

Because this publication is in an unconventional format (annotated training materials), is available from a lesser-known publisher (Artima), and is electronic-only (DRM-free PDF), getting the word out about it has been challenging.  I'd appreciate it if you'd let people know about it, whether through blogs, tweets, social networks (the politically correct term for Facebook), email, or that most retro of communications mechanisms, face-to-face conversation.

Thanks,

Scott

C++ and Beyond 2012 Announced

We've just announced dates and locations for C++ and Beyond 2012: August 5-8 in Asheville, North Carolina.  Like its predecessors, enrollment will be limited, and the centerpiece of the event will be all-new technical sessions by me, Herb Sutter, and Andrei Alexandrescu.

For more information, consult the announcement on the C++ and Beyond blog, then make plans to spend August 5-8 in Asheville for the premier C++ event of the year. I look forward to seeing you there!

Scott

New C++ and Beyond 2011 Panel Sessions Now Online

Microsoft's Channel 9 has posted two more sessions from last year's C++ and Beyond.  Both feature me, Herb Sutter, and Andrei Alexandrescu fielding questions from C&B attendees.

Session topics are:

• Concurrency and Parallelism.  This was actually put online in November, and I simply forgot to announce it here. Mea culpa.
• "Ask Us Anything." This was the last session of the event, so the questions were rather varied.

These are the final sessions from last year's C&B that will be posted, but we're already hard at work on C++ and Beyond 2012. It will take place August 5-8 in the eastern USA.  I'll post details soon -- within days.

Scott

C++11 Training Materials Updated

Now that C++0x has become C++11, I updated the name of my training materials and released the latest revision to past buyers. This marks the third updated release of these materials since their original publication in April 2010.

Updating notes for a multiple-day training course (such as my three-day C++11 seminar) has an interesting constraint:  unless the changes involve adding or removing full days worth of material, the length of the course can't be changed.  For a topic like C++11, where I'm learning more all the time, this means that I sometimes want to add information without changing the length of the class.  One way I do that is by adding comments below the PowerPoint slides.  The comments don't get shown in class, but they elaborate on material in the slides.

For the most recent materials update, one of the ways I took advantage of this was by taking the following bullet point from a list of "Other Features" in C++11 (that the course doesn't really cover, typically because the features are less important or because there's currently little or no compiler support for them):

• Contextual keywords for alignment control, preventing derivation, and constraining virtual function overrides.

I added the following elaboration in the comments:

The identifiers override and final are contextual keywords. Both classes and virtual functions may be declared final. final classes may not be used as bases (per 9/3), and final virtual functions may not be overridden in derived classes.  A virtual function declared override must override a function in a base class. The following is an amalgam of examples from 10.3/4-5:

struct B {
    virtual void f() const final;
    virtual void f(int);
};
struct D : B {
    void f() const;                      // error: D::f attempts to override final B::f
    void f(long) override;             // error: wrong signature overriding B::f
    void f(int) override;               // OK
};

Because elaborations like this generally don't get presented in class, this means that the information in the training materials is in some ways more comprehensive than the information I deliver during a presentation. On the other hand, during a live presentation, people can ask about whatever they want, so I typically address a variety of topics that aren't in the training materials at all.

To the best of my knowledge, my training materials are currently the best source of accessible information about C++11. The Internet is filled with pages about C++11, but many of them were written at a time when draft C++0x was still in a state of flux, and unless you already know the details of the final version of C++11, it's hard to judge whether what you read on a given page is up to date.  The final C++11 standard is definitive, of course, but it's currently expensive (about US$400 at the ISO store), and I don't think anybody will tell you it's easy to read or understand.  There is, as far as I know, only one book out that covers C++11, and although I have not read it, given its recent publication date, I'd be surprised if it takes into account the very latest changes that took place during standardization. (I'd hoped to link to this book, which I know about only from a press release, but now I can't find it. If you know which book it is -- or of other books currently available that cover C++11 -- please let me know.)

To be frank, my training materials aren't perfectly up to date, either.  I had hoped that they were, but it's a big standard (1353 pages), and just yesterday I received a set of bug reports from a member of the standardization committee pointing out places where my notes' treatment of some parts of C++11 are out of sync with the final standard.  I'll fix those problems in the next release of the training materials, a release that, like all releases, will be automatically pushed out to anybody who has purchased the materials.

If you're interested in a book-like publication covering the most important parts of C++11 (both language and library), I encourage you to consider purchasing my training materials.  If you like my other publications, I think you'll like these, too.  To see exactly what you'll be getting, check out the free sample.

Because this publication is in an unconventional format (annotated training materials), is available from a lesser-known publisher (Artima), and is electronic-only (DRM-free PDF), getting the word out about it has been challenging.  I'd appreciate it if you'd let people know about it, whether through blogs, tweets, social networks (the politically correct term for Facebook), email, or that most retro of communications mechanisms, face-to-face conversation.

Thanks,

Scott

C++11 Discussion with me, Herb Sutter, and Andrei Alexandrescu

One of the panel sessions at C++ and Beyond 2011 in August was devoted to C++11, the new standard for C++. That panel session is now live.  I hope you find it interesting.

Scott

"Final" C++11 Feature Availability Summary Updated

Since "freezing" my C++11 Feature Availability Summary about a month ago (per this post), I've had a couple of people point me to Stephan T. Lavavej's unbelievably detailed blog post summarizing C++11 feature availability in Visual C++ 11 (as well as VC10), plus I came across Michael Wong's corresponding post for C++11 support in xlC++, so I decided that I froze only the feature tables in my C++11 support summary.  I'll continue to update my links to sources summarizing C++11 feature support in various compilers, because that's not a lot of work for me, and I think the information is useful.  You'll find those links on the first page of my feature availability summary.

Enjoy the ever-burgeoning compiler support for C++11!

Scott

Video Interview with me, Herb Sutter, and Andrei Alexandrescu

Immediately after the conclusion of C++ and Beyond on August 10, Charles Torre from Microsoft's Channel 9 rounded up me, Herb Sutter, and Andrei Alexandrescu for an hour-long discussion of a variety of issues related to, well, C++ and beyond.  That interview is now live, and I hope you enjoy it.

Scott

C++11 Feature Availability Spreadsheet Updated

Now that C++ and Beyond 2011 is behind me, C++0x has been officially christened C++11 (or, as I like to think of it, "C++:  The Spinal Tap Edition"), and Stephan T. Lavavej pointed me to his unbelievably easy to download and install binary of gcc 4.6 for Windows, I had time to play with gcc 4.6 and update my C++11 feature availability summary (now rechristened to reflect that "C++0x" is terminologically passé).  Once again I found myself cackling with glee as I successfully built and ran programs with wacky stuff like

constexpr int factorial(int n) noexcept {                 // define constexpr function!
  return (n == 1) ? 1 : (n * factorial(n-1));
}

std::array<int, factorial(5)> a;                          // use it!

and

for (auto i : { 1, 2, 3, 4, 5} ) std::cout << i << " ";   // range-based for!

I mean, really, who can't love that?   More complicated stuff works, too, like defaulting and deleting and automatically generating move operations.  And nullptr (already present in VC10) joins the party, too. Fun, fun, fun. 

Because C++11 is no longer a draft standard (even if there are still some bureaucratic levers to be moved) and compiler support for C++11 is increasingly common, there's no need for me to keep updating the feature availability summary, so, modulo bugs in the existing data (I'll fix those as they're brought to my attention), I'm freezing it as is.  That will give me more time to play around with the newly-minted and schnazzed up C++, and that's a lot more rewarding than putting little letters in boxes on a spreadsheet.

Have fun with C++11.  How can you not?

Scott

Only 10 Seats Left at C&B next month

Next month's C++ and Beyond is nearly sold out;  there are only 10 spots left.  Registration runs until the end of the month, but only if we don't sell out first, which seems likely.  If you've been thinking about registering for three highly technical days with Herb Sutter, Andrei Alexandrescu, me, and about 100 of the most experienced and insightful C++ developers on the planet (registrations have already come in from three continents), I encourage you to do it while you still can.

I'm especially looking forward to hearing Herb talk about taking advantage of GPUs' computational capabilities in general-purpose programs, and I suspect that Andrei's talk on Big Data will reflect the fact that he and his colleagues have hallway conversations that include offhand comments like, "it's taking too long to create a hash table with four billion elements."  In the meantime, I'm working on the materials for my talk on the C++0x memory model, and my research is showing that, pretty much as expected, there are some interesting subtlties very much worth exploring.  And that's only a third of the technical program!

I'm also looking forward to hanging out and talking with those ~100 experienced and insightful developers, because they -- you -- collectively comprise a gold mine of information.  Plus they -- you -- work on really interesting problems.  And you're all just so darn nice, too.

I hope to see you in Banff next month!

Scott

C&B Early Bird Registration Expires Friday!

Early Bird registration (and, more importantly, the $300 per person discount that goes along with it) expires at the end of this week (i.e., at the end of the day on Friday, 10 June) for C++ & Beyond 2011, so if you've been thinking about joining Andrei Alexandrescu, Herb Sutter, and me in Banff in August to talk about topics such as programming GPGPUs, the C++0x memory model, processing BIG data, and more, be sure to sign up by the end of the week!

Scott

Presentation Materials from ACCU Talks Now Available

Silly me. When I posted about the availability of videos of my ACCU talks, I forgot to also make available the presentation materials for those talks, even though in the talks I say I'll send copies to anybody who asks me for them.  Let's skip the you asking me and me sending them to you, okay?  Instead, just download them directly:

• Presentation materials for "CPU Caches and Why You Care."
• Presentation materials for "Move Semantics, Rvalue References, and Perfect Forwarding.

Scott

Blog posts now reflected to Twitter

If you're interested in knowing about new posts to this blog, but your preferred notification mechanism is twitter, you'll be pleased to know that I've set up a twitter account, and I've arranged for blog posts here to be reflected there. This is, at least for the time being, the only use I plan to make of twitter.

At twitter, I'm @Scott__Meyers, i.e., http://twitter.com/Scott__Meyers.

Scott

Videos from ACCU Talks Now Available

The fine folks behind the 2011 ACCU Conference recorded my technical presentations, and those videos are now online as follows:

• CPU Caches and Why You Care.  This is an excerpt from my training course, Fastware for C++. 
• Move Semantics, Rvalue References, and Perfect Forwarding.  This is an abbreviated version of my treatment of the topic in An Overview of the New C++, and the fact that the abbreviated version runs an hour and a half gives you some idea of the depth of the subject. (The full version, including time for Q&A about the kinds of obscure edge cases that programmers live for, goes three hours or longer, but given the intricacies of rvalue references and their pervasive impact on C++0x, I think the investment is worth it.)

Viewing these videos is the next best thing to having been to the sessions, provided your definition of the next best thing includes having a seat at the extreme left end of Row 1. The video is nothing to tweet home about (especially if you want to read the text on the slides), but the audio is quite nice. One thing you're likely to find attractive is that the way the video is exposed, I'm hidden much of the time.

Enjoy!

Scott

Updated C++0x Training Materials Published

In April of last year, I announced the publication of my training materials on C++0x.  In trying to win your interest, I wrote:

In some ways, they're better than a book. They make more extensive use of color, they "cut out the fat" to focus on the technical essentials, and my licensing terms grant buyers unlimited updates for life: as long as I update the materials, buyers are entitled to a revised version for free.

I published updates last May and August, but I decided to hold off on publishing additional revisions until C++0x had settled down.  With ratification of the FDIS in March, that settling has occurred, so I've updated my training materials to correspond to the essentially-final draft standard.  The revised version of my materials also includes all the modifications I've made based on my experience using them for professional training purposes, so the latest incarnation should be both the most accurate ever as well as the clearest and most useful.

If you've purchased a copy of the materials, you should already have received notification from Artima Press on how to download the latest PDF. If you haven't purchased a copy, but you've been thinking you'd like to learn more about C++0x, maybe this is the time to give my materials a try.  You can download the first ~25 pages as a free sample at the materials' sales page.

I hope you find these revised materials on C++0x useful.

Scott

C&B Talk on Perfect Forwarding

I've just posted a description of another presentation I'll be making at C++ & Beyond to the C&B blog.  Like all the other talks at C&B, it's of the all-new, world-debut variety.  The title is Adventures in Perfect Forwarding, and following the link will take you to the blog entry that will tell you all about it.

I continue to hope to see you in Banff in August.

Scott

C&B Talk on C++0x Memory Model

Herb Sutter, Andrei Alexandrescu, and I are in the process of fleshing out the technical program for this year's C++ & Beyond, and I've just posted my first session announcement.  The title is "The C++0x Memory Model and Why You Care," and rather than repeat the talk description here, I'll let you follow the link to the C&B blog entry for the details.  This will be a new talk I'm creating specifically for C&B, and it should cover topics of interest to anybody who cares about multithreaded programming under C++0x.

The other C&B talks that have been so far announced are:

• Andrei's "BIG: C++ Strategies, Data Structures, and Algorithms aimed at Scalability."
• Herb's "C++ and the GPU… and Beyond" and "Exceptional C++0x (aka C++11)".

I think this year's C&B is shaping up to offer an exceptionally strong set of technical talks, and I hope to see you in Banff in August.

Scott

Appearing/Disappearing consts Article now at C++Next

Shortly after I posted about DDJ publishing and then "unpublishing" my article on appearing and disappearing consts, Eric Niebler suggested I publish it at C++Next. I was pleased to get the offer.  C++Next is emerging as a premier site for C++-related articles, and, unlike some other publishers I could mention, it doesn't demand exclusive worldwide rights to the content it publishes, nor does it insist on "the right in [its] sole and exclusive discretion to edit, rewrite, condense, abridge, or otherwise change" what I wrote. (In fairness, that last part was followed by "taking care, of course, not to change your meaning," but my experience is that the most appropriate person to retain sole and exclusive discretion over what I mean is me.)

Eric volunteered to do the hard work of taking my article and preparing it for publication at C++Next, and then, in a stunning departure from some other publishers I could mention, he worked with me as I tweaked things here and there for final publication.  The result is the best version of the article that exists, both in terms of content and presentation.

I'm grateful to Eric and also to Dave Abrahams, both of whom were instrumental in helping me publish this article in its current form.  In an era when anybody can publish anything with a few mouse clicks, it's a pleasure to work with people who remain dedicated to the hard and detailed work of making content available that's useful to readers and satisfying for authors. Even more than usual, any shortcomings that remain in the article are my fault, because Eric and Dave bent over backwards to accommodate my requests.

Scott

Effective C++ in the C++0x (C++11) Age

Yesterday, Herb Sutter posted the truly exciting news that the new version of C++ has reached FDIS status.  Practically (though not officially) speaking, this means that the new standard for C++ is finished, and we can stop using the code name "C++0x" and start using "C++11" in its place.

I was recently informed that the German translation of Effective C++ will be reissued with a new cover as part of their "classics" series.  They asked me to write a little something about it, and I came up with a new preface that considers the relevance of the information in the book in the age of C++0x/C++11.  Given the adoption of the FDIS, plus the fact that the preface will be published only in translation, it seems appropriate to post it here:

2011 is an exciting year for C++ developers. It marks the official debut of the new standard for C++, informally known as “C++0x”. Over a dozen years in the making, C++0x makes C++ more powerful and flexible than ever. In addition to introducing major new features, such as support for concurrency, lambda expressions, move semantics, and type deduction for variables (auto variables), C++0x provides an assortment of secondary capabilities that also increase expressiveness, improve efficiency, and eliminate programming drudgework. Examples include range-based for loops, static assertions, inheriting and delegating constructors, reference-counting smart pointers, hash tables, regular expressions, variadic templates, and more. All told, the C++0x feature set is about twice that of “old” C++. Furthermore, the feature set is increasingly real: the number of C++0x features supported by modern compilers is large and growing quickly. 2011 isn't just the year when C++0x receives official ratification as a new standard, it's also the year in which it starts to see serious mainstream use.

Which may lead you to wonder whether the information and advice in this pre-C++0x edition of Effective C++ remains relevant. I'm pleased to report that it does. Surprisingly so, in fact. Having spent nearly two years steeped in the details of C++0x, I expected to groan a bit as I reviewed this book's table of contents with C++0x in mind. Surely some Items would be inappropriate. But the advice I found proved sound. Should C++0x developers prefer consts, enums, and inlines to #defines (Item 2)? They should. Should they prevent exceptions from leaving destructors (Item 8)? Certainly. Should they use objects to manage resources? Declare data members private? Consider alternatives to virtual functions? Factor parameter-independent code out of templates? (Items 13, 22, 35, and 44.) Yes, yes, yes, yes! My goal has always been for Effective C++'s table of contents to summarize the advice in the book, and that summary remains just as applicable to C++0x development as to “traditional” C++ development. C++0x is a bigger language, and in some ways it's a different one, but the core techniques for making effective use of “old” C++ are core for the effective use of C++0x, too.

This doesn't mean that this Effective C++ is a perfect match for C++0x. The book doesn't discuss features new to C++0x, so Items about making effective use of those features are missing. A C++0xified Effective C++ would certainly have Items devoted to move operations, to uniform initialization, and to lambda expressions, and it'd probably have an entire chapter on making effective use of the concurrency API. Such a book would also contain different examples, e.g., ones making use of auto variables, range-based for loops, in-class default initializers, as well as the occasional variadic template. To the extent that this book falls short in its support for C++0x, the errors are those of omission, not commission.

But Effective C++ has never claimed to be a comprehensive book. My intent has never been for it to address every aspect of the language. Rather, it has been to examine the most important aspects of C++ that affect practicing programmers on a day-to-day basis. C++0x introduces new aspects of the language that warrant discussion, but that doesn't diminish the importance of the issues I treat in this book. In fact, it may accentuate them, because effectiveness with C++0x requires mastery of the language it extends, i.e, “old” C++. As the shiny new parts of C++0x garner more and more attention, discussion of the “old” parts will recede, but those parts will still be important.

Whether you're programming in “traditional” C++, “new” C++, or some combination of the two, then, the information and advice in this book should serve you well, both now and in the future.

C++ and Beyond 2010 Presentation Materials Now Available

The official presentation materials from last year's C++ and Beyond event that I did with Herb Sutter and Andrei Alexandrescu are now available for purchase.  For the full story, please consult my post at the C++ and Beyond web site.

Scott

Neuer Schulungskurs: Effektives C++ im eingebetteten Bereich

Seit 1999 habe ich mit der Firma QA Systems daran gearbeitet, technische Seminare in Mitteleuropa (hauptsächlich in Deutschland, normalerweise im Herbst) zu halten. Wir haben versucht, fast jedes Jahr etwas Neues anzubieten. Bis zu diesem Jahr hat „etwas Neues“ immer neue Themen bedeutet, und in den letzten Jahren ist es fast voraussehbar geworden, dass die Weltpremieren meiner neuen Seminare in Deutschland stattfinden. So war es mit meinem Seminar über C++0x in 2009 und mit dem über Fastware in 2010. Für 2011 wollen wir auch etwas Neues haben, aber dieses Jahr ist es kein neues Thema. Stattdessen ist es ein bewährtes Thema – die effektive Anwendung von C++ im eingebetteten Bereich – in einer neuen Sprache: Deutsch.

Wir finden, dass es ständig Interesse an diesem Thema in Deutschland gibt, und wir glauben, dass einige Ingenieure die Informationen lieber in ihrer Muttersprache erfahren würden, auch wenn der Referent (ich) mit einem komischen Akzent spricht. Der Inhalt des Kurses ist gleich wie die ursprüngliche englische Version („Effective C++ in an Embedded Environment“), aber alles ist auf Deutsch: der Vortrag, die Folien, die Unterlagen, die Fragen und Antworten – alles.

Ich kann nicht behaupten, dass ich Deutsch so gut spreche wie  Englisch (schön wär's!), aber QA Systems und ich denken, dass wir dieses Jahr eine gute Gelegenheit anbieten, nützliche, verlässliche Informationen über die Anwendung von C++ im eingebetteten Bereich auf Deutsch zu bekommen. Wenn Sie sich für dieses Thema interessieren, empfehle ich Ihnen, dass Sie die Beschreibung des Kurses auf der QA Systems Website anschauen.  (Dort wird der alternative Titel "Effective C++ in einer Embedded Umgebung" verwendet.)

Ich hoffe, Sie bei diesem Seminar im Oktober in Stuttgart kennenzulernen.

Scott

Talks in Stuttgart in October

For the dozenth year in a row, I'll be collaborating with QA Systems on a series of one- and two-day technical seminars in Germany in the fall.  (Okay, the first year the seminars were in Switzerland, and, yes, I am aware that Switzerland is not part of Germany.)  This year's talks are:

• Fastware for C++ (2 days)
• Effective C++ in einer Embedded Umgebung (2 Tage)
• Designing and Implementing Effective C++ Classes (1 day)
• Design Patterns, Templates, and Policy-Based Design (1 day)

If the title of the second seminar looks a little funny, that's probably because you're expecting it to be in English.  It's not.  Like the entire seminar, it's in German.  I'll post details about that in a separate posting that will follow this one, although I'll note here that I didn't choose the rather Denglish title above.  The title I use is "Effektives C++ im eingebetteten Bereich."

The seminars with QA Systems are always a lot of fun, with very sharp attendees asking really interesting questions.  I hope to see you at one or more of the talks I'll be giving in Stuttgart in October.

Scott

Registration for C++ and Beyond 2011 is now open!

Herb Sutter, Andrei Alexandrescu, and I will be doing an all-new C++ and Beyond in August in Banff, and registration has just opened.  If you're intrigued by the notion of getting together with some of the most interesting and experienced C++ developers on the planet, discussing how to take advantage of new C++0x language features, and exploring how to attack challenging performance problems, C++ and Beyond is an event I think you'll find worthy of your attention.  I encourage you to check out the C++ and Beyond web site for everything there is to know about the event.

Most of my posts related to C++ and Beyond go to the C&B blog, so if you'd like to follow developments related to C&B, I suggest you subscribe to its feed.

I hope to see you at C&B 2011 in Banff in August!

Scott

Appearing and Disappearing Articles at DDJ

The article I mentioned in my last post ("Appearing and Disappearing consts in C++") is no longer available at the URLs I provided.  In fact, it's not available at the Dr. Dobb's web site at all.  However, the PDF I submitted to DDJ is available through this link, where it will remain. The rest of this post explains why the article briefly flickered to life at DDJ and then vanished. Unless your interest in C++ extends to the process of getting something about it published, you can skip the information that follows.

I can't speak for other authors, but the way I've always worked with publishers on articles can be summarized this way:

1. I send the prospective publisher an idea for an article, a rough draft of an article, or an essentially complete article, and I ask if they are interested in publishing it. If so, we move to step 2.
2. We negotiate a contract for the article.  Generally speaking, I grant them certain publication rights, and they agree to pay me something for them.
3. I deliver a final version of the article, which they then convert into whatever format will be published.
4. They ask me to review the converted article to ensure that no errors were introduced during conversion.
5. The article is published.

In this case, DDJ went directly from step 1 to step 5 after agreeing to publish the article, something they were able to do, because I'd submitted an essentially final manuscript, thus eliminating the need to wait for me to deliver the final copy in step 3. I found out about the publication from a friend of mine some hours after the bits went live.

I contacted DDJ and expressed my concern that they had published without our agreeing on a contract or my being given a chance to review the article for errors.  They sent a proposed contract, and I requested changes.  We went back and forth a couple of times.  They eventually decided that we would be unable to come to agreement, so they removed the article from their site.  I found out about this when somebody posted a comment to that effect to my blog, although DDJ sent official notice some time later.

As an aside, the contract negotiations didn't get hung up on money.  It was more about the kinds of rights DDJ would acquire and who'd have control over the content of the article.

 I'm sorry about the confusion about the article's location, but at least we can enjoy the irony of an article about appearing and disappearing consts itself appearing, disappearing, and now reappearing.  I still  hope you find the article interesting and useful.

Scott

New Article: "Appearing and Disappearing consts in C++"

It's been a couple of years since I got the itch to write a technical article, but I recently found myself thinking about types in C++ and how the language sometimes adds or removes const without your explicitly asking it to do so.  This is especially the case when it comes to new features in C++0x such as decltype and lambda expressions.  The result is "Appearing and Disappearing consts in C++" at Dr. Dobbs.  The normal online version of the article is available here, but I think the formatting they use makes it difficult to read, so I suggest you view the printer-formatted version of the article instead. 

I hope you find the article interesting and the information in it useful.

Scott

Caches and Move Semantics at ACCU in April

I'll be giving two talks at the ACCU Conference in Oxford, England, in April:

•  CPU Caches and Why You Care
•  Move Semantics, Rvalue References, and Perfect Forwarding in C++0x

The ACCU Conference has a great reputation, and based on my experience there last time, I can pretty much guarantee an event that's both technically solid and extremely entertaining. I hope to see you there!

Scott

New Training Course: "Fastware for C++"

I've been working intermittently on a book to be called Fastware!  for the past few years. (You can find information about it at its web site.) That project is currently on the back burner, because I ran into two difficulties.  First, I realized that the scope of the project -- encompassing topics in hardware, systems design, concurrency (both thread-based and distributed), algorithms, data structures, tools for improving performance, and more -- was not only going to be impossible to fit within 300 pages, it was also probably beyond my ability to fully comprehend.  Second, the fact that the book was to be language-independent meant that I'd be unable to push my technical treatments down to the level of detail that I and my readers are accustomed to.

These challenges interfered with my work on the book, but they did nothing to diminish my interest in the production of low-latency software systems, so I decided that a reasonable alternative approach was to take my long-established High-Performance C++ Programming training course, update it to acknowledge the emergence of compilers supporting features from C++0x, and expand it to include selected performance topics beyond C++ and its standard library. The result is a new two-day training course that draws heavily on my original vision for Fastware! while still assuming that C++ is the implementation language:  Fastware for C++.

Fastware for C++ covers hard-core C++ performance-related information such as how to avoid the creation of unnecessary objects and how to use the STL efficiently, but it also covers the impact of CPU caches on data structure and algorithm design, the need to optimize the performance of code you don't control (e.g., third-party libraries), commonly-available concurrent algorithms and data structures modeled on the STL, build-time optimization via profile-guided and whole-program analyses, and more. For details, consult the course's web page, and if you're interested in technical training on low-latency software systems in C++, I hope you'll keep it in mind.

Scott

Updates: C++0x Feature Availability, C++ & Beyond Encore

Two independent announcements that I'm bundling together, because both are short:

• C++0x Feature Availability Table Updated.  In July, I posted that I'd updated my table of C++0x feature availability to include a link to a page summarizing Clang C++0x support.  Recently I discovered that that link is missing.  I can't explain this, but I can fix it, and I have: the link to Clang support is now present.  While I was updating that information, I took the opportunity to update my information for MSVC from Version 10 beta 2 to simply Version 10.  As far as I know, my table is now up to date, but if you see anything that's inaccurate, please let me know.

• C++ & Beyond Encore Seats Going Quickly.  The "encore" version of C++ & Beyond that Andrei Alexandrescu and Herb Sutter and I will be putting on in December is now 1/3 sold out.  There won't be a second encore, and, like the original event that will take place at the end of this month, attendance is strictly limited to 60 spots, so if you've been thinking of attending, I encourage you to register sooner rather than later. (If you're interested in the technical program, talk descriptions are being posted to the C&B blog.)

Scott

Notes from MISRA Day 2010 Talk Now Available

On September 29, Les Hatton and I gave dueling presentations at the 2010 MISRA Day conference.  The exchange was billed as a debate between the two of us, with Les defending C for use in embedded (typically safety-critical) systems and me advocating C++.   As it turned out, Les argued that the choice of programming language is a lot less important than the ability of developers to use it well (a position with which I agree), but I went out and made my case for C++, anyway. 

It was an interesting talk to prepare, because it got me to thinking about very fundamental aspects of C++.  C++ has lots of fancy features, but what are the core features that really make it nicer to program in than C, especially for systems where you know you'll be programming in some kind of "safe" subset?  (MISRA has published guidelines for both C and C++ that are designed to constrain its use to improve its suitability for application in safety-critical systems.)  I ended up spending the biggest part of my time on constructors, destructors, and RAII, although I touched on many other aspects of C++, too.  These days, I spend most of my time focusing on the more advanced C++ features (often the new ones introduced in C++0x), so it was nice to go back and remind myself of some of the key things that distinguished C++ from C at the very beginning (in the early 1980s).

If you're interested in the presentation materials I used at MISRA Day -- at my take on key C++ features that make it more attractive than C for use in safety-critical systems, they're now available for viewing.

Scott

Encore! C++ & Beyond Redux Occurs Dec. 13-16

C++ & Beyond, the sort-of-a-conference-but-not-really that Herb Sutter and Andrei Alexandrescu and I are putting on at the end of October, has been sold out since July, but so many people added themselves to the waiting list, we decided to do an encore presentation in December.  For details, consult the event announcement at the C&B web site.

In the meantime, Herb and Andrei and I just "finalized" and published the C&B technical program, so I encourage you to take a look at the topics we plan to address.  I put "finalized" in quotes, because we always reserve the right to change things.  Officially, the schedule is perpetually in draft form.  Having said that, I don't think any of us expects to make any changes. We just like knowing that if we wake up one day with a brilliant idea for a topic, we have the freedom to displace something else on the (always draft) schedule to make room for it.

I hope to see you at C&B, either in October or in December.  If you're interested in following what's happening in C&B-land, please subscribe to the C&B RSS feed.  Most of my posts that are specifically about C&B appear there.

Scott

Updated C++0x Feature Availability Information

Today I downloaded the TDM distribution of gcc 4.5 for Windows and played around with it a bit.  Part of that playing around including cursory checks to see what new features of C++0x were supported, and I was pleased to see that there were quite a few, including lambdas, raw string literals, and new STL algorithms like all_of/any_of/none_of.  I updated my summary of C++0x feature availability with the new information, and as long as I was at it, I also added a link to C++0x support in Clang, as I'd happened across that page a couple of days ago.

Gcc 4.4 already had a lot of C++0x support, and in conjunction with MSVC 10, which also offers many C++0x features, it was already possible to experiment with lots of C++0x, but with the introduction of gcc 4.5, not only do we have even more of C++0x to play with, but, thanks to gcc's support for lambdas, writing portable C++0x code is now easier than ever.

If you find the revised C++0x feature availability table useful, please spread the word about it.  If you find errors in it, please let me know about them.  Either way, have fun with C++0x!

Scott

PS - Even if you're familiar with Gnu's summary of C++0x support in gcc 4.5, you might want to take a look at my table, because Gnu and I break things down differently.  Gnu's table, for example, makes no mention of alignof, but my table includes it as a line item, which is why I was motivated to see if gcc 4.5 supports it.  It does!