I’m working on a rather interesting project now and it’s got a lot of variables seeing as how it involves networking and a series of other things. I’m new to unit testing as it is and wasn’t prepared to slow down the pace of development by learning to do things test-first on a project like this. When I went to actually write my application, I was reminded of my personal pessimism and paranoia as I automatically added exception and error-handling code to every potentially-dangerous method to ensure that errors would be caught, debugging would be eased and all the loose ends would be tied up. Is this bad? Is there someone out there who would balk at my careful and obsessive compulsion to anticipate failure states and account for those which are unforeseeable? It’s not like I wake up in the middle of the night visualizing a failure case, run to add an exception handler and commit it to revision control before returning to bed in a self-satisfied saunter. Sometimes I will get worried when I look at my source base and realize that many lines might never be called because the error they account for is so unlikely that other might laugh at their very existence. When my app does encounter an error, the exceptions carefully make their way up the call stack carefully logging detailed error message as they bubble to the top. So then, when execution goes awry and things go asunder, my deliberation pays off with the satisfying anti-zen of a startlingly-detailed backtrace.