3 ms·
You can do everything you might do in Rust equally as easily in C++. The compiler won't hold your hand, so much, but if you wrap the semantics in a library, an
by ncmncm 6y ago
You can do everything you might do in Rust equally as easily in C++.
The compiler won't hold your hand, so much, but if you wrap the semantics in a library, and use the library, you get the same reliability from it.
(This is an unpopular observation in certain places.)
- floatboth 6y agoThe power of Rust is not in what you can do, it's in what you can't (without the `unsafe` keyword). C++ doesn't have the prevention. If you're not an expert on concurrency, you might just share mutable access to a regular bool variable between threads and use it in that way (as in the article) and nothing would tell you it's wrong. You wouldn't know you need a specific library (or just "to use std::atomic" in this case) until you encounter the weird runtime behavior, try to debug it, try to formulate a google query that describes the bugs/code well enough, and find the answers. "Hand holding" (i.e. rejecting programs that don't conform to more advanced correctness rules) is great. It's what computers are good at. It's foolish not to use computers for this!
- ncmncm 6y ago> C++ doesn't have the prevention Obviously. But that was not the topic. A discipline of single-writer is as easily composed in C++, and, encapsulated in a library, as easily maintained. Nothing about Rust makes this unavailable in C++. The library itself, then, becomes responsible for maintaining the discipline, not the compiler. But once encoded there, it is done. Rust's compiler provides safety advantages, but there is no need to exaggerate them. (Exaggeration is a liability to your language community.)
- adwn 6y ago> [...] if you wrap the semantics in a library, and use the library, you get the same reliability from it. Wrong. Rust offers more tools for checking that your library is used correctly than C++ does. First and foremost, the borrow checker – there is nothing comparable in C++, and it's a lot harder/impossible to statically prevent code from modifying shared data after a mutex has been unlocked, for example. > (This is an unpopular observation in certain places.) It is unpopular because it is factually incorrect.
- ncmncm 6y ago(Knee-jerk reactions do not improve the reputation of your language or of your language community.) A library interface boundary can enforce behavioral restrictions on its clients equally as strong as a compiler's. Clients not handed pointers cannot abuse them. It does demand correctness of the library implementation similar to demands on the compiler. But such correctness in a library formalism is certainly as possible to establish and maintain as in a compiler. Use of wild pointers in other parts of the client could overwrite library data, but that is a different risk than the data races that are the topic here.