Here's a list of useful programming articles I've compiled over the years:
Teach Yourself Programming In 10 Years - a more realistic response to the dozens and dozens and dozens of books titled "Teach Yourself [Insert Favorite Language Here] In 24 Hours". The author explains that no one can pick up one of those books and suddenly master a language in 24 hours, or even months. Programming is an acquired skill, not a fabulously easy thing that anyone can pick up in a few days. In reality, true programming expertise, like any other subject, takes about 10 years to develop.
Pounding A Nail: Old Shoe Or Glass Bottle - an article by Alex Papadimoulis (the same guy who runs the The Daily WTF blog) which explains the a bizarre tendency that programmers have to enable newbies to write atrocious code.
Revenge of the Nerds - an boring, cliche title to an otherwise fascinating and interesting article. The author explains how many major languages today (or 2002 when the article was written) are finally catching up to 1958. Many languages becoming more and more LISP-like over time, copying featuers of the language that have existed for decades. For example, many languages are sporting lambda functions, anonymous functions + closures, have support for passing functions as argunments to other functions (this is the basic idea behind a delegate in C#), etc.
The Rise and Fall of Homo Logicus - contains an excerpt from a book The Inmates Are Running the Aslum by Alan Cooper. The excerpt explains one of the most pervasive management mistakes in software development: letting developers design software. Developers are experts are using their computers, and they unintentionally design software from a developer's point of view (i.e. to give the user / developer as much control over the program as possible). The developer loves complexity, but unfortunately for the developer, completely clueless people are using her software. Here's a follow up along the same lines.
Beating the Averages - another Paul Graham article where he remarks on peculiar tendency of programmers:
Programmers get very attached to their favorite languages, and I don't want to hurt anyone's feelings, so to explain this point I'm going to use a hypothetical language called Blub. Blub falls right in the middle of the abstractness continuum. It is not the most powerful language, but it is more powerful than Cobol or machine language.
And in fact, our hypothetical Blub programmer wouldn't use either of them. Of course he wouldn't program in machine language. That's what compilers are for. And as for Cobol, he doesn't know how anyone can get anything done with it. It doesn't even have x (Blub feature of your choice).
As long as our hypothetical Blub programmer is looking down the power continuum, he knows he's looking down. Languages less powerful than Blub are obviously less powerful, because they're missing some feature he's used to. But when our hypothetical Blub programmer looks in the other direction, up the power continuum, he doesn't realize he's looking up. What he sees are merely weird languages. He probably considers them about equivalent in power to Blub, but with all this other hairy stuff thrown in as well. Blub is good enough for him, because he thinks in Blub.
When we switch to the point of view of a programmer using any of the languages higher up the power continuum, however, we find that he in turn looks down upon Blub. How can you get anything done in Blub? It doesn't even have y.
By induction, the only programmers in a position to see all the differences in power between the various languages are those who understand the most powerful one. (This is probably what Eric Raymond meant about Lisp making you a better programmer.) You can't trust the opinions of the others, because of the Blub paradox: they're satisfied with whatever language they happen to use, because it dictates the way they think about programs.