Dependency traps
Theory goes that a lot what was accomplished in computer science was actually accomplished due to the laziness of the actors involved. And it’s not hard to find examples supporting that theory, but my favorite is about programmers in the 50s that didn’t like writing their programs in assembly language, so they invented new programming language(s) and accompanying tools (compilers) to translate those new languages back into assembly. True, writing all those tools took quite some time, but after they were done with them, they suddenly became a lot faster in their craft, offsetting time spent on building the tools by a large margin.
Native code is slow (and always will be)
It looks like there is a growing push towards going back to distributing software as native binaries. However, it also looks that programmers these days seem to forget why we moved from native to bytecode binaries in the first place (maybe because the ones that still have that experience all migrated to management?). It’s not that native code doesn’t have any advantages, but far from it that it’s a silver bullet like we are (sometimes) led to believe.
Simple technologies don't scale
As programmers, most of us are intimidated by big, complex problems. And since most of us are a bit cocky too (in a positive way!) we are often inclined to dismiss inherited complex products and technologies as “old” or “bloated” and tend to solve every problem with “refactor” using some “new technology”. Similarly, we tend to dismiss as “not needed” most of the things we don’t understand. Don’t know about you, but I have to confess that throughout my career I have sinned on all of those accounts.