Hi everyone here's a question which has caused many arguments in my lurking spots on discord.

What is the worst type of bug? (logic, type, syntax, etc)
//you decide what "worst" means

1. Logical bugs (because they'll often fail when it's too late or code has been already released)

2. Dependency bugs (not owning or being able to edit the broken code is the stuff of nightmares)

3. Improper configuration or input cleaning bugs (gaping security holes and you must be knowledgeable to avoid them)

4. Syntax errors (just type it right)

Whatever one has the greatest impact and takes longest to find.

Wrong documentation and unexpected behavior without access to source code. Perfect for rapid hair loss.

Yeh, just the thought of module bugs and npm makes my skin crawl...

Race conditions win over them all. They are difficult to reason about, hard to reproduce, hard to test for absence, and any kind of logging or debug build usually turns them into Heisenbugs.

How do we define worst bugs?

Is it based on the amount of time required to fix the bug?

Is it based on when we identified the bug?
During testing phase? On production?

Is it based on impact of the bug? Money that business has lost because of the bug?

Regardless of how we define it, I'm actually biased towards design bugs because those are the ones that slow you down (iterations in future) and takes most of the time to refactor.

Def race conditions. Intermittent, hard to find, hard to debug, one thing depends on another and frustrating as all get out.

Bed.

Indeterministic "bugs" when doing multithreading stuff..
(Additionally the people throwing around mutex'es as an attempt to solve the problem)

@wholl0p Why, mutexes are the easiest preventive measure when accessing shared variables or resources. I wouldn't even think about lockless stuff unless benchmarking has proven the mutexes to be a serious bottleneck.

@Fast-Nop My "rant" was because mutex'es should absolutely be set wisely and not being thrown around and placed randomly

@wholl0p ah ok, yeah of course only around access to shared stuff.

The miracle why random mutexes can happen to accidentally work is that they contain memory barriers so that unrelated things get synced up, too.

@Fast-Nop I mean I would do the same if I was lazy, sometimes it works but that makes the Programs much much slower

@wholl0p yeah, it's a choice between either limiting concurrent access by design or manually dealing with possibly inconsistent memory.