Fact of the matter is, software is NOT like building a bridge, or any other engineering discipline, it's much, much more complex. We'll never achieve high reliability for anything but the simplest software (reactor control rooms come to mind). Accept the fact that software is hopelessly broken, and find tactics to deal with it.
But on the other hand, I don't want to accept that we will never achieve high reliability. I've heard and read multiple times that software goes through an expansion phase (an exploratory phase), until we eventually manage to gain enough insight and clarity as to be able to go back and simplify to something that we can wrap our head around again. Certainly, while developing, I often find myself in this situation. For many problems, you don't understand them until you have written the solution, come across new problems, and are able to rewrite again with much greater understanding... a clean solution.
Now, there are many very complex problems. Some solutions will never be clean. But we do definitely have light years of room for improvement. Networking is messy. OpenGL / Vulkan / low level graphic APIs are unwieldy and inelegant. Same for most databases and SQL. Audio APIs are not much more pleasant. Real time systems are mythical creatures for the average developer. Filesystems are not as homogeneous and standardized as we would like. Browsers are monsters. We can't even agree on what units use for UI elements. We don't really have much idea of how to handle screens of different sizes. Common file formats shouldn't even be a software concern most of the time. We talk so much about type systems but still define most protocol specs in plain text. Interoperability is mostly C or die. Unicode is many things besides a standard for symbols. Too many. Permissions and privacy are... well, maybe it's better to stop for today.
And that's indeed the reason why software must be a moving target. Because we can't accept these foundations to stay as our original, unerasable sin. But I do believe there is a real possibility to do better. One day devs will unite in a mystical place outside the realm of "pressure to deliver", we will agree on what are the main priorities and opportunities for improvement, and we will coordinate to start changing things and make our asylum a saner place. Coordination might be both the biggest technical and non-technical problem we will ever have to face, but I find no reason to believe we can't handle it.
I believe this is exactly what free software is - and in a distant future it will replace all proprietary solutions due to its higher quality.
Agree with the rest though. From time to time, the industry manages to go back to the drawing board and make big simplifications or reliability upgrades, quantum leaps. Java was one example because it combined garbage collection, a somewhat rigorous language, high performance, a clean reset of the toolchain (no messy autoconf/Makefiles) and very robust/well engineered standard library. It was a huge success for that reason: familiar enough to be easy to pick up, but it abstracted or eliminated vast complexity.
SystemD was a smaller scale example of a Big Simplifying Reset in the UNIX world.
But these sorts of things come along rarely, and entropic decay into ever more complexity never stops.
> We'll never achieve high reliability for anything but the simplest software
Sorry, I wasn’t very clear!