Tuesday, September 11, 2007

Programming Can Ruin Your Life


There are many essays and articles extolling the virtues of becoming a great programmer. You’ll have a sharp mind, great abstract reasoning skills, and a chance to become wealthy by working mere hours a day. This is what you’ve heard, right?

Sadly, no one ever tells you about the ways in which it will adversely affect your life. The physical effects are obvious. You’ll spend most of your time sitting, probably in an uncomfortable chair that doesn’t promote good posture. You’ll fuel yourself with food that is readily available, meaning it’s more than likely processed and full of sugar and you’ll likely choose either coffee or soda to stave off the drowsiness. A coworker once remarked, “If it doesn’t come out of a vending machine, programmers don’t eat it.”

But I’m not particularly interested in the health risks, as I said, they’re obvious. So what am I talking about? Programming changes more than your body. Programming changes the way you think. You might hear a programmer say, “I like python because it matches the way I think.” Or is it really that they’ve learned to think in python? Regardless of the language employed, you think differently when you program. No decent programmer will deny that. This is why it’s often so hard to explain to someone “how you do that” because, as clear as your explanation may be, you simply think differently. It is this change in thinking that can ruin your life.

The application of programming specific processes and habits to the everyday is where peril lies. The same traits that make you a great programmer can make you an awkward, misunderstood and miserable human being.

Programming presents you with a problem and allows you to eventually solve it provided you don’t quit. A solution is out there somewhere. Make enough attempts and chances are you’ll eventually prevail. Aren’t computers great? They afford a large degree of freedom in problem solving. If nothing else, you are able to make as may attempts as you please and it will happily execute each one. This instills in you a sense that failure is not final. Any obstacle can be hurdled. This is not true in the real world. While you may find second chances now and again, the wheels that turn in the big blue room are largely unforgiving. Time marches on in one direction.

When faced with an interesting programming problem your mind will chew it over in the background. Maybe it’s an algorithm you need to develop, maybe it’s a tricky architecture problem, maybe it’s data that needs to be modeled. It doesn’t matter. Your mind will quietly work the problem over in search of a solution. The “ah-ha!” moment will come when you’re in the shower, or playing Tetris. This practice of constant churning will slowly work its way into the rest of your life. Each problem or puzzle you encounter will start it’s own thread; the toughest and most troubling of which will be blocking.

A program is highly malleable. You can make a nearly unlimited number of changes. You can re-implement. You can optimize. You can run the compile-test-debug cycle ad infinitum. Make a change, see a result. Life is not like this. Every action you take is followed by a commit and the transaction cannot be rolled back. You can continue to make changes and optimizations as you move forward but the effects of these will not be immediately apparent. The instant feedback of development is sorely lacking in real life. Furthermore, your changes might simply be ignored. Data will be skipped. Blocks will not be executed. Optimizations will go unnoticed. The world is resistant to your tinkering.

Programmers become obsessed with perfection. This is why they are constantly talking about rewrites. They cannot resist optimum solutions. Perfection requires tossing aside mediocre ideas in search of great ones. A good programmer would rather leave a problem temporarily unsolved than solve it poorly. A good solution takes into account all predictable outcomes and solves the largest number of them in the most efficient way. This mindset prevents you from writing code with limited utility and life span. While it’s a wonderful trait to have in programming, the demons of scope and efficiency will start to assert themselves on your ordinary life. You will avoid taking care of simple things because the solution is inelegant or simply feels wrong. Time to think will no doubt yield a better result, you’ll say.

The obsession with perfection develops a forward-thinking mindset. The ability to anticipate provides a huge advantage because you won’t waist your time implementing solutions that ultimately fail due to short-sightedness or lack of imagination. You will constantly be mapping out flows and running the permutations through your head. Back in the real world, you will find yourself piecing together plans of breath-taking size and beauty that simultaneously resolve multiple problems and fulfill numerous dreams. You will attempt to kill every bird with one stone. The impossibility of actualizing these plans will be agonizing, yet your mind will continue to pour over every detail as it seeks to anticipate every possible outcome and construct the perfect solution.

Everything is now data. Every bit is worthy of attention. Every interaction is worthy of analysis. Your mind has been trained to do this since it is usually the insignificant or subtle bits that have to be rooted out when debugging. You will find it frustrating that everyone else does not collect and analyze data. You will notice details that others simply gloss over. Your penchant for detail and over-analysis will earn you strange glances and confused shrugs. Your decision making process will resemble that of your peers less and less.

The frantic pace of the software world will instill in you a sense of panic and urgency. You must do everything now. Tomorrow is too late. The thought of working constantly will no longer seem foreign or ridiculous. You will spend your free time feeling guilty about not working. But you will be working. Your hands may not be at the keyboard, but your mind will be.

The romanticized story of young upstarts toiling away in a garage to build the world’s next great company is alluring. It’s easy to convince yourself that the dream is there for the taking. But understand that there are many factors you cannot control. Luck and timing being but two. Don’t miss the life you have in the search for the one you think you want. To quote John Lennon, “Life is what happens while you are busy making other plans.” But perhaps Pascal said it best, “We never keep to the present. We … anticipate the future as if we found it too slow in coming and were trying to hurry it up, or we recall the past as if to stay its too rapid flight. We are so unwise that we wander about in times that do not belong to us and do not think of the only one that does; so vain that we dream of times that are not and blindly flee the only one that is… [We] think of how we are going to arrange things over which we have no control for a time we can never be sure of reaching… Thus we never actually live, but hope to live, and since we are always planning how to be happy, it is inevitable that we should never be so.”

Is programming the road to ruin? Or is it that those with a predilection for detail and mental gymnastics find themselves drawn to it. Perhaps it simply exacerbates a pre-existing mindset. There are certainly other traits (stereotypical or not) that most programmers seem to share. I have focused mainly on the negative impacts, but there are certainly positive ones as well. All things listed as bad can be good if simply kept in check. Obsession is dangerous, and anything great requires obsession. Programming is no exception.

Source: Devizen

No comments: