-In fact, it is pretty hard to perform such a test; the standard has not been written with such considerations in mind.
-This has given UB a very bad reputation, and mostly rightly so, I would say.
-[A lengthy blog post](https://blog.regehr.org/archives/1520) summarizes the situation quite well:
-There is progress being made with various sanitizers, but e.g. for the effective type restriction we discussed above, the mitigation (i.e., the way to check or otherwise make sure your programs are not affected) is "turn off optimizations that rely on this".
-That's not very satisfying.
+It also turns out that programmers' intuition often [does not match what the compiler does](https://www.cl.cam.ac.uk/~pes20/cerberus/notes50-survey-discussion.html), which leads to miscompilations (in the eye of the programmer) and sometimes to security [vulnerabilities](https://lwn.net/Articles/342330/).
+As a consequence, UB has a pretty bad reputation.
+(The fact that most people will not expect an innocent-looking `+` operation to come with subtle proof obligations concerning overflow probably also plays a role in this.
+In other words, this is also an API design problem.)
+
+There are various sanitizers that watch a program while it is being executed and try to detect UB, but they are not able to catch all possible sources of UB.
+Part of the reason this is so hard is that the standard has not been written with such sanitizers in mind.
+This [recent blog post](https://blog.regehr.org/archives/1520) discusses the situation in much more detail.
+For example, for the effective type restriction (also sometimes called "strict aliasing" or "type-based alias analysis") we discussed above, the mitigation -- the way to check or otherwise make sure your programs are not affected -- is to turn off optimizations that rely on this.
+That is not very satisfying.