Writing Efficient Programs

by Jon L. Bentley

Book Overview

No Synopsis Available.

• Format: Hardcover
• Language: English
• ISBN: 0139702512
• ISBN13: 9780139702518
• Release Date: January 1982
• Publisher: Prentice Hall
• Length: 170 Pages
• Weight: 0.95 lbs.

Customer Reviews

Computer Science

Writing Efficient Programs, by Jon Louis Bentley, illustrates to the reader how the primary task of a software designer is the development of programs that are not only useful, but easy and inexpensive to maintain. Moreover, the book explores how software must have specific application as well as versatility to me modified for unforeseen uses. Lastly, efficient programs must be efficient to write as the cost of writing will determine their competitiveness in the software market.

Dated, but still valuable

Bentley has the right idea when he states that you first write a correct, understandable and maintainable program, and then if it is not fast enough, modify it to improve the efficiency. He is also correct in pointing out that with this approach, modifications to improve efficiency, while not altering the correctness of the program, tend to reduce the clarity and maintainability of the code. However, he does miss one important point, which in his defense, is to a large extent due to the date of original publication. With the availability of modern tools and advances in software design, it is now possible to create programs where the efficiency of the code can be part of the design. Changes in the design made to improve the efficiency can increase the maintainability and reduces the need for final alterations that lower the clarity and portability. These points aside, the techniques that are demonstrated to improve the efficiency of code are a lesson in what is really happening as we code. Bentley starts with a simple example of making a change to a correct program that he expects to dramatically increase the speed only to see it improve by a few percent. That is exactly what happened to me when I was a commercial coder and faced with my first problem with code that was too slow and had to be improved. The problem of course was that the change does increase the speed, but that segment of code is not called often enough for the change to be dramatic. Increasing the efficiency of code is a job to be done with a sharpshooter's rifle rather than an indiscriminate shotgun. The only really effective changes to code are those that increase the speed of the code that is actually used. Since this is often dependent on the circumstances, which includes the current data sets, this is often as much an art as it is a science. While code profilers can be an enormous help, sometimes you simply must know the circumstances where the code will be used. Bentley also gives some sound advice in that area. Bentley's first example of code improvement, where he uses simple techniques to get an order of magnitude improvement in speed is the best example of code improvement that I have seen. The fact that it is written in the largely obsolete Pascal language does not render the example obsolete in any way. He takes an example of code to do a shortest-path search and demonstrates some of the common "mistakes" done in code that can reduce efficiency. In this case, many of the changes do not alter the clarity of the code and are an example of the point made in the first two paragraphs of this review. The general consensus was that the best IT book of 1999 was "Refactoring: Improving the Design of Existing Code" by Fowler et. al. While reading "Refactoring . . . ", I continually thought back to this book by Bentley, as many of the same ideas for code improvement appear in both books. Even though hardware continues to be dramatically improved, there are still many situati

Classic on Practical methods of optimizing programs

Jon Bentley is recongized as one of the great authorities on Computer Programming and also as one of the best writers in the field. In this book he gives practical advice on improving the efficiency (optimizing) and the limits there of. While showing how to trade off speed for space or vice-versa, he points out the limits that can be expected to gain. His list of techniques is a collection of practical approaches rather than theoretical possibilities.At 158 pages (not counting index) this book is eminently readable, accessable and useful. Clearly written and well organized this is a book to keep on your shelf for when a program needs improving. It is also a book to read before a program as a reminder not to make things complicated with optimization that aren't needed.