Freedom is not free
It’s not uncommon for any of us to trade our personal freedoms for various perks. As a most well-known example, in most modern societies it’s expected to give up one’s freedom to use force in exchange for a safer society altogether. And it makes sense: if it’s not corrupt, letting the state own a monopoly on the use of force is a net positive for everyone. We are significantly more cautious when a privately owned company requests that we relinquish some of our freedoms, but it’s not uncommon for us to accept even those monopolies, often in exchange for a better level of conformity (think credit cards or smartphone platforms). But what happens when we, consciously or not, allow this concept to go a bit too far, relieving us of more freedom than we initially anticipated and subduing us to monopolies whose walled gardens were not evident at first sight?
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.