For anyone who spends a lot of time writing user interface code, optimizing the view immediately conjures up images of windows, clever little UI gadgets, usability issues and a long string of design meetings with excitable and over-caffeinated programmers. The fact that these little get togethers may very well involve airborne white board erasers traveling with great velocity and purpose is just another testament to the passionate importance we place on how our software is presented to our customers. Indeed, the portal through which the user peers into the depths of our code often seems to define the software itself, at least in the eye of the beholder. Consequently, we acknowledge that user interface issues are not just a matter of putting on a pretty face, but in fact define the boundaries within which our users will operate. Put a clunky view on a good piece of software and you end up with a clunky piece of, well, software.
However, those of you who have already fired up your programmer's editor and called in your order for a pepperoni pizza in anticipation of yet another exciting session of coding are probably getting a little ahead of the game. We're not here to talk about the bits and bytes of coding. We're here to talk about something much more important - your future as a professional software developer. So, you won't be needing that programmer's editor for the moment. The pizza is probably still a good idea, though. Some traditions should never be changed.
If we're not going to talk about functions and objects and squiggly little lines of incomprehensible text, then what on earth are we here for? What could possibly be more important to a developer than the details of writing code? The answer is both obvious and elusive in the same breath. The most important thing to programmers everywhere is not writing code, but rather delivering quality software.
Did you just stop, shake your head and read that last sentence again? You're not alone. Almost universally, good programmers reflexively equate writing code with delivering software, as if they were one and the same thing. They are not. In fact, it is this very view that is largely responsible for release disasters worldwide.
If you don't know what a release disaster is, you've led a charmed life. Take two donuts out of petty cash and go back to what you were doing. The rest of us are all too familiar with the details of good releases gone bad, including arbitrary deadlines, endless overtime, high stress levels, short tempers and monitors flying out of fifth floor windows, all for a product that gets shipped long before it's ready due to market pressures. When your software hits the streets with more bugs than a cheap motel and less stable than a maintenance programmer who hasn't slept in a week, are the technical details of coding really the guilty party? Not likely. I can assure you, some of the worst software releases I've seen were the product of absolutely brilliant technical minds. Let me present that thought once more, for emphasis. Poor quality software releases are almost never due to a lack of technical skills.
So, if the project you're working on is greeted by the user community with those two immortal words dreaded by programmers everywhere ("it sucks!"), then who is the culprit if not the code? The programmers, of course. Hey, you didn't think you were going to get off the hook that easily, did you?
The Usual Suspects
I'm beginning to see some glazed eyes in the back of the room. If bad releases aren't caused by poor technical skills, then how can it be the fault of the programmers? Well, in fact, we're going to invoke a little pretzel logic here. Not the straight, matchstick sized ones that are also good for stirring your drink, but those twisty, winding type pretzels that take a lot of turns but always end up right back where they started. We'll start by listing rounding up all the usual suspects, but trust me; in the end it's all going to come home once more to rest right in our own laptop filled little laps. Pretzels are like that.
In fact, many of the veterans here have already made a list of the parties responsible for screwing up a perfectly good project, and have even made suggestions regarding exactly which wall they should be placed against when the revolution comes. Some of the more seasoned among you may have even suggested that the lawyers must wait their turn, or use another wall.
Who are these villains, these people powerful enough to override the capabilities of even the most brilliant coder? Marketing and management are certainly the first to come to mind, often known as Weasels and Suits when programmers are hanging out by the cappuccino machine late at night. When turned loose on an unsuspecting software development team, the results inevitably include vague and shifting requirements, arbitrary deadlines declared with no concept of the technical realities, scope creep, crisis driven management, complete lack of a professional testing department and in the end, software that was released long before it should have been.
It's Not My Job
What's that you say? I've just clearly proven that it's not your fault? Nice try. And pass me a pretzel, will you? Projects fail for an unbelievably simple reason. Extremely intelligent and otherwise talented programmers time and again make the naive assumption that if it's not about the code, it's not their job. In modern air to air combat, a jet fighter pilot who finds himself close enough to his opponent to fight it out with machine guns has already missed critical opportunities to solve the problem from a safe distance with long range missiles. And so it is with programmers. If you find yourself in Overtime City with a guaranteed release disaster right around the corner, you screwed up long before then by failing to control your situation before it controlled you. Ouch. Can I say that? Well, maybe I should at least have offered you a pretzel first.
Your view of the software development process dictates what you do, and do not do, in the course of your work week. If you believe that everything beyond coding is "not my job", then you and your project will without question fall prey to the strong and illogical forces that sweep through the corporate world. However, the follies of marketing and management can both be minimized by the savvy programmer. For every bone headed thing that these rocket scientists can throw at us, there is a counter. Manage the problems early enough in the game, and your release disaster instead becomes a release party. They'll probably even spring for the pizza.
The Road Ahead
You don't have to have an MBA or be a sales weasel to effectively manage these problems. You just have to expand your view of the software development process to include anything that might affect your release, and do what's necessary to protect the code you've worked so hard to create. Granted, this isn't always as sexy as writing a flashy UI in the cool language of the day, but when it's 4 AM, you haven't slept in 3 days, and poor management decisions all but insure that tomorrow your product will ship in less than perfect shape, nothing's sexy.
It's time for programmers to regain control of the software development process. Learning sneaky and not so sneaky tricks to deal with all the non-coding issues that threaten our programs, our free time and our sanity is what we'll be doing in the months ahead. Step by step, issue by issue, we'll look into ways of seeing disaster before it strikes and taking preemptive steps. The end result will be more time doing what you really love - writing cool code that becomes the next Killer App. And isn't that really what you signed up for when you chose this profession?
About the Author
Christopher Duncan, a veteran contract programmer, is President of Show Programming of Atlanta and teaches seminars based on his recent book, The Career Programmer: Guerilla Tactics for an Imperfect World (Apress). He can be reached at Chris@ShowProgramming.com.
Copyright (c) 2002, Christopher Duncan.