There are subfields of programming that generate more than their share of subtle gotchas, so that one should be particularly careful even when doing many routin

There are subfields of programming that generate more than their share of subtle gotchas, so that one should be particularly careful even when doing many routine (aka "trivial") things. E.g., security, or multithreaded stuff. From my single real analysis course way back when, I remember an impression that real analysis was a subfield of math with a similar error-prone character --- particularly easy to conclude something incorrect by stumbling over a technicality (e.g. integrating before taking a limit instead of vice versa), where the technicality is likely to be tricky to keep track of because the cases where the technicality matters are so weird (e.g., carefully constructed horrendously discontinuous functions). Not all fields of programming or mathematics are as productive of fiddly gotchas: often an experienced specialist can judge rather reliably that a piece of work will be entirely routine, though time-consuming. I can only appeal to my informal anecdotal impressions for this in programming, but in mathematics I have some harder evidence: setting up machine-checkable proofs in HOL Light. The prover won't let me get away with any hand-waving or ambiguity: I really do have to dot every single i and cross every single t. In the end, doing that is routine (though often very tedious and messy --- people talk about spending a week to formalize a page of mathematics), and I am very seldom surprised by a part of a proof that I expected to be tedious instead turning out to require new insight.