Frivolous Friday, 02.12.2010: Paying your dues

I won't mention a handle, because I was too lazy to get advance permission to do so. So let's just say that someone I know is morphing into a self-taught web programmer, and (from what I can tell) is doing so fairly conscientiously. In other words, the expectation that dues must be paid seems pretty clear to the fledgling coder in question. (A huge mercy, by the bye, to those of us who bristle at the implication that programming in three and a half languages for any web application worth the name can be picked up from a book in 24 hours.)

The bad news is that dues are not the kind of thing you can get out of the way with an up-front lump-sum payment (although dues tend toward front-loading). The good news is that everyone has to pay them, and even the brainiacs can bank on feeling like chumps from time to time. Here are a few examples:

• Being logged into multiple databases and accidentally updating the live one with test data.
• Deleting the production (i.e. prime-time) database entirely.
• Forgetting to add an exit condition to a code-block and being stuck in an endless loop. (Bonus points if you lock up the AS/400 shared by the entire school computer lab. Double bonus points if you knock the development database server offline--your fellow programmers will loooove you for that.)
  
• (My personal favorite) Driving yourself up the wall (and across the ceiling and down the other side) debugging a gremlin that's not your code at all, but rather a file/database permission problem.
• Spending weekends, birthdays, holidays, etc. at the office because no one else really groks that part of the code-base, and deadlines only care about one date in the calendar.
  
• Writing a boatload of low-level code before learning that the language in question already has an API to deal with that...in a handful of function calls.
• Having to modify crufty old code, and kvetching both loudly and publicly about how awful it is before realizing that you wrote it.
• Misplacing source code...or at least neglecting to archive the latest & greatest working version before you hose it up twelve ways to Sunday.
• The flip side: Fixing/improving/augmenting code and seeing it overwritten by the version control software (whether it's your screw-up or not).
  
• Watching some over-confident n00b make a complete mess of your code.
  
• Watching some over-confident n00b make complete code from your mess. (Frankly, I can't decide which is worse.)
• Seeing the programming language on which you cut your teeth become obsolete.
  
• Seeing "your" application retired.
• Having to learn a new language under a project deadline.
• Breaking the build.
• Missing a deadline because you thought, "How hard can that be?"
• Blaming the web server for caching obsolete code when, in fact, you forgot to promote your changes.
  

Not, mind you, that I've ever actually done of any of these things... [lily-white innocent look] And, doubtless, such dues can be paid in hundreds of other "currencies" besides. Fortunately, there seems to be an inverse relationship between the severity of any screw-up and the likelihood of it been made again (at least by you). But whatever the case, the silver lining of any mistake, mishap or misfortune is adding it to your collection of war stories.