countdown boutiques-francophones Beauty home Kindle sports Tools



There was a problem filtering reviews right now. Please try again later.

on May 29, 2002
I have programmed for 20 years, and there are references in this book older than that. However, this touches on the principles and that can make you think more about how you code and the impact it will have on performance. The writing style of the book can be confusing at times, and that is probably why I would not give this 5 stars. It seems like these were supposed to have been articles in some Computer periodical and put together as a book. If you are looking for a book on programming as a craft this would be a book to own.
0Comment|Was this review helpful to you?YesNoReport abuse
I consider this book a classic. Written in 1986, Bentley engages in some of the best deconstruction and explanation of programming problems that I have ever seen. While it is true that the constraints he discusses are in the distant past, his methods of finding solutions will forever remain part of the programmer's toolbox.
Programmers who have been raised on larger memory units and faster processors tend to ignore concepts such as frugal memory usage and efficient code. When I was a commercial coder, some of the newbies were encountering a bug they could not find. The memory bounds were being exceeded and they simply could not comprehend that they were running out of memory. Forced to fit the data within bounds, it took a great deal of effort to teach them some of the "old-style" techniques of memory management and program efficiency. To prepare for my explanations, I went back and consulted this book to brush up on some of the ideas.
The topics covered are: finding efficient algorithms by solving general problems rather than specific instances, how to verify the correctness of programs, using "back of the envelope calculations" to quickly verify the effectiveness of code, how to squeeze space and some examples of programs. Bentley also refers to the book ,"How To Solve It" by George Polya, a book that should be required reading for all developing programmers.
Bentley is a very good explanatory writer and I can understand why he has received awards for excellence in teaching. Until we develop intelligent robots that will write code for us, the ideas in this book will continue to be useful.
0Comment| One person found this helpful. Was this review helpful to you?YesNoReport abuse
on February 5, 2002
Eu já havia lido os dois volumes da primeira edição, os quais considero de alto nível. A segunda versão está impecável. Tenho usado na preparação de aulas para cursos de graduação e recomendo a sua leitura a todos que se interessam por programação.
0Comment|Was this review helpful to you?YesNoReport abuse
on November 30, 2001
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.
0Comment| 2 people found this helpful. Was this review helpful to you?YesNoReport abuse
on November 7, 2001
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.
0Comment|Was this review helpful to you?YesNoReport abuse
on September 21, 2001
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!)
0Comment|Was this review helpful to you?YesNoReport abuse
on July 13, 2001
One of a few books I'd suggest every programmer read. For two reasons:
o the technical material is well-chosen and well-explained o the writing style is worthy of emulation
Overall, it's worthy of your bookshelf's space.
0Comment|Was this review helpful to you?YesNoReport abuse
on June 17, 2000
The thirteen columns in this book appeared in the Communications of the ACM between 1983 and 1985. There can't be more than a couple of technical books on computing from that era that are still worth reading. Kernighan & Ritchie's book, "The C Programming Language", is one that springs to mind; this book is definitely another, and will probably outlast K&R as it has almost no ties to existing or past hardware or languages.
What Bentley does in each of these columns is take some part of the field of programming--something that every one of us will have run into at some point in our work--and dig underneath it to reveal the part of the problem that is permanent; that doesn't change from language to language. The first two parts cover problem definition, algorithms, data structures, program verification, and efficiency (performance, code tuning, space tuning); the third part applies the lessons to example pseudocode, looking at sorting, searching, heaps, and an example spellchecker.
Bentley writes clearly and enthusiastically, and the columns are a pleasure to read. But the reason so many people love this book is not for the style, it's for the substance--you can't read this book and not come away a better programmer. Inefficiency, clumsiness, inelegance and obscurity will offend you just a little more after you've read it.
It's hard to pick a favourite piece, but here's one nice example from the algorithm design column that shows how little the speed of your Pentium matters if you don't know what you're doing. Bentley presents a particular problem (the details don't matter) and multiple different ways to solve it, calculating the relationship between problem size and run time for each algorithm. He gives, among others, a cubic algorithm (run time equal to a constant, C, times the cube of the problem size, N--i.e. t ~ CN^3), and a linear algorithm with constant K (t ~ KN). He then implemented them both: the former in fine-tuned FORTRAN on a Cray-1 supercomputer; the latter in BASIC on a Radio Shack TRS-80. The constant factors were as different as they could be, but with increasing problem size the TRS-80 eventually has to catch up--and it does. He gives a table showing the results: for a problem size of 1000, the Cray takes three seconds to the TRS-80's 20 seconds; but for a problem size of 1,000,000, the TRS-80 takes five and a half hours, whereas the Cray would take 95 years.
The book is informative, entertaining, and will painlessly make you a better programmer. What more can you ask?
0Comment|Was this review helpful to you?YesNoReport abuse
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.
0Comment|Was this review helpful to you?YesNoReport abuse
on December 18, 1999
It's great to see they've come out with an update to this book. The essays in this book are easy to read and touch on many valuable things, such as tuning and optimization of algorithms, using mini languages to provide robust tools, doing back-of-the-envelope calculations, and much more. I have recommended this book to several beginning programmers that I know as an excellent introduction to thinking effectively about the challenges of software engineering.
0Comment|Was this review helpful to you?YesNoReport abuse