Good programmers

Good programmers write code that can be understood quickly by other programmers and is obviously correct.

Beyond those two criteria, it gets hazy and language-specific.

Good programmers know they're good.

"Obviously correct" comes up with such cool findings I'm leaving it...

It's true that "good programmers know they're good", but it's also true that a lot of bad programmers "know" they're even better.

There's no reliable self-administrable test for being a good programmer. Programmers are delusional by nature. Why else would we do that to ourselves?!

Programming is the art of problem solving. Computer programming specifically is the art of problem solving using computers, usually computer software.

Being a good programmer then involves being a good problem solver. It has nothing to do with being a good coder (though good programmers usually are), writing popular software (just as some movie stars are lousy actors, having written popular software does not necessarily mean one is a good programmer, nor, of course, does it mean that one is not).

A good programmer can see a problem that needs to be solved. He can split it into smaller subproblems. Without losing track of the initial problem he can then treat each subproblem as a problem sui generis, then continue the art of problem solving recursively until he gets to atomic problems, that is problems that can (or should) no longer be subdivided into further subproblems but can be solved with a simple algorithm, a few lines of code, or even a single op code.

The good programmer does not need to solve every subproblem by himself. He may assign (i.e., delegate) any subproblem to another programmer, perhaps not as good as himself, but good enough to solve that particular subproblem. If he does that, it is possible for the good programmer to be good, even very good, without writing a single line of code. Though that is rare because good programmers generally enjoy coding as much as they do programming. Besides, often good programmers have a big ego which makes them think that other programmers and coders would mess up his solution. But that, of course, is a different topic altogether.

You can be a genius as a person, but if your code isn't readable and maintainable, you are not a good programmer.
  -   Words of wisdom from a coworker.

Any fool can write a program that the computer can understand. It takes a good programmer to write a program that other people can understand.
  -   Words of wisdom from Martin Fowler.

A charlatan makes obscure what is clear; a thinker makes clear what is obscure.
- Hugh Kingsmill

Good code is its own best documentation. As you're about to add a comment, ask yourself, 'How can I improve the code so that this comment isn't needed?' Improve the code and then document it to make it even clearer.
- Steve McConnell in Code Complete

Most of you are familiar with the virtues of a programmer. There are three, of course: laziness, impatience, and hubris.
- Larry Wall

The characteristics of a good programmer have nothing to do with talent and everything to do with a commitment to personal development.
- Jeff Atwood

Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.
- Brian W. Kernighan

You know you've achieved perfection in design, not when you have nothing more to add, but when you have nothing more to take away.
- Antoine de Saint-Exupery in Wind, Sand and Stars

The trouble with the world is that the stupid are cocksure and the intelligent are full of doubt.
- Bertrand Russell

When asked, most individuals will describe themselves as better-than-average ... Clearly a large number of the self-described "above average" individuals are actually below average ... and they are simply unaware of their incompetence.
Unskilled and Unaware of It: How Difficulties in Recognizing One's Own Incompetence Lead to Inflated Self-Assessments
Justin Kruger and David Dunning
Department of Psychology
Cornell University

Good programmers think that they might do good if they try, but bad programmers just know that they're good.
Good programmers suspect that there's always room for improvement, and they look for it. Bad programmers are complacent.
Good programmers learn and get better. Good programmers are mindful that there are many ways that things can be better: shorter code, more readable and maintainable code, neater code, a more elegant expression of the algorithm, a lower bug count, or simply producing code faster.

Good programmers read a lot.

They constantly keep abreast of new technology that might make their jobs and lives easier and more productive and they never stick their head in the sand or allow themselves to stagnate.

Knowing how to get the most out of books is crucial. Good programmers don't re-invent the wheel. Bad programmers re-invent the wheel at the drop of a hat and do it badly because they fail to learn from others' past mistakes.

Here are a few good books to get you started:

• The Pragmatic Programmer: From Journeyman to Master by Andrew Hunt and Dave Thomas.
• Code Complete by Steve McConnell
• The Practice of Programming by Brian Kernighan, Rob Pike

There's enough reading there to keep even an unusually bright geek thinking for a WHILE. If you're not thinking while you're reading you're not doing it right. Read actively making sure you're understanding the words going by and not just breezing over them.

Good programmers are facile with a number of different languages. if you're a hard core Perl nut why not try a more truly object oriented language like Ruby or dare I say it Java? If you've been doing scripting for a while why not do a project in c++?

Good programmers are always stretching the boundaries of their skills.

Good programmers do it because they enjoy it, not because it represents greener pastures.