Developers make more mistakes than any other profession I can think of. The editor you use finds some. Your compiler finds some. Your unit tests find some. Static analyzers find some. The QA team finds some. And, as we all know all too well, your customers find some.
I was recently talking to a friend and co-worker about developer mistakes and we reached a valuable conclusion: senior developers don’t make rookie mistakes. The result is that it appears that they make fewer mistakes, but the quantity isn’t what’s important. Senior developers don’t necessarily make fewer mistakes, they simply catch them sooner. No else sees the majority of their mistakes because of the way they perform their work. Senior developers know what it takes to deliver good software and at the critical decision points, they do what it takes to keep things on track.
Ask yourself: When was the last time you made a rookie mistake? If it’s been a couple of years (or a couple of projects), then chances are that you’re firmly in "senior-level" territory. If you’ve made any in the last few months, though, then you might want to spend some time focusing on the way you work instead of adding new tools or techniques to your repertoire.
But what are rookie mistakes?
Maybe a list of rookie mistakes would be a good feature . . . not to do in one sitting, but to accumulate over time.
I think a list would be good for a future post, but in the meantime I'll propose a rule of thumb:
A rookie mistake is one that exposes you to being caught with your pants down.
Some quick examples are: not using version control, not writing tests (unit or otherwise), not documenting your design, starting without clear requirements (they don't have to be complete, just clear), etc.