This might be true in a deterministic setting, since the likelihood that a test suite will find the error is very high. But in a non-deterministic concurrent setting, throwing an exception that might be only caught once in a blue moon is just as bad as not doing anything about errors.
If you're really serious about data integrity, ask yourself - does any language even attempt to describe data structures stored on disk?
The fundamental problem still remains, that in neither case can I use the language's semantics to guide the design of my program.
> and as long as you have one instance of the exception you have a stack trace to start from
Oh, really? How am I supposed to find what the problem is in the general case, from just a single exception stack trace that I might or might not get?
What if the error is difficult to reproduce in the first place? This isn't too uncommon in concurrent programming.
Of course I can look at the code. Trust me the reason why I introduced the bug wasn't because I was looking at something else at the moment.
> see why you can't prove it correct,
Realistically, this is because the language and the program's design conspire to make proving anything about the program an uphill battle. If the language could perform basic sanity checks (e.g., no attempting to use objects after ownership has been transferred to someone else), then at least I could have a fighting change to manually prove more interesting properties.
> or work backward to see how the code could have gotten to such a state.
Doing this on a per case basis is an incredibly mind-numbing task.