- On May 22, I gave a keynote address at the D Conference on "The Last Thing D Needs." This was a talk about inconsistency issues in C++ and how they make it more complicated to explain the language (and also to understand it).
- On June 4, I gave four presentations at the Norwegian Developers Conference:
- Effective Modern C++, which covers some guidelines from the book I'm currently working on (and about whose progress I'll blog shortly).
- C++ Type Deduction and Why You Care, which also covers information from the book, and which addresses a topic I think is of increasing importance to C++ software developers. (I'll be doing a longer presentation on this topic at cppcon in September.)
- CPU Caches and Why You Care, which is about exactly what the title says it is.
- Better Software — No Matter What: The Most Important Design Guideline, which is about the guideline "Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly," which I really do think is the single most important design guideline in software development. This is an excerpt from my full-day presentation, Better Software--No Matter What, which was so well received at NDC last year, they decided to bring it back at 1/6th full size :-)
Scott
10 comments:
Easy to use correctly and hard to use correctly? I think you're missing an "in" there, Scott.
Yep, fixed, thanks for pointing out the most embarrassing kind of error...
Scott, thanks. Very interesting stuff, as always. Have a good day.
BTW, did you publish the Moscow C++ party video? http://tech.yandex.ru/events/cpp-party/june-msk/talks/1954/
@Timur Safin: I didn't know about this link. Thanks for posting it. I'll add it.
Did you publish your slides somewhere?
@Anonymous: I'll make the slides available for the talk at the D Conference and for the talk at the Moscow C++ Party (look for links to them them by the end of this week at my Online Videos and Past Talks pages), but I think I'm going to hold off on the slides from my NDC presentations, at least for the time being.
Hi Scott - you mentioned something (which I think a lot of developers read & quickly forget) in your talk about auto - the fact that iterating over a map with the construct
for(const pair<K, V>& pair : myMap)
creates a temporary pair (since the real entities in the map are pair<const K, V>). Do you know why compilers don't seem able to optimise this away if you don't use / modify the key? It seems like such an obvious win...
@Anonymous: It seems obvious to humans, but to compilers, myMap contains objects of type T1, and pair is of type T2, and you're asking them to do the analysis to prove that operating on objects of type T1 is the same as operating on temporary objects of type T2 that were initialized by objects of type T1. The optimization is permitted under the as-if rule, and compiler-writers could probably put in special checks in the front end to look for opportunities to use it, but they'd have to ensure that operating on an object of type T1 was the same as constructing an object of type T2, operating on that object, and then destroying that object. To the best of my knowledge, no compiler currently has special checks to see if they can do that.
Scott, many thanks for the swift response and for all the videos - I'm a huge fan of your works and explanations!
mzc
Post a Comment