During my career I have come across many developers who frowned at my pedantic use of double checks in various layers and modules in my code. Most developers will place a layer of parameter validation and assertions at the boundary between the external and internal layers. That is because of the common wisdom that you should never trust user input or external data.

I take it a step further. Internally between different modules I also add a layer of parameter validation and assertions. So the question becomes why? Because I do not trust myself - or my team members. Mind you, this is not in the bad kind of way. I do not trust that I cannot create a bug. That a team member cannot forget about a certain assumption made elsewhere. And this very practise saved my butt yesterday.

In one large enterprise system I created, data integrity is particularly crucial, and it is particularly hard to detect any inadvertent data corruption. There is a process whereby certain data can be set up that will be processed a couple of weeks later. These are two distinct (but co-located) modules in the system. I designed and implemented both. However, the processing engine has some assertions regarding the format and structure of the data it processes. Even though the data setup module enforces these restrictions, the ones pertaining to the data processing module are re-checked before the processing module starts processing the data. In this case, an assertion made in the processing module caused the whole processing to be aborted with a neat, concise and accurate description of the problem.

My kid found this yesterday... Hand picked but she did not realise at the time its beauty when inspected up close under 40x magnification and with fluorescence excitation.

I applaud Google for their effort, but we are a long, long way from making computers intelligent at interpreting trivial visual images.

Amazing to see how a biosystem reaches equilibrium from the primordial soup of nothingness to ordered beauty.