Hacker News Reader

Comment by moralestapia | Hacker News Reader

I was once made fun of (in a kind of humiliating way, now that I recall) by a bunch of HPC scientists in a room at KAUST for saying that C++ had support for GC.

They were like "if you knew the least bit a about C++, you'd knew it doesn't have a GC".

I was like, "yeah cool, but C++ does have some GC functionality", but they just shut me down. My background is Biology so there were a few remarks about how "a biologist just doesn't know these things, lol".

This was around 2019, btw. And sure, I'm a biologist, but I also happen to have spent 8-10 hours/week for the past 20 years coding because I just really like it; so, there's my 10k hours, ¯\_(ツ)_/¯.

View on HN

So far as I can see, this was in the C++ spec but not implemented by any major compiler, though. So I guess the technical answer to “who’s right?” would depend on the verbiage of the discussion. :shrug:

(But regardless, that sounds like a toxic environment and I’m glad you’re out of there. To think that because someone has a degree in biology, that automatically precludes them from knowing anything about computers or programming that you don’t is just the epitome of arrogance and hubris.)

I'm kind of surprised they didn't try to get rid of/adapt the standard for C++/CLI on Windows since it actually uses GC for a lot of things. However, I guess the standard wasn't all that useful, especially since it mandated a lot of overhead for pointer arithmetic. My theory is that it is very difficult to come up with a general API for interacting with GC'd memory in C++ because making the API efficient depends heavily on how it is implemented.

Yeah that is the thing, Unreal C++, C++/CLI, and COM/WinRT frameworks, are the main users of automatic memory management in C++ dialects, and none of them was taken into consideration.

If it came to that it's time to whip out the technically right big dick and remind them that C++ has had smart pointers since forever and that TRACING garbage collection is far from the only automatic garbage collection technique known to man. ;)

C++ has had conservative tracing garbage collection since forever; GCC is garbage collected and you can use Boehm gc.

Some of the best programmers I've worked with have backgrounds in sciences, and it's been a delight just being around them as they apply some of that knowledge in in a different field.

That kind of blatant ass-holery is really common in C++ circles and you even see Bjarne doing it.

"I understand what you are trying to say and I think you are wrong" at a conf to delighted razzes and jeers from the room. Bjarne had seemingly just discovered that link lists thrash cache and was presenting about swapping in a vector instead. Note it's got nothing to do with whether this guy is onto something or not. It is possible to disagree without being an asshole. Bjarne missed the opportunity. C++ culture follows.

https://youtu.be/SfkMiGFVhZo?si=pd36kbm9FFoKFuKm&t=4111

IMHO it is unsurprising there's a lot of groupthink involved in such a culture and it has really damaged the language and certainly makes it unpleasant in the way you describe.

Bjarne is right, the guy is wrong, full stop. If you don't care about performance, then don't worry about performance. Use std::list if you like, and don't complain about it.

Ultimately, we write programs to make machines do things. What we write exactly determines what the machine does. It is our responsibility to understand what we write makes the machine do; otherwise it won't do what we wanted. Often (maybe almost always nowadays) the performance details don't matter much. When they do matter, there is no substitute for understanding.

The Standard data structures are constructed simply, with understandable performance characteristics, imposing minimal overhead both in time and code space. This is an extremely important quality not to sacrifice idly. No one is obliged to use only the Standard containers; if you need something different, you can write something different yourself, or even find it online somewhere. You are encouraged to write something yourself, and maybe publish it. People do.

In a very real sense, the Standard containers are just examples. Making them unnecessarily complicated would make them worse examples, and would make them worse for almost all places they are used.

I think you may have missed the point of my raising that fwiw. I genuinely don't care who is right [1]. Bjarne's attitude and manner is very wrong and very normal amongst c++ people. That's a shame. He could have explained his point of view forcefully, without being a jerk. Bjarne made his choice.

Maybe it's why there have been so many terrible decisions in C++ over the years because being an asshole and right might scare off discussion but it doesn't make even Bjarne infallible.

[1] If you care about performance you take full responsibility for all code used including all libraries like the stl, which might well mean you don't use the stl and vector and write something optimised for your specific purpose, and not for every possible purpose. But I don't want to be an ass about saying it.

For someone for whom English is a second language, what was wrong with his statement ? For a non-native English speaker it seems expressing disagreement is becoming more and more difficult and complex.

Indeed, the usual we need to talk like radio censorship on US.

Nothing Bjarne says would be censored on NPR. Being a jerk is totally allowed and should be. As is pointing it out.

I can explain why I disagree with you. Or I can put you down for not already understanding and agreeing with my point before I do that.

He is not a jerk. He explained his point clearly, concisely and respectfully, without wasting the time of the next person with a question. Making people into jerks because you don't like their answers, you find yourself surrounded by jerks. Then who's really the jerk?

He explains, "People have not figured out how to automate picking data structures optimally relative to their use in a program". In other words, the guy asked for something impossible. Bjarne was as diplomatic as was possible while still answering the question accurately.

"I think I understand what you are trying to say and I think that you are wrong."

The giveaway is the hoots and razzes from the crowd. No word above needed saying. It clarified nothing. It is pure assholery. (And he may not have even intended it. Clearly lots of c++ people have no issue with just how unpleasant community interaction is compsred other communities. It's also pretty obvious that many do see it plainly).

Here is Microsoft's implementation of map in the standard library. I think of myself as a competent programmer / computer scientist. I couldn't write this: https://github.com/microsoft/STL/blob/f392449fb72d1a387ac502...

I think you mean to say that you couldn't afford to devote the time to making a map that Microsoft did. Generally, in C++ we get to use data structures that have had far more attention to every detail than we could apply personally because they are used by many more than just us. Microsoft's gets used by everybody who uses their compiler, and so commands attention. It probably deserves more than Microsoft actually spends, but that is a management problem.

So definitely don't use it if you care about performance? (You can't write it, but anywhere you'd use it you can probably beat it). But we're getting into discussion of sensible benchmarking of actual deployable applications so let's leave that for another time.

> delighted razzes and jeers from the room

To me it sounded more like a reaction to Bjarne phrasing himself in an unexpected way, much like you'd laugh at a joke. But I regardless do agree that it's inappropriate to laugh at a sincere question. And as an extension to that, it would have been better if Bjarne's first sentence wasn't phrased as a joke.

But I don't think there's any issue with plainly stating that you think the asker is wrong, or with the rest of Bjarne's response. Of course, I'm not a native speaker.

>But I don't think there's any issue with plainly stating that you think the asker is wrong

I completely agree with that.

You have to arm yourself with facts.

- know exactly what you mean by "C++ has support for garbage collection"

- have the chapter-and-verse citations from ISO C++ ready if someone disagrees

- understand the limitations of what is required in the document, and be the first to point that out

- and have a good idea of some of the landscape in terms of what of those requirements is implemented in the wild

How about you stop caring that much about proving others right.

He cares about proving others wrong...

Thats just a good approach to being well versed on a topic, it doesn't have to be for adversarial situations only

That goes against the entire premise of C++ developers mindset.

You mean proving others wrong?

In this situation, those others were not exactly wrong. It was about OP proving also not being wrong.

If people in your organization think you said something stupid, that could be bad for your opportunities there.

If you say something which is correct, but the correctness depends on some unusual conditions that are not well known, or special interpretations of common concepts, or some context that is not shared with whoever you're talking to, you have to either not mention that, or spell out those details.

If you posit that pigs do fly, don't forget the detail that it's when they are shot out of a cannon.

tbqh kazinator is manifesting the bare minimum of Caring to be trusted with C++ code as a developer. If you aren't prepared to get into bizarre pseudo-legal arguments with collaborators about language specifications you are going to be happier somewhere else in the software industry.

I do not say this as someone who believes this represents healthy behavior or that wants to write C++ for a living. They've been like this since #C on EFNet and FreeNode were a thing 30+/25+ years ago. My guess is they got the behavior from Usenet or something but I didn't hang out there so I don't know first-hand.

He was fighting social proof. Because they viewed him as an outsider no amount of facts will convince them. They won't take his word for it and they won't spend the time verifying his facts.

Been there many times. Including when a room full of programmers laughed at me for suggesting randomizing a list prior to using quick sort because "it messes up the big Oh complexity"

(Yes yes I know there are simpler ways to handle quick sort attacks but that wasn't why they were laughing)

> Because they viewed him as an outsider no amount of facts will convince them.

I am not able read that into the anecdote presented in the original comment.

They all but said it in the original comment:

"My background is Biology so there were a few remarks about how "a biologist just doesn't know these things, lol""

That sucks, those people sound like grade A assholes.

lol, we all want those things in the moment.

There are so many arguments that I could have won, if I had just had an evening to mull it over.

I'm reminded of the movie Annie Hall where Woody Allen is waiting in line...

    Alvy: [Hearing a man behind him rambling about Marshall McLuhan]
          What I wouldn't give for a large sock with horse manure in it.
          [Turns to the camera] What do you do when you get stuck in a
          movie line with a guy like this behind you? It's just...maddening-
    Man in Theatre Line: [Notices Alvy and walks up to him] Wait a minute,
          why can't I give my opinion? It's a free country!
    Alvy: Did-did he, he can give you- Do you have give it so loud? I
          mean, aren't you ashamed to pontificate like that? And the
          funny part of it is, Marshall McLuhan; you don't know anything
          about Marshall McLuhan!
    Man in Theatre Line: Oh really, really? I happen to teach a class at
          Columbia called "TV, Media, and Culture." So I think that my
          insights into Mr. McLuhan, well, have a great deal of validity!
    Alvy: Oh, do ya? Well, that's funny, because I happen to have Mr. McLuhan
          right here, so, so, yeah, just lemme lemme lemme — [pulls McLuhan
          from behind a nearby poster stand] — Come over here for a second.
          Tell him!
    Marshall McLuhan: I heard what you were saying. You know nothing of my
          work. You mean my whole fallacy is wrong. How you ever got to
          teach a course in anything is totally amazing.
    Alvy: [To the camera] Boy, if life were only like this!

I think the parent commenter is being ironic to some degree

But if you're the one starting the argument, then you have all time in the world to mull over the proper defense of that argument. Weeks, months, years ... There is no need to regret anything. Especially in a matter that isn't even an argument but basically just conveyance of facts from the public record.

I would probably agree with those scientists, this seems like a “well actually” kind of gotcha claim with no practical significance when there is no usable implementation of this.

I think the main issue with those folks wasn't if/how they're right, but rather how they treated the commenter.

This.

The thing was so obscure that even seasoned people who have worked with this for many years didn't know about it.

I guess the takeaway is to stay humble because you never know what you don't know.

And more specifically, never get into arguments about what C++ can do because it’s guaranteed that someone has used it the way you assume it should never be used.

They probably totally forgot the conversation only seconds later, and did not intend humiliation or perceive any humiliation. He said something not usefully correct for the circumstances under discussion, and was corrected without fuss.

Then he carried a grudge.

There is one.

https://hboehm.info/gc/

From Bjarne's website:

> If you want automatic garbage collection, there are good commercial and public-domain garbage collectors for C++. For applications where garbage collection is suitable, C++ is an excellent garbage collected language with a performance that compares favorably with other garbage collected languages. See The C++ Programming Language for a discussion of automatic garbage collection in C++. See also, Hans-J. Boehm's site for C and C++ garbage collection.

> Also, C++ supports programming techniques that allows memory management to be safe and implicit without a garbage collector. I consider garbage collection a last choice and an imperfect way of handling for resource management. That does not mean that it is never useful, just hat there are better approaches in many situations.

> C++11 offers a GC ABI.

https://www.stroustrup.com/bs_faq.html#garbage-collection

It seems few remember the days when Java put so much pressure on C++ that Bjarne S was very much trying to find a way to provide GC for those who wanted it. In 2023, the folks wanting GC are all using those languages, and it's assumed C++ is anti-GC.

It is shocking how groups can create an environment of being proudly wrong. Once you see the pattern, you see it everywhere.

Hahaha, how can that guy be so stupid as to think the world isn't flat? Easy to see in hindsight, but it happens with everything (programming language a vs b, OS A vs B, etc).

Groupthink is strong and even the people who agree with you might find themselves not pointing it out.

Yeah it's like saying that Linux has support for case insensitive paths or that Windows supports forwards slashes in paths.

People with some limited amount of knowledge will quickly tell you that you are wrong, but it is them who are wrong. Many don't even give you the little benefit of the doubt to do a small internet search, and yeah the problem is worse when you are an "outsider" in some sense.

It's like when you say Java has a GOTO. It's in bytecode, in the language as a reserved word, and has a rarely used partial implementation vis-a-vis label: https://www.geeksforgeeks.org/g-fact-64/ Ultimately, thankfully, it never got made into a real keyword.

>Ultimately, thankfully, it never got made into a real keyword.

Why "thankfully"?

canonically: https://homepages.cwi.nl/~storm/teaching/reader/Dijkstra68.p...

but see also 50+ years of back and forth on that subject, other opinions available.

This paper was written in the times where goto was way more powerful than current goto, wasn't it?

I'm guessing you never had to debug spaghetti non OO code that used GOTO or you'd not be asking that question :D

OO is a lot of things to a lot of people, but it's not "structured control flow".

What's difference between debugging spaghetti non OO code from debuggin spaghetti abused OO code?

both are terrible mess to debug, yet we aren't calling out ppl using (or even abusing) OOP

Nothing from my POV. GOTO is more necessary (or even required) in procedural non OO languages because of fewer constructs to support modelling or structure. The OP mentioned redundant features, and in OO GOTO is redundant.

Maybe you were technically right for some small scope of the problem, no proper industry definition of GC was supported by C++ by any of the major compiler. So, the HPC scientists were right imo.

Being technically right for an aspect that doesn't matter is a common trope that a lot of software engineers fall for.

It's not just you and not just biologists. I've had engineers with 20+ years of experience tell me that fixed width types don't exist in C++

Presumably 20+ years of experience somewhere far away from C++.

Doubtful, C++ tends to bring exactly this sort of persona to the forefront

no the majority of the career experience was with C++

Depends what they meant. An expert in C++ likely meant that C++ does not guarantee any fixed width types. Whether they are provided depends on the implementation.

Well, "by support" it means a few functions that allow user to query some information about GC if implementation had it. No implementation has ever implemented GC.

Bah, the only thing worse than a buncha arrogant C++ programmers is someone who complains about them

Classic gatekeeping.

This is why I always carry around a hardcopy of the C++ spec so I can pull it out Phoenix Wright: Ace Attorney style /s

That must be heavy! LOL!!

For CHF 208, you can buy the reference directly from ISO...all 1,853 pages! [0]

[0] - https://www.iso.org/standard/79358.html

If anyone tells you C++ isn't a safe language, watch them try to stop a bullet with the C# language spec!

ECMA-334 (the C# language portions): https://www.ecma-international.org/publications-and-standard..., 639 pages

ECMA-335 (the Common Language Infrastructure portions): https://www.ecma-international.org/publications-and-standard..., 574 pages

Ok, but if I need to be saved from an anti-material round, I'm sticking with C++.

Just sayin'

I admit I had to shop around for a smaller language spec and chose C# :)

Note that those 639 pages are only for C# 6, for further pages the Word documents provided with the SDK are required.

Let's equip the addenda. It should enable us to withstand short bursts from a phased plasma rifle in the 40 watt range as well.

At some point you could get it for 18 USD from ANSI, and later for about 30 Euros from the Estonian standardization office.

Both offers had their prices, erm, fixed.

You joke about that, but people who blindly "know things" will refuse to even look at the standard. After all they already know what it says on the topic. So even carrying the standard around with you wouldn't help.

Probably safe to say that everyone has issues.

I've never successfully submitted a PR for someone's issues. Someday...

You'd have to print out your own, you can't actually buy a hard copy of any recent ISO C++.

Some national standards bodies, entitled to do so, might claim they can sell you one when actually they've got a deal with a relatively local print-on-demand company, but because this standard is huge that company will reject the order so you in fact can't buy the product you'll get an apology, or a PDF or both despite specifically buying paper.

Although their processes are hopelessly antiquated (fly to Hawaii to fix a typo? I don't think so), the result is, as you might expect in 2023 - just a bunch of document layout source, from which "draft" versions of the document are publicly available.

Not as useful if you're getting burgled, or to raise a display off the desk, but more practical for real work.

I find Stroustrup's book to be more accessible; the C++ spec can get rather math-y for some people.

What does this have to do with the article? This sounds like you're here gloating about some pedantic argument you made 4 years ago. And of course we are only hearing your side, so of course you're the hero.

And judging by the fact that this is currently the top comment, I guess this is what other people come to HN (now) to read in the comments. Color me confused.

Newer comments tend to float near the top for a while to give them a chance to get some upvotes.

>What does this have to do with the article?

Did you read it? It's about GC in C++ being a relative obscure feature that is now going to be removed.

>some pedantic argument you made 4 years ago

I just shared an anecdote related to it and I thought it'd be appropriate bc. this is/was quite likely the only chance I'd have in life to talk about this very very very specific situation with people that would understand it. And yes, it's getting a few upvotes, weird thing to be mad at that but to each its own.

It was in the spec but never implemented, so it's obly a feature of C++ if you take the stance that there are no real implementations of C++.

IIRC it was present in Clang back at the time (which was relevant to us as we were using it); not sure about gcc or others.

If you want to go this way, then take a look at compiler support matrix for last few language versions - if having an implementation is necessary for something in spec to "be a feature of C++", then C++20 and C++23 are still missing some features they're supposed to have.

Several features in ISO are yet to be fully implemented, there are compilers still catching up with C++17.

GC isn't the first one to victim of such lack of implementations, only EDG implemented C++98 external templates, for example.

extern templates are a C++11 feature. export templates are the removed C++98 feature.

Thanks for the correction, I meant obviously export templates.

We should be clear, GC was never a feature in C++.

What these features do, which are being removed, is make it easier to implement a GC allocator in a standard conforming and portable fashion. Current GCs in C++, such as Boehm's GC, depend on platform specific hacks that are incredibly brittle.

As it turns out, these features do not make it easier to actually implement a GC allocator in C++, so they are being removed.

I think most people can differentiate between a language providing a feature as a first class native property, and a library or feature built on top of that language. Most people would not argue against the position that C++ does not contain a web browser as a feature, even though it's possible to build a web browser using C++.

Similarly, C++ does not and has never had garbage collection, but for a time the standard did provide facilities that was supposed to make it easier to implement a garbage collection library.

>I guess this is what other people come to HN (now) to read in the comments.

Reading comments (loosely-related, tangential, meta, whatever) that generate potentially interesting discussion? That's pretty much the only reason I've visited HN for years and years. What do you mean "now"?

Reply on news.ycombinator.com