average c++ dev
-
"C++ compilers also warn you..."
Ok, quick question here for people who work in C++ with other people (not personal projects). How many warnings does the code produce when it's compiled?
I've written a little bit of C++ decades ago, and since then I've worked alongside devs who worked on C++ projects. I've never seen a codebase that didn't produce hundreds if not thousands of lines of warnings when compiling.
Ideally? Zero. I'm sure some teams require "warnings as errors" as a compiler setting for all work to pass muster.
In reality, there's going to be odd corner-cases where some non-type-safe stuff is needed, which will make your compiler unhappy. I've seen this a bunch in 3rd party library headers, sadly. So it ultimately doesn't matter how good my code is.
There's also a shedload of legacy things going on a lot of the time, like having to just let all warnings through because of the handful of places that will never be warning free. IMO its a way better practice to turn a warning off for a specific line.. Sad thing is, it's newer than C++ itself and is implementation dependent, so it probably doesn't get used as much.
-
100%. In my opinion, the whole "build your program around your model of the world" mantra has caused more harm than good. Lots of "best practices" seem to be accepted without any quantitative measurement to prove it's actually better. I want to think it's just the growing pains of a young field.
Even with qualitative measurements they can do stupid things.
For work I have to write code in C# and Microsoft found that null reference exceptions were a common issue. They actually calculated how much these issues cost the industry (some big number) and put a lot of effort into changing the language so there's a lot of warnings when something is null.
But the end result is people just set things to an empty value instead of leaving it as null to avoid the warnings. And sure great, you don't have null reference exceptions because a value that defaulted to null didn't get set. But now you have issues where a value is an empty string when it should have been set.
The exception message would tell you exactly where in the code there's a mistake, and you'll immediately know there's a problem and it's more likely to be discovered by unit tests or QA. Something that's an value that's supposed to be set may not be noticed for a while and is difficult to track down.
So their research indicated a costly issue (which is ultimately a dev making a mistake) and they fixed it by creating an even more costly issue.
There's always going to be things where it's the responsibility of the developer to deal with, and there's no fix for it at the language level. Trying to fix it with language changes can just make things worse.
-
Have you heard about cve-rs?
https://github.com/Speykious/cve-rs
Blazingly fast memory failures with no unsafe blocks in pure Rust.
Edit: also I wish whoever designed the syntax for rust to burn in hell for eternity
Edit 2: Before the Cult of Rust
sends their assassins to take out my family, I am not hating on Rust (except the syntax) and I'm not a C absolutist, I am just telling you to be aware of the limitations of your toolsSo now we're considering bugs in the compiler as bugs in the language?
-
So now we're considering bugs in the compiler as bugs in the language?
wrote on last edited by [email protected]A) Rust doesn't have a formal specification other than "whatever the fuck our team hallucinated in this compiler version"
B) Doesn't matter the definition if it fucks your day because you're not careful.
Sure sure Heil Rust but be mindful of the fuck you're doing before you get bit ¯\_ (ツ) _/¯
-
We need to stop attaching shit someone doesn't say to something they did. It makes commutating hostile and makes you an asshole.
Edit: okay that was a bit rude. But it's so frustrating to say something and then have other people go "that means <this other thing you didn't say>!!!11!"
wrote on last edited by [email protected]I understand your frustration and I apologize for reading into your comments something you didn't mean. I, too, wish people would say what they mean and mean what they say, and that when you say something its taken to mean what you said.
Unfortunately very often people will make a very reasonable (even factually true) point as a preamble to support something very unreasonable. If you agree with the reasonable point the person will then act like you agree with the unreasonable one. This is not only more time consuming and tiring to argue against, it also lends a great deal more credibility to the unreasonable point than it is really owed. To the uninformed reader to looks like the two sides of the argument partially agree, when nothing could be further from the truth. Its immensely frustrating to have your words used against you like this, so many people try and preempt it by jumping straight to (what they assume to be) the unreasonable point and arguing against it directly.
This is toxic for actual discussion. It means that good faith actors have to add all sorts of qualifications and clarifications about where they stand before they say anything about anything, which is tiring in itself. But its the world that we live in. If someone makes an unqualified comment about the CO2 emissions of volcanoes in a thread about anthropogenic climate change people are going to assume that they don't think climate change is real. And, operating that way, those people will be right more often than they're wrong.
-
Have you heard about cve-rs?
https://github.com/Speykious/cve-rs
Blazingly fast memory failures with no unsafe blocks in pure Rust.
Edit: also I wish whoever designed the syntax for rust to burn in hell for eternity
Edit 2: Before the Cult of Rust
sends their assassins to take out my family, I am not hating on Rust (except the syntax) and I'm not a C absolutist, I am just telling you to be aware of the limitations of your toolsYeah, and that falls under the first category, bugs in the compiler: https://github.com/rust-lang/rust/issues/25860
(All exploits in that repo are possible due to that bug.)
-
Yeah, and that falls under the first category, bugs in the compiler: https://github.com/rust-lang/rust/issues/25860
(All exploits in that repo are possible due to that bug.)
Yeah and those are the ones currently identified (btw that issue isn't completely fixed) because rust never was nor advertised itself as sound. Meaning, you gotta be careful when writing Rust code too. Not as much as C++, but it's not a magical shield against memory problems like people have been shilling it as.
-
A) Rust doesn't have a formal specification other than "whatever the fuck our team hallucinated in this compiler version"
B) Doesn't matter the definition if it fucks your day because you're not careful.
Sure sure Heil Rust but be mindful of the fuck you're doing before you get bit ¯\_ (ツ) _/¯
wrote on last edited by [email protected]Rust doesn’t have a formal specification other than “whatever the fuck our team hallucinated in this compiler version”
That's simply not true. The Reference, while not an ISO-style formal spec, does actually specify most of the intended language behavior, and incrementally approaches completion over time. But even if you insist on an ISO-style formal spec, there's Ferrocene: https://ferrous-systems.com/blog/the-ferrocene-language-specification-is-here/
it fucks your day because you’re not careful
The
cve-rsvulnerability is actually not really something you'd ever write by accident. Also note that the bug report has multiple versions because, even though a "full" solution is pending some deeper compiler changes, the firsttwothree versions of the exploit are now caught by the compiler. So, like I said, the compiler bugs do get fixed over time. -
"C++ compilers also warn you..."
Ok, quick question here for people who work in C++ with other people (not personal projects). How many warnings does the code produce when it's compiled?
I've written a little bit of C++ decades ago, and since then I've worked alongside devs who worked on C++ projects. I've never seen a codebase that didn't produce hundreds if not thousands of lines of warnings when compiling.
0 in our case, but we are pretty strict. Same at the first place I worked too. Big tech companies.
-
I mostly see warnings when compiling source code of other projects. If you get a warning as a dev, it's your responsibility to deal with it. But also your risk, if you don't. I made it a habit to fix every warning in my own projects. For prototyping I might ignore them temporarily. Some types of warnings are unavoidable sometimes.
If you want to make yourself not ignore warnings, you can compile with
-Werrorif using GCC/G++ to make the compiler a pedantic asshole that doesn't compile until you fix every fucking warning. Not advisable for drafting code, but definitely if you want to ship it.Except when you have to cast size_t on int and vice versa (for "small" numbers). I hate that warning.
-
Structs with union members that allow the same place in memory to be accessed either word-wise, byte-wise, or even bit-wise are a god-sent for everyone who needs to access IO-spaces, and I'm happy my C-compiler lets me do it.
#pragma push
-
That what comments and documentation are for.
A yes, comments.
int flubTheWozat(void *) { for (int i=0; i<4; i++) { lfens += thzn[i] % ugy; // take mod of thnz[i] with ugy and add to lefens. } return (lfens % thzn[0]) == 4; // return if it's 4ish } -
Ideally? Zero. I'm sure some teams require "warnings as errors" as a compiler setting for all work to pass muster.
In reality, there's going to be odd corner-cases where some non-type-safe stuff is needed, which will make your compiler unhappy. I've seen this a bunch in 3rd party library headers, sadly. So it ultimately doesn't matter how good my code is.
There's also a shedload of legacy things going on a lot of the time, like having to just let all warnings through because of the handful of places that will never be warning free. IMO its a way better practice to turn a warning off for a specific line.. Sad thing is, it's newer than C++ itself and is implementation dependent, so it probably doesn't get used as much.
I've seen this a bunch in 3rd party library headers, sadly. So it ultimately doesn't matter how good my code is.
Yeah, I've seen that too. The problem is that once the library starts spitting out warnings it's hard to spot your own warnings.
-
I've seen this a bunch in 3rd party library headers, sadly. So it ultimately doesn't matter how good my code is.
Yeah, I've seen that too. The problem is that once the library starts spitting out warnings it's hard to spot your own warnings.
Yuuup. Makes me wonder if there's a viable "diaper pattern" for this kind of thing. I'm sure someone has solved that, just not with the usual old-school packaging tools (e.g. automake).
-
So, did you get it down to 0 warnings and manage to keep it there? Or did it eventually start creeping up again?
I'm not the person you're asking but surely they just told the compiler to treat warnings as errors after that. No warnings can creep in then!
-
A yes, comments.
int flubTheWozat(void *) { for (int i=0; i<4; i++) { lfens += thzn[i] % ugy; // take mod of thnz[i] with ugy and add to lefens. } return (lfens % thzn[0]) == 4; // return if it's 4ish }Haha, meaningful, informative comments that make it easier to understand the code of course.
-
"C++ compilers also warn you..."
Ok, quick question here for people who work in C++ with other people (not personal projects). How many warnings does the code produce when it's compiled?
I've written a little bit of C++ decades ago, and since then I've worked alongside devs who worked on C++ projects. I've never seen a codebase that didn't produce hundreds if not thousands of lines of warnings when compiling.
I put -Werror at the end of my makefile cflags so it actually treats warnings as errors now.
-
Even with qualitative measurements they can do stupid things.
For work I have to write code in C# and Microsoft found that null reference exceptions were a common issue. They actually calculated how much these issues cost the industry (some big number) and put a lot of effort into changing the language so there's a lot of warnings when something is null.
But the end result is people just set things to an empty value instead of leaving it as null to avoid the warnings. And sure great, you don't have null reference exceptions because a value that defaulted to null didn't get set. But now you have issues where a value is an empty string when it should have been set.
The exception message would tell you exactly where in the code there's a mistake, and you'll immediately know there's a problem and it's more likely to be discovered by unit tests or QA. Something that's an value that's supposed to be set may not be noticed for a while and is difficult to track down.
So their research indicated a costly issue (which is ultimately a dev making a mistake) and they fixed it by creating an even more costly issue.
There's always going to be things where it's the responsibility of the developer to deal with, and there's no fix for it at the language level. Trying to fix it with language changes can just make things worse.
For this example, I feel that it is actually fairly ergonomic in languages that have an
Optiontype (like Rust), which can either beSomevalue or no value (None), and don't normally havenullas a concept. It normalizes explicitly dealing with the None instead of havingnullor hidden empty strings and such. -
I don't know which is worse. Using C++ like lazy C, or using C++ like it was designed to be used.
An acquaintance of mine once wrote a finite element method solver entirely in C++ templates.
-
I suppose it's a matter of experience and practise. The more you wotk with it the better you get. As usual with all things one can learn.
The question becomes, then, if I spend 5 years learning and mastering C++ versus rust, which one is going to help me produce a better product in the end?
