It dawned on me in April that bugs and testing to find bugs reaches infinity pretty fast. In high school math, we are taught that asymptotes stretch to infinity. This is simple to visualize on a graph, but numerically no one has a gut feel for how big (or how far out) infinity is. Later on in college chemistry class, we are taught that moles are the better unit for measuring large numbers of things, like molecules. Avagadro’s number -- 6.02*10^23 -- while certainly a very, very large number, never felt like "infinity". You could hold several dozen moles of various items in a small beaker. In my particular secondary educational background, we talked about the cross section of nuclear interactions. The units were "barns", which amounted to tiny numbers on the order of 10^-24 square meters, so even if something was "as big as a barn" it would still take millions of nuclei to add up to something larger than infinitesimally small. When we throw around units like moles and barns, with numbers of this scale, it remains challenging to not throw in the towel, just call something "infinite", and slink off to the pub to avoid thinking about them over a pint. We use those units to bring back very large numbers to the realm of human-visualized quantities.
Software testing however rapidly reaches "infinity" when the permutations and combinations of linearly independents variables mushroom a test matrix to beyond a scale a human can visualize or comprehend. For a real and raw example, the DevPartner Java support matrix consists of eight mostly independent dimensions to pick one cell in a possible runtime environment. The dimensions are JVM version, JVM Bitness, OS version, OS bitness, AppServer, IDE, Browser, and Browser public JRE. Even though these variables may have a discrete set of values, the combinatorics involved with spanning the space to determine a suitable test matrix rapidly approaches infinity, or in other words beyond the ability for a human to visualize and construct a reasonable test plan, especially since once you've selected values in each of these dimensions, you still have a wide number of tests to run to ensure stability and compatibility. Draw up a short plan, and bugs will fill the remainder of the spanned space of untested variables. Build and execute a completely exhaustive plan, and you'll consume all the energy in the universe to finish it, and likely blow quads of energy uncovering and trying to fix bugs in combinations that no other user will ever run. I like the concept of equivalence class portioning to reduce the number of test cases, but those always seem to be contrived dataflow algorithms under test. I also know that in an infinite number of rooms with an infinite number of monkeys tapping on typewriters that one of them will come up with a copy of Macbeth. I would feel better if a test protocol had a better way to knock infinity in the shins. I certainly don't have budget to consume all the energy in the universe to ensure my code is infinitely clean at all its asymptotes. Do you?