meetingcpp

For C++ these exist:

ACCU - https://conference.accu.org/site/index.html

Meeting C++ - https://meetingcpp.com (9-11. Nov) not yet announced

ADC - https://adcpp.de/2017/

code::dive (not yet announced) https://codedive.pl/pl/index/

NDC Oslo - https://ndcoslo.com/

Audio Developer Conference:(not yet announced) https://www.juce.com/adc-2016

emBO++ (embedded C++)- https://www.embo.io/

boost::variant is 12 years old, the std::variant version is not based on the actual design nor is it a copy of the boost implementation.

The interface is very similar, but the implementation is ofc using C++17 and not C++03.

Whats holding you back then?

Eric Nieblers Range-v3 library is available:

https://github.com/ericniebler/range-v3/

Its not going to be (much) better in the standard...

Except that it would use real concepts then...

The very first link is a link to the previous part of the series.

Well, they have been accepted into the standard last week ;)

Well, there is progress on all features, yet nothing is ready to go into C++17. So either we get no new standard at all, or we get a Standard without the large features.

Also C++14 was a step forward, generic lambdas are a step forward (boost::hana is based on this, and brings though compile times down), I expect similar language features in C++17, that ease the programming and will bring new innovations to C++.

Your boost argument is only valid for library features. Modules or concepts can never be a part of boost in the way they are in the TS.

Well, boost::filesystem exists for ages...

No, that is not dropped, but it also is not contained in a TS yet, I'm not sure if it gets added to C++17.

There is a wording paper: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p005...

Not sure if Jacksonville will already give green light or if this will be decided later. Would be a good addition though.

If you can, go for C++14 directly, it offers improvements over C++11.

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.

Yes, that is correct. That is not possible, modules might offer things in this direction.

um, nope, not going to happen...

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.

Well, that has been done for decades. You just need to link your code with the correct libraries.

Its probably a bit easier with C as it has a common ABI, and C# as it only has one tool chain, and not multiple toolchains from multiple vendors like C++.

Modules will help here further.

Maintaining boost is incredible hard, as not all authors support their libraries over all the years.

But there is an volunteer group of maintainers which you can join to improve the overall quality of boost.

Its going to be added to the language MAYBE. One of the problems with the first approach was, that it used {}, but did not introduce scope. A serious wtf in any c-like language.

C++0x? This page must be very old...

> Error establishing a database connection

Hm, don't depend on a database when rendering your page? scnr

Eric Niebler is still working on it, see his last blogposts at http://ericniebler.com

2008? There never was a C++08...

Last Standard was 2003 before C++11.

Well, stay away from r-value references[1], and trust the defaults for move will make your live a lot easier.

To Quote Eric Niebler: "I want you to fear r-value references, like one could fear god" (last year at Meeting C++)

[1]except things like forwarding in templates, but thats fairly easy.

Well, of course accessing the value of fh after foo would be fatal. But how would you then sort a container of moveable-only objects?

An object should be accessible for reassigning a value after its move, as its often needed for algorithms, thats exactly why the C++ Standard mandates this. Move does really only make sense if the class holds a moveable allocation, such as a container, array etc., which makes copying expensive.

cpp-next seems to be lost, at least for the web, but you still can access its content at the webarchive.org.