(Replying into Programming topic since it seems more appropriate.)
Oof. I could probably rant for a long time but my mind is tired so I’ll try to keep it short. A couple of examples:
- EAV data. It seems like every single programmer who has to work with a database at some point comes up with this great idea - instead of creating domain-specific data models with proper constraints and validations, why not just store a table of Entity, Attribute, and Value fields - then anything can have any data structure! So flexible, and the domain becomes irrelevant, so we can do anything with it!
- Similarly, the opposite. Why not put each individual field in its own table, so we can also store all kinds of metadata about it? So flexible, and we can do anything with it!
- Then a hot thing - ORMs. Why not just treat the database as dumb storage and rewrite all of the indexing, querying, joining, and sorting stuff in code? That way we don’t have to deal with SQL!
Of course, with any of those, the queries are horrific, performance is awful, and the bulk of everything that the database would handle so much better and more elegantly instead has to be re-implemented in the application code (and additional dependencies/libraries) instead.
After you’ve seen it, you know you’re still gonna end up having to make properly-modeled tables and/or denormalized ones for the software to even begin to work decently and then you have to keep all those copies synchronized, which is awful error-prone, and a resource hog. And worse need a ton more application code to handle that mess. Yet every hot new thing seems to take at least one of those approaches (and/or go noSQL).
Then there’s OOP. Almost everyone who learns it discovers the famous Patterns, gets blinded by the light of revelation and then that’s all they can see. Let’s add abstraction layers to everything! Inheritance, composition, and indirection everywhere! It’ll be so flexible!
If I see one more AbstractSingletonEntityFactoryManagerFactoryInterface… 
Ravioli code is just spaghetti code with a designer logo.
But those are fairly recent things that have peeved me lately. Going back further, you see things like the switch from thin-client dumb terminals connected to mainframes, over to fully-capable networked PCs, now back to thin-client browsers connected to cloud services.
Or how about the back and forth between “Statically-typed languages are so constraining and have so much boilerplate, a more dynamic language would be so much more productive and flexible!” vs “This dynamic language needs so much inline type-checking and validation, if only the compiler could do this for us it would be so much more productive and robust!”
We keep cycling over the same stuff, just reinventing the cycle’s wheels. And adding epicycles with the tooling. Not that tooling is bad. It’s just that the fact that we now need so much and so complicated of tools to deal with the complexity that we’ve made for ourselves says something.
Guess I failed at keeping it short. 
I never actually ‘broke in’, but at the right age, dressed the right way, with a backpack… You could just walk right in and stay in the computer room until they shut the lights out and the security guard came around. Of course, then you had to take the stairs because the elevators were already shut down. 
Not all of that time was spent playing MUDs or on IRC. We also had gopher, telnet, ftp, etc. Also found an open university dialin which you could use from your own home to telnet to other non-local universities and dial-out to what would’ve been long-distance BBSes.