Hacker News Reader

Comment by rurban | Hacker News Reader

Unlikely. We were hit by a series of similar string builtin related bugs in the tree optimizer since gcc 9.0. And the bugfest is still ongoing. The most likely explanation is an incompetent developer touching these areas.

View on HN

Not sure why has this comment been downvoted. It simply describes the bug in context ("there has been a series of similar string builtin related bugs in the tree optimizer since gcc 9.0") and offers a plausible explanation of the bug ("an incompetent developer touching these areas") based on Hanlon's Razor.

Even this is not welcomed on HN nowadays?

Perhaps because it is unfairly assuming incompetence? Everyone makes mistakes.

It's attributing the error to incompetence instead of malice. It's not particularly unfair, it's providing an alternate explanation, if a bit bluntly.

Even the most competent among us makes mistakes from time to time. I make them almost daily.

Sometimes you just have a problem that's hard to wrap your head around and you think you found a way to make code faster that just isn't so.

Now the issue is better understood and we may end up with a couple good tests to prevent future regressions.

A bunch of mistakes all in the same area mean you're doing something wrong, moreso than "everyone makes mistakes". And if it's an accident, and not caused by someone overworking you, then it falls under the umbrella of "incompetence". That doesn't mean you're a failure in general, it means you weren't up to doing this particular work at this moment in your life.

Depends on how much work you did in that area, and even if the proportion of mistakes is high, it doesn’t necessarily imply incompetence. Could be a bad day.

Also, I would guess gcc does code reviews. If so, gcc seems to be full of incompetent programmers, making it a miracle that this thing can even compile hello world. I don’t think that’s the case.

If you had that bad of a day while being extremely "productive", and never double checked, then that falls under the umbrella of incompetence.

> If so, gcc seems to be full of incompetent programmers

Are you bristling at a word that looks like an insult and then ignoring what I'm actually saying? I specifically said you can be incompetent at a particular thing at a particular moment in time and that it is not a summary of you in general!

"Incompetent", in special if you use it without any further qualification, is not usually meant as "incompetent at a particular thing at a particular time".

I'd say that pretty much everyone is completely incompetent when it comes to correctly implement a complicated piece of software like GCC. OTOH, the people who develop GCC are incredibly competent at what they do because the compiler does insanely complicated things the vast majority of the human race would struggle to comprehend and, yet, its surprisingly correct, with the occasional bug and confusion here and there.

We all work at the limits of our wits. Right now I'm waiting for a timeout so I can continue to test a hypothesis. If I am lucky, I'll be right and the system will malfunction in the way I expect it to. I'd say my chances at this point are 50/50.

In the context of malice vs. incompetence, malice certainly doesn't refer to an innate quality you possess all the time, so why would the alternative mean that?

> with the occasional bug and confusion here and there

And the point of this thread was talking about a big batch of bugs, the opposite of "occasional".

Maybe that area just has a high complexity, making mistakes there more likely?

It was declaring that the developer was incompetent. That's needlessly insulting to anyone. Making a mistake doesn't make you an incompetent person.

Fair enough.

Also, because it badly models how the error occurred in the first place. It wasn't any one developer who made a mistake, as a comment in the thread makes clear, it was a series of mistakes, made by different people, coupled with poor documentation that ultimately led to this.

Yes... but breaking similar things repeatedly.

Certainly not needless. The whole world relies on a new gcc release not to introduce new severe bugs in good code. Mistakes need to found and fixed before the release, but not 3 years after. Then the mistake becomes incompetence. I wish I would not need to sprinkle my code with

    #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) && \
       (((__GNUC__ == 9) && (__GNUC_MINOR__ <= 3) || \
        (__GNUC__ > 9)))

Also their arrogant attitude. Incompetence is rarely the only problem, it only gets problematic if paired with disfunctional management or arrogance.

Hanlon's razor isn't a binary device. It recommends a preference ordering of two well-known attributions, malice and stupidity, but does not close the door to the many other possible explanations for any given undesirable outcome.

rurban often gets flak for his method of communication, which is generally blunt. Whether from a language barrier or just how he communicates, I think people have a problem separating the message from the delivery, so that might be what's going on here.

I agree with his assessment that it's probably just someone's mistake. I also personally wouldn't have worded quite that way, even if technically correct (incompetent is fairly harsh wording in English). I don't think it's worth down voting over.

Reply on news.ycombinator.com