This is moving fast, a moratorium for some time would be beneficial for community. Like the one that happened in Python sometime ago.
https://en.wikipedia.org/wiki/Java_version_history
https://en.wikipedia.org/wiki/C_Sharp_(programming_language)...
"C++ use is on the increase. We need to improve C++ to sustain the momentum, not better serve the C++ programmers, not out of fear of competition."
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n449...
It was probably intended to be "..., to better serve the C++ programmers, ...". That would provide a contrast for the final "not" to be operating on.
"We need to improve C++ to sustain the momentum and to better serve the C++ programmers, not out of fear of competition."
The accidental repetition of not is not an unusual mistake, and the original sentence doesn't match the tone of the previous paragraph given that he says "I deem something 'major' or 'minor' based on what it does for users"
C++ did that in the 2000's, in that time there wasn't much news about standardization, because of this C++ was seen as legacy, people moved to other languages. The new languages such as Rust, Go etc. are also a result of this.
The C++ committee has now a process of ongoing standardization established, which will improve the language further, and make it easier and more efficient to write C++. Also, the standards are usually backward compatible for at least 2 standards. What gets removed is often obscure features like auto_ptr, random_shuffle etc. which are superseeded by better alternatives. Clang modernize can even get your code base automatically updated to a new standard.
I know, that some of you are left behind, as you are stuck with the traditional "almost never update the toolchain" model, but clang and other tools are such a leap forward, that this is not a model for the future anymore.
So, C++ ecosystem evolves to become better, and make you as a programmer more productive and lets you write easier and safer code.
Language features that ease your daily working with C++11/14:
- Lambdas, especially when working with <algorithm>
- ranged for loop
- auto instead of typing long types
- variadic templates increase compilation speed over the previous macro based simulation of this feature.
- the basic support for multithreading which std::thread & co offer.
And also, as always in C++: you only pay for what you use. You still can write code in old styles pretty well with C++14, same will be true for coming standards.
If your last exposure to C++ featured nothing but raw pointers, you should really give it a second look.
C++17 is the first "big" standard change since C++11. It will likely be followed by a small bug fix revision, analogous to C++14, a couple of years later.
C++14 had relaxed requirements on constexpr, initializers in lambda captures, using auto for return type deductions, and a few other small tweaks.
struct Foo {
int i;
float f;
bool b;
// No constructor
};
std::make_unique<Foo>(1, 2.3f, true);
It also doesn't work when Foo's constructor is private, even when called from a function that would have access to this private constructor.
And this is my beef with C++: Yes it's powerful, and I quite like it, but you sooner or later hit these speed bumps that unnecessarily complicate things.