The best software / programming concepts have put a lot of thoughts on how to prevent developers to not shoot themselves in the foot again and again.

Should we learn from the best? Sure, but most often we don't actually realize how much efforts have been put into preventing those errors. We are focused in the task at hand (thanks to them!). At best we are grateful that the thing we wanted to do wasn't as complex as we feared.

If learning from the best doesn't work, what we can do is to learn from the worst.

And that's where I need your stories and insights

What are the best tools/concepts that empower developers to shoot themselves in the foot again and again?

The kind of things that could have been as welll designed by an evil genius curious to see how much confusion it can infuses in the world.

It could be anything (IT-related):

• a concept considered as harmful as GOTO (nullable booleans?)
• some wonderfully confusing piece of interfaces (git's cli?)
• some overly complex architecture principles (microservices)?

And what lesson can we learn from this? (Because they didn't in fact do it on purpose, so we could too).

Please use your keyboards, release your frustrations and let's celebrate the worst of the worst!

And vote for the worst answers.