The Evolution of a Programmer

I think I am a pretty good programmer. I only feel free to say this because I have had many other people (including other programmers) tell me so over the last many years. I know that there are many programmers out there who are better than I am, and not just hypothetically—I’ve met them in college classes and online. However, it really doesn’t matter how good I am for the sake of this argument. What matters is that I think I am good. And even more importantly, a year ago, I felt exactly the same way about myself. Looking back, I know that I was comparatively lacking in many areas.

This can be a discouraging revelation. Every time I have to work with code that I wrote a year or more ago, it’s all I can do not to bang my head against my keyboard. I always find myself wanting to rewrite the whole function (or class, or website) because I know I could just do so much better now than what I did before. I want to use some new coding model, a new CSS convention, a more efficient database structure, or any other simpler/better/faster technique to make an old convoluted mess into a thing of beauty. Making mere modifications to such blatantly awful code is painful. I feel almost ashamed, even if just a little bit, even if only for a moment inside, to have written code that is sub-par at best.

Recently though, I’ve come to interpret that revelation as an encouragement.

Computer technology is one of the fastest-changing fields around. And I don’t just mean the hardware, which is typically the subject of that sort of statement. The same thing applies to software applications and, by implication, the programming languages used to write them. This is most severely felt in the web application market, where new languages and frameworks seem to come into existence weekly. If you are in the mood to learn something new, there are endless opportunities, many of which could probably benefit your specific job directly in some way.

This is even true if you stay mainly within one language. I’ve been programming almost exclusively in PHP since about 2003, but during the last six years, PHP has undergone many revisions and updates (most notably, a true object-oriented implementation instead of a hack-job imitation). I am constantly learning new tricks, and occasionally learning totally new ideas that change the way I use the language. I wrote my own MVC framework about a year ago, and I learned so much new stuff about PHP during the process that my whole programming paradigm changed. I couldn’t believe that I’d gone so long before learning what seemed so fundamental. That kind of thing doesn’t happen all the time to me, but I do learn how to do my job better on a regular basis.

It’s this learning process that enables me to recognize how bad my old code was, and this is what is so encouraging. If I never realized my old code was bad, it would mean that I hadn’t learned anything new, and that would be a truly disheartening outcome. I would much rather be constantly reminded of how much farther I have progressed than be unknowingly stagnant in a rapidly changing field.

Of course, it is possible that you’re just totally awesome at what you do, and your code is impossible to improve. If that’s the case, please email me so we can set up a brainstorming session. Or perhaps you’re using an ancient language (COBOL or FORTRAN, anyone?) because your job requires it, and you can’t really learn new things because the last language revision was decades ago. But for most web developers, neither of those things are true.

So, even if you don’t need to delve into your old code to fix or modify anything, take a moment sometime and compare what you’ve done in the past to what you do now. Bash your head on the keyboard if necessary; but if you do, realize you’re only inclined to do so because of how much farther you’ve come.