It's also worth noting that 'winter' used to be monthless in the Roman calendar, so there were 10 months, ending in December (so all of the number names make sense) and then a big blob of 'winter' before the new year started.

As somebody who attended this conference, and hadn't had much exposure to C++11 features outside of 'auto', my personal biggest takeaway from almost every talk was this: Stop passing your sink variables as const refs.

That is to say if you have a constructor:

  MyClass::MyClass(const std::string& s) : m_s(s) {}

That you call like:

  std::string s = "Some string";
  MyClass c(s);

You're hamstringing the compiler into always copying that string instead of being able to use the new move semantics, because it can't mess with the guts of a const reference. Instead, do the previously unspeakable evil of passing by value and then moving, e.g.

  MyClass::MyClass(std::string s) : m_s(std::move(s)) {}

This lets the compiler know that if string has a move constructor, and is an rvalue, it can just move the guts into place instead of performing the copy, since the variable is 'sunk' into the new location. Huge wins all around.

Is the std::move call really necessary? It's a little sad if the compiler can't see that s is already an rvalue.

Once things have a name and you can take their address they are no longer an rvalue. It would require a much more sophisticated type system to do this automatically (when you pass a reference to another function, does it capture it?). It would also be non-obvious when you were moving. Think of Java style escape analysis vs C++ stack allocation (implicit vs explicit). There is one case where the compiler will do this though, when you return a stack allocated value from a function, it is implicitly moved.

The argument here is that in the body of the constructor the developer probably doesn't use s, so a trivial analysis of the function can say "oh, it doesn't matter if I destroy s, so in the one place where it is used I'll just move it". It doesn't then matter if it is obvious it happens or not, because the semantics of the program wouldn't be maintained (and honestly, I'd argue it is never quite obvious when what happens in different contexts given the large number of rules involved: you kind of just have to have some trust).

There are a number of considerations because the compiler can't prove it in general without augmenting the type system or doing whole-program analysis.

Do you allow, but not require, the compiler to do this substitution whenever it can prove a value is never used again? This is unreliable across build options and compilers so it would be unwise to depend on it. There is an opportunity here for a tool that could identify places where you could insert move, perhaps even a -W option for the trivial cases such as above, but I am not convinced the language should allow the compiler to do this.

Do you make it mandatory and add more special cases for the compiler to have to implement? This would require the compiler to track references to make sure they don't get passed to some other function. It would need someone to codify the special cases in the standard and this might be very difficult. It would also be fragile, there would be cases where implicit move used to kick in but some added function call inhibits it even though a move is still the right thing to do.

You seem to be assuming that optimizations are only of value if they can be depended on happening consistently as a defined property of the language on every single platform for which there exists a compiler: in practice, compilers perform numerous optimizations (such as static branch prediction) that only work probabilistically even for the case of a specific version of a specific compiler on a specific operating system; I know of very few people (maybe you are one of them, however) who consider this to be a detriment. For a more obvious comparison: yes, I could sit around constructing object pools in my Java program to avoid heap allocations and their associated garbage collection penalty, but if rudimentary escape analysis manages to pick up a lot of the value, even if "fragile" or nondeterministic, I might not need to spend the time anymore to worry about that kind of detail in my software as the cost benefit analysis shows that the toolchain is now a more efficient usage of resources towards that issue (I could be spending my energy working on algorithm design, for example, instead of object pools). As long as the semantics of the language support the optimization, and as it doesn't seem to be difficult to implement, it would be useful to have the compiler perform this optimization for the developer, and one would expect such an optimization to either already be there or be "in the works".

This is a very different kind of optimization than the other things you are talking about. This is something that is operating at a high level and potentially has implications that might not be obvious. You are changing the type of something and effecting the function overloads which are resolved. I think its important for what functions you are calling to be deterministic. My previous post was just touching on what possible value can be gained from allowing this and my conclusion is that it would be very little.

Also, your example of escape analysis is precisely because Java doesn't allow you to express what you are wanting to do, whereas C++ does allow you to express moves.

edit: I would compare this to C++'s copy elision, but that has a very high value and is much less intrusive.

I guess considering a user defined move constructor could do something arbitrarily stupid you have to be consistent.

Also, any function can be overloaded on rvalue references.

s isn't an rvalue. It has a name, and you can refer to it within the body of the constructor.

I understand that, but it's clearly not used in the body. I was hoping it would be a legal and implemented optimization.

move calls strike me as ugly and kinda dangerous. What if you do wind up wanting to refer to s in the body later on? It'd be nice if the compiler just handled it.

> What if you do wind up wanting to refer to s in the body later on?

Then copy s, don't move it.

The point is move makes things that look like values as annoying as pointers. You have to keep track.

I'll buy that.

I'm confused as to why you think the code presented in the blog post isn't an example of 'the same functionality implemented some other way'. The await code is almost undeniably more straightforward and the exceptional cases more obvious to handle.

He also doesn't seem to be making a weird logical leap the way you claim he is. He's not really using an analogy. He's saying callbacks are bad the same way goto is bad, in that they make the logical structure of a program's execution non-obvious, particularly over time and when being modified.

I'm not saying the await syntax isn't useful or a better way to implement that problem. The title and opening of the article is comparing callbacks with gotos. It would be logical if he titled the article "C# Await syntax trumps callbacks when multiple callbacks need to be synchronised".

Any syntax can be used to create spaghetti code. Callbacks only become spaghetti like when nested / chained / abused. I've written hundreds of API methods using callbacks that I believe are very clean. I've recently written a large API which makes async service calls that follows this pattern :

void GetInvoiceHistory(int? customerId, Action<List<InvoiceItem>> callback, Action<string, Exception> exceptionCallback);

The consumer of this API does not need await, there is no need to nest callbacks, there is no need for try/catch and it is very clean to work with. So IMHO, stating that callbacks are this generation's gotos is a pile of shit.

This is the link, for reference: https://news.ycombinator.com/item?id=6033567

Pedantic and tangential, but in your example, the statement would still be incorrect, as a revocable right is, by definition...well, alienable.

That's kind of the point. You can't argue that a specific right is not inalienable just because a process exists by which it could be denied, unless your point is to argue that no rights can ever be inalienable, or that no power can ever be unaccountable, etc.

We say that someone is unaccountable when the process required to lead to their accountability subsequent to misbehavior is in practice not likely to occur, not when the absolute lack of accountability can be proven with mathematical rigor.

This is the same pedantry that leads engineers to come up with crazy legal arguments. The fact that velocity is relativistic and relative to an external observer not subject to the rotation of the Earth your vehicle was not exceeding the speed limit is not going to get you out of a speeding ticket, no matter how many times you argue that it's technically correct. Because when people say things they do so within an accepted context that doesn't include the sort of pedantic absolutism that would cause arbitrary good faith statements made in the course of normal conversation to become technically inaccurate when weighed against impossible standards.

Any "right" can be revoked by someone with a bigger gun.

My question is: Once the truck is stopped in front of the sign, presumably with traffic backed up behind it...how do they get it out?

Not really the case here because the article specifically calls out what happened, but it can't really be the case that the name of the blog or site should play NO role in determining defamation, right?

If I run a blog called "Murderer Watch: Keeping an Eye on Murderers and Things" and I post "Bob Jones is 34 and lives in Atlanta, GA," that can't be totally okay just because those are all factual statements, right?