Rating: 
Summary: Wow!
Review: This book is amazing! Its a true classic on algorithims.I would place this on my list of the top 5 programming books of all time. A must read for every who calls themselves a "programmer".
Rating:
Summary: A classic that will always be readable
Review: This book is timeless because it discusses recurring problem situations with elegance, clarity, and insight. The book is about thinking and problem-solving more than it is about the particular circumstances it discusses. For instance, the very first chapter ("Cracking the Oyster") would seem to be about the problem of sorting on disk: surely an archaic concern in these days of 1+GB RAM and 100 GB online media on PCs. But that would entirely miss the point, which Bentley clearly summarizes for us in the "principles" section of this chapter:
* "Defining the problem was 90 percent of this battle..."
* Select an appropriate data structure
* Consider multiple-pass algorithms
* A simple design: "a designer knows he has arrived at perfection not when there is no longer anything to add, but when there is no longer anything to take away." -- St. Exupery This advice might look like a string of old, worn-out chestnuts as set forth above. But within the context of the specific problem, we can see how the design challenges and solutions follow each other, through several iterations, culminating in a pretty solution, nicely illustrating the principles, and suggesting their relevance to other problems, too. A thoughtful programmer, no matter whether her domain is machine language or OODBMSes, will come away from any chapter in this book full of new ideas and inspiration. Problems (good ones) after each section encourage the kind of rumination that is necessary to derive the most from this book. Every few years I take it (and its companion, "More Programming Perals") off the shelf and dip into it again, and always come away enlightened.
Rating: 
Summary: Out of date
Review: This book was useful in 1983, when professional programmers were still coding in assembler, and there was a need to get high-performance software into a small space (like 12K!). But the world has moved on. Performance will always be a key issue, but the performance problems of the modern world typically do NOT lie in the areas which this author is enthusiastic about: the choice of sort algorithms. A lot of software doesn't do any sorting at all, but retrieves records from a relational DB pre-sorted by the SQL statement. (In this world, the DB vendor will be acutely aware of sort performance!) But software has grown huge since 1983. Various techniques have evolved to handle this hugeness: structured analysis, modular design, and object-oriented techniques most recently. Most professional software engineers spent a LOT more time defining interfaces (and repairing them, or migrating them) then they will ever spend tweaking a sort algorithm. After all, as the wise old programmer said, if you're only sorting a dozen things (or even two dozen), a bubble sort is the way to go: easy to code, easy to understand, a little slow, but with machines running at 2 gigahertz it all happens in less than a millisecond anyway. I think you would be much better advised to read "Rapid Development" by Steve McConnell. That book is an excellent overview of modern software engineering issues and practices, and discusses dozens of essential things not even mentioned in this book (source code control, development cycles, release management, coding to requirements, and so on and on and on!)
Rating:
Summary: doesn't get much better
Review: this is a thinking man's book. Lots of puzzles to get you thinking about proper data structure design, choice of alrogithm, and optimization. I like how it doesn't 'dumb down' and explain every last detail. Bentley is also an entertaining writer. There are answers to select questions that appear at the end of each chapter.
Rating:
Summary: Jon Bentley's small book is itself a pearl...
Review: This slender volume is one of the all-time classics for programmers. Each chapter is an essay from Bentley's wide-ranging programming column dealing with an algorithm, an engineering principle or some more general technique of reasoning. Beginners and experienced professionals alike will be delighted. This is one of the few books for serious programmers which can also be read with pleasure by the non-expert, even by the non-programmer. You'll find the techniques of thinking explained in this book popping up again and again whether you are coding or reading the newspaper. I have owned and loaned I don't know how many copies; nobody ever returns it.
Rating:
Summary: Great mental warm-up
Review: With tight schedules it is often easy to forget to ask the question "Why do you want this?" If you help other coders solve problems like I do, you are often approached with a solution that "needs to go faster." This book has paid for itself with just the fact it reminds me to ask this question.
If you are a very experienced programmer you probably won't find much new, but you might find lending it to other people allows you to get more done. Teach a person to fish...
Rating:
Summary: The Pearls Still Glitter After a Decade
Review: Without any doubt, my favorite article in _Communications of the ACM_ in the 1980's was the regular 'Programming Pearls' articles by Jon Bentley. When the first edition of these collected gems was published, I read it with great delight. Now, over a decade later, a second edition has been published, containing the same problems with additional modifications and notations. Given the enormous changes in programming since the mid 80's, your first reaction might be that this book is dated and therefore irrelevant. Nothing could be further from the truth.
Elegant solutions to complex programming problems are free from the rot of time. Programming is a thought process largely independent of the notation used to write it down. The solutions are sketched and explained rather than coded, and the solutions are complete. There is a certain mystique about taking a complex problem, finding an initial solution and then refining it down until it kicks some big time. There are some major lessons in program refinement explained in these solutions.
Coding a binary search is covered quite extensively, which may seem like a waste of space, as this problem was solved decades ago. However, that solution took decades to get right, and this is one of those "separates the coders from the key bangers" type of problem. Other problems examined include performance tuning, squeezing space and program correctness. While the improvement in the performance of the hardware has been astounding since these solutions were written, that does not make them obsolete. The complexity of the programs that we now build has risen even faster, so performance and space considerations are just as critical.
Some problems were here at the beginning and will still be here at the end. Even though there may be canned code to handle them, these problems are generic enough that the solutions can be applied elsewhere, so we must learn how to solve them. Understanding these problems and their solutions will give you a fundamental skill set that will serve you well for a long time.
| 
