It seems that often times new programmers and old programmers have a tendency to over-evaluate themselves. They will believe they can do something faster/better than they can, or they might look back at some old code they wrote, and think to themselves “Gee… I used to suck back then, my code is tons better now though”. I call this the violin effect. When someone plays the violin, since they rest their chin on the sound box, often times it effects what they actually hear. Even if they play scratchy and out of key, often times they will presume that they played beautifully, because that’s what they heard. Programmers do the same thing. We have a tendency to normalize our current skill level, to a previous skill level, and then notice how good we are comparatively.
I often see a programmer commenting “I used to write code like that, now I’m better though.” then a two years later they will make a comment “I looked at some code two years back that I wrote… I really sucked back then… It’s a good thing I’m writing good code now” and they will continue making comments about how their old code wasn’t that good, and their new code is much better. In reality, their new code isn’t any better. Its just that they are currently working on it, and they understand it. Later on when they don’t share the mindset of their old code, they realize how much their code sucks.
A lot of this is caused by programmers not planning their code in advance. Instead they write it as they go. As they’re writing out their ideas, they understand what they are trying to do. Once they stop, they don’t see any internal structure, and suddenly their code looks terrible. Planning is an important part of any project, and it is also often overlooked.
Another reason for this is, technology and methodology in the computer industry are advancing faster than virtually any other industry. This is a good thing in my opinion, however, often times programmers assume they are getting better, when in reality, the technology/methodology around them is getting better, and their actual skill level is still about the same.
A recent poll showed 90% of of people working in an intellectual field believe they are above average in their field. Surely, some of them are above average, however, a large amount of them aren’t. We have a natural tendency to assume that we are better than most people, and in some cases we are. The danger occurs when we become biased, basing our assumed skill level not on evidence, but on our own opinion.
I’d argue, you should always try to realize what sucks in your code and try to get better in that area. The moment you’ve stopped realizing what sucks in your code, you’ve stopped improving. However, don’t try to compliment your code by concentrating on the bad things in your old code, and the good things in your current code. In both new and old code, try to notice the bad things and fix them, and also try to notice the good things and reinforce them. If you are unable to balance both tasks, you will just be another one of the 90% who believe they are above average.