Also, it should have a short appendix explaining that you do not get geek brownie points simply by using as many patterns as you can think of.
I realize these are not problems with the book per se, and it's worth reading, but some developers seem to get the wrong message from it.
Not really. I've found a use for design patterns in just about every language I've used. They're not all equally useful, but that was never the book's claim.
It's become a little fashionable to be cynical about Design Patterns, but most of them have held up well. A few of the patterns were always obscure (even at the time of writing), and a few others are trivially implemented in newer languages, but honestly, there are a lot of people who are doing a poor job of re-implementing the patterns, then doing an worse job of communicating their work. There's something useful about the notion of a consistent engineering vocabulary.
Also, I talk to a lot of people who claim to hate Design Patterns, but haven't actually read the book. They've used Java, decided that they hate Singletons and Factories, and thrown the baby out with the bathwater. There's a lot more to the book than just Singletons and Factories.
Well this is just wrong! I would call them good languages but that just my opinion.
I have never really found it helpful to think about these patterns. Witch one do you find helpful to think about?
Lots of people seem to independently "re-invent" the Observer and Visitor patterns (badly), which is a shame, because there's lots of room for subtlety in their implementations. And of course, Ruby makes use of Interpreter all over the place, and frameworks like Rails use Command, Chain of Responsibility, Mediator, Template Method, and so on...but don't really call them by their names. Blargh.
What sets these books apart is that they try to tackle the problem of _how_ to design elegant algorithms. In the process they introduce crucial concepts like invariants which, once you understand them, become indispensable tools in reasoning and designing algorithms.
More generally, their stress on elegant proofs develops a taste for mathematical elegance which would serve all programmers well as they design new systems.
These books are much too under-appreciated, in my opinion.
I reread Pragmatic Programmer every year.
The other two you mention I find pretty poor, to be honest. I may reference them once in a while, but to really understand the topics they cover I'll rely on a well written, colorful article over those books.
In general I've found books written by more than 2 authors to be quite boring, impersonal, and oftentimes misleading.
Code Complete and Pragmatic Programmer are two of my favorites alongside C, and the Practice of Programming.
Design Patterns are only needed if your language is not powerful enough.
In assembler subroutines and classes are design patterns.
For what it's worth, it's the same imprint that gave us the pickaxe book (Programming Ruby), so perhaps that ought to be a point in it's favour.
Code Complete is a fine book. The Pragmatic Programmer is okay. But neither book holds a candle to Introduction to Algorithms for career-long usefulness. For that matter, neither one holds a candle to Design Patterns for the ability to expand your mind and improve your ability to think about code (I read both at the same time, and Design Patterns is the only one whose lessons I remember distinctly, years later).
I think the main problem here is that the easy, mechanical reads get more votes than books that are harder, but more valuable. It's the technical equivalent of a lolcat photo.