Bjarne Stroustrup invented the original C++. Many people refer to the book, and though it certainly has its detractors. The book is not aimed for beginning programmers. Instead, it serves as a reference book to C++. You won't find data structures, nor software engineering in this book.

Still, most people who program in C++ own this book.

For those who don't like Stroustrup, and even those who do, another very good reference book in C++.

Advice on how to improve you C++. What's nice about it is that it's a thin book, and you should be able to read it without taking too much time. Meyers has also written two follow-ups: More Effective C++ and Effective STL.

The authors are called the GoF (Gang of Four). This is supposedly the book on design patterns. Consider it a collection of ways to organize classes to deal with certain kinds of problems. The main gripe I have about the book is the application domain is a bit large (they talk about how to design a word processor). I would have preferred smaller examples, written in C++ and Java (it's mostly in C++). There are other books on Design Patterns, but none of them seem all that good, except for the following.

This book is written like Effective C++. It is a series of tips on writing good Java code. However, it also has advice on design patterns (not a whole lot). You can probably carry over some advice to C++, while you're at it.

This is the 106 textbook. While I have quibbles with this book for its pedagogy (it doesn't talk about tracing code, its treatment of nested loops is weak, it introduces arrays too late), it's a very good C reference book. King really knows his stuff, and he states things concisely. A great book if you want to brush up on your C.

Before this book, perhaps the classic algorithm book was by Aho, Hopcroft, and Ullman. That algorithms book was pretty dense, written as if it were a math book for math majors.

This book gave meaning to the "instant classic". Instant classics occur when someone writes a decent book so thick, no one else would actually write such a book again (although this hasn't prevented other authors from trying).

The proofs in the book are sometimes wordy, taking up a few pages when one page will do, but is generally friendlier than most algorithms books. If you would prefer a more story-like approach to algorithms, read Algorithmics: The Spirit of Computing by David Harel. You won't learn how to solve algorithms, but you should gain some appreciation of algorithms, nevertheless.

This book does some things well (MIPS assembly language) and some things poorly (digital logic design). At the very least, it acknowledges its weaknesses. You're probably better off with the original, Computer Architecture: A Quantitative Approach (3rd edition) by Patterson and Hennessy (the author's names are reversed), since it covers more advanced topics.

West Coast hardware guys vs. East Coast hardware guys. Patterson and Hennessy were the founders of the RISC movement from Berkeley and Stanford, respectively. Bryant and O'Hallaron are from CMU in Pittsburgh.

Like Patterson and Hennessy, this book does less digital logic than similar computer organization books. For some chapters, the writing is excellent. This book also covers some material that would normally be seen in compiler optimization, and talks about ways to make programs fast. Students learn the most if they can also do the labs associated with the book.

One drawback (IMO) is the use of the IA32 ISA (dubbed "y86" since it's a subset of x86). While x86 dominates the CPU market and MIPS is non-existent, MIPS is easier to understand and is a modern RISC CPU. Still, if you have to learn a CISC ISA, it might as well be x86 based.

OK, this isn't for the faint of heart. This kind of book is starting to approach expert level C++, and if you can learn the stuff in here, you're starting to be an ace C++ programmer.

Lots of snippets of advice on how to code. Not specific to any language. You should be able to take something from it, no matter what you read.

OK, so not everyone should own this book, but if you were ever interested in type theory, this is the book to get. This explains the theory behind type-safe languages such as Java and ML. Of course, it talks about lambda calculus. You do have to like some math (say, math logic) to follow the book, but since most books on type theory are aimed at grad students, this book is the one to get because it should be readable by a reasonably mathematical undergraduate (that is, if you like math and intro algorithms, and 330, you should be able to read this book).