When the actual behaviour of software diverges from its expected behaviour we call it a bug. The reason we have bugs is that we humans are very bad at reasoning

When the actual behaviour of software diverges from its expected behaviour we call it a bug. The reason we have bugs is that we humans are very bad at reasoning about the expected behaviour and projecting the actual behaviour of a computer program, and that is because of the humongous complexity that is involved. Unbounded complexity is a distinct trait of software. The most important, most regulated and most prestigious software engineering tasks are hands down mostly about doing relatively simple things but controlling complexity. To a lesser degree, when writing code every programmer is actually working to control complexity. Once things get complex then nobody, not even the brightest brain, can get anything done anymore. So the first priority is to actually avoid too much complexity and to reduce it further will cost time and money. This means we can do simple things well if we want to. We do this for narrowly scoped projects such as aviation-grade software, rocketry and medical software et cetera. It costs, and we can do it, but that's only because we already slashed out most complexity out of the window before we even started. Instead of general-purpose software we're writing very specific-purpose software. Using the same principle but working on top of abstractions we can do complex things well in software, too. But those always come with a caveat about when and where the abstraction might fail. Most software is like this but that is also the sort of software which is no longer bridge-building grade. We don't build bridges whose design is theoretically sound given a few hasty assumptions, but with the possibility that when those assumptions might fail the bridge would come down. Certified software engineering can't fix that because they would have to start from the ground up to cover all their bases and then they couldn't get very high from there. Certification is no silver bullet. Complexity is already managed where absolutely necessary and where there is the money to back it up. Requiring a certified engineer with legal responsibility in the general case would just make most software development stop entirely because anyone with the slightest understanding of programming would never sign off the software we currently want to run, and writing properly engineered software to handle what we currently want to run would be just prohibitively expensive.