The difference between my line of work—software development—and others is the fact that the consequences of imperfections are far more drastic though they are just as inevitable. Just about any other occupation affords one the opportunity to recover from mild screw-ups: a dentist can mistakenly scrape your gums, an actor can stumble over a line, or a dump truck driver can blow a tire. But with a little improvisation and ingenuity, these folks can amply recover and still accomplish the task at hand.
The experience of the software developer is a bit more vexatious. The hope is that we (or our IDE) will notice a mistyped letter or slightly flawed logic before we unleash imperfect software on the masses, but unfortunately “bugs” are a fact of life. Witness the number of major companies such as Google, Apple, and Microsoft that release software tagged with the word “beta”—a term that in the world of software programming I would describe as politically correct. It absolves the software provider of responsibility and is roughly an open admission that things might not work as intended.
With computers, everything is black and white, ones and zeroes, pure logic. This fact actually appeals to most programmers and provides us with a constant challenge as we write software. But without shades of grey, we are bound to continue producing otherwise exceptional products that are ever so slightly tainted by the stain of human error. The average citizen has used enough software at this point that they almost expect problems to occur, and as a result software developers are often viewed with some degree of suspicion. What can we do about this problem of error-prone software, and how do we improve? Certainly testing mechanisms are already in place on development platforms, but even then we are limited by our inability to foresee all the possible scenarios that might result in errors. Testing techniques have improved, but so too has the complexity of software skyrocketed, leaving us in roughly the same position.
The harsh reality is that this problem will never disappear completely. I anticipate that significant strides will be made via new automated testing methods, new programming languages, and simply better documentation and training. But as a software developer I know all too well that my mistakes, however scarce, will always be prone to unveiling themselves in a most garish fashion and to my enduring chagrin.