Bartek Filipek writes in-depth posts on modern C++ features, covering C++17 and C++20 topics such as variant, SFINAE, and parallel algorithms.
HN commenters recommend it as a great C++ blog that covers each feature at length, plus his C++17 book and survey data on C++ use.
> So you're saying if the code was higher quality it would have fewer bugs? I mean, well, yeah.
That's not what I am saying, at all. You cannot do RAII in C.
My point was that I believe that most of the bugs under discussion here would not have happened if a language that provides RAII capabilities had been used.
> The problem with solutions like RAII is that it doubles down on programmer infallibility, from "good programmers don't write bugs" to "good programmers correctly use RAII."
> You haven't really solved the actual problem unless you have tooling available that won't let non-RAII be checked in at all. Does that exist?
I don't understand what you are trying to say honestly.
If you think that RAII requires the same level of attention and care as manual malloc()/free()/new/delete, then this makes me wonder if you even know what the point of RAII is. Given the same "programmer quality" (for the lack of a better term), the use of RAII will certainly reduce the occurrence of memory mismanagement bugs.
For the tooling, you can use clang-tidy in C++ to enforce the use of smart pointers, make_unique, etc. E.g., see:
https://www.bfilipek.com/2017/12/why-uniqueptr.html
(I am sure there are other static checkers around that can spot the use of manual memory management functions, it's an easy thing to check for).
So, please don't put words in my mouth. The claim was never that RAII gives you the mathematical certainty of the absence of certain classes of bugs. Rather the…
Not all of them, to be sure, lambdas and in particular their capture list syntax is solid. By no means is that universal though, for instance, move semantics.
std::move doesn't move anything, it casts an object as a movable reference (equivalent to static_cast<T&&>). The compiler doesn't preclude you from accessing the old object (or say anything at all) and there's no guarantee it actually did get moved, it's just a hint. That's not real move semantics, it's a shoddy knock-off.
You also have to manage a new constructor, new reference type and the opt-in because the default remains not using move semantics. Worse yet, there's varying agreement on what you can or should do with the source of a moved value, the STL containers will all continue to let you use the old value, it's just empty now. That's not standard behavior because there is none, and it's de facto now because it's in the STL. What a nightmare. [1]
std::variant is supposed to be associated values on enums, but of course, it doesn't do that either. You don't match, you create a new struct with a bunch of operator() methods on it [or overload a lambda?!] and throw it at std::visit. You can only have one variant of each type. Then it throws exceptions if you start mucking about in ways you shouldn't. There's no context. It's dreadful. [2]
[1] http://yacoder.guru/blog/2015/03/14/cpp-curiosities-std-move-that-doesnt-move/
[2] https://www.bfilipek.com/2018/06/variant.html
Having started using the Internet in the 90's, and thus still remembering Geocities-era websites, I loved that they did this as a webring (https://en.wikipedia.org/wiki/Webring): each blog post has a link to the next one, making a singly-linked circular list.
Starting with this one, we have:
- http://www.bfilipek.com/2018/04/deprecating-pointers.html
- http://www.modernescpp.com/index.php/no-new-new
- https://www.fluentcpp.com/2018/04/01/cpp-will-no-longer-have-pointers/
- https://blog.tartanllama.xyz/no-pointers/
- https://arne-mertz.de/2018/04/raw-pointers-are-gone/
And it circles back to this one.
Should be noted that so far only Visual Studio (partially) implements C++17 parallel algorithms, although there are several third-party implementations.[1]
Apples to oranges comparison of course, since Rayon isn't [planned to become?] part of the Rust standard library.
[1] http://www.bfilipek.com/2017/08/cpp17-details-parallel.html#current-implementation
According to most surveys, they aren't used as much on real life.
Here 14%, https://www.jetbrains.com/lp/devecosystem-2019/cpp/
Here 40 - 55%, https://www.bfilipek.com/2019/12/cpp-status-2019.html
At CppCon 2015 or something, at Herb's question during his keynote, about 1% of the audience as per his comment on the video.
> You have std::variant and std::visit. https://www.bfilipek.com/2018/09/visit-variants.html
Which isn't a true sum type because it doesn't nest properly.
> Or you can use a library: https://github.com/mpark/patterns
Interesting; proper pattern-matching is nice, but the lack of type safety is still a major issue.