Ihren Artikel jetzt
eintauschen und
EUR 0,10 Gutschein erhalten.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen

Writing Efficient Programs (Prentice-Hall Software Series) (Englisch) Taschenbuch – Mai 1982


Alle 2 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Taschenbuch
"Bitte wiederholen"
EUR 64,65 EUR 11,96
4 neu ab EUR 64,65 7 gebraucht ab EUR 11,96
Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.


Produktinformation

  • Taschenbuch: 170 Seiten
  • Verlag: Prentice Hall (Mai 1982)
  • Sprache: Englisch
  • ISBN-10: 013970244X
  • ISBN-13: 978-0139702440
  • Größe und/oder Gewicht: 15 x 0,9 x 23 cm
  • Durchschnittliche Kundenbewertung: 5.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 475.607 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Kundenrezensionen

5.0 von 5 Sternen
5 Sterne
1
4 Sterne
0
3 Sterne
0
2 Sterne
0
1 Sterne
0
Siehe die Kundenrezension
Sagen Sie Ihre Meinung zu diesem Artikel

Die hilfreichsten Kundenrezensionen

1 von 1 Kunden fanden die folgende Rezension hilfreich Von Dr. Chrilly Donninger am 27. April 2014
Format: Taschenbuch Verifizierter Kauf
Dieses Buch lese ich immer wieder. Die Beispiele sind inzwischen teilweise etwas angegraut. Aber der Geist der durch die Zeilen weht hat zeitlose Gültigkeit. Das Studium hat auch eine therapeutische Wirkung. Es graust mir, wie sorg- und ahnungslos heute mit den Ressourcen umgegangen wird. Es geht mir wie meinem Vater der ausgerastet ist, wenn man Brot weggeworfen hat. Als meine Schwester das Auto zu Schrott gefahren hat war hingegen seine Reaktion "Hauptsach dir ist nix passiert".

So sind in typischen Java-Anwendungen nur ein Bruchteil des Heap-Spaces Nutzdaten ([1],[2]). Das viel gefeierte "Effective Java" von J. Bloch ist eine effektive Anleitung möglichst ineffizienten Kode zu schreiben. Wenn der Grausen wieder einmal zu gross wird, ziehe ich Bentley oder Knuth aus dem Bücherregal und bewundere die Kunst und die Sorgfalt der Zen-Meister. Ich stell zu meinem Schrecken fest, dass auch meine eigenen Programme teilweise schon unnötig aufgebläht geworden sind. Und tröste mich damit, dass sie im Verhältnis was sonst so üblich ist noch immer sehr schlank und rank sind.

Man müsste eine moderne Fassung dieses Buches schreiben dass sich z.B. mit effizienten Datenstrukturen in modernen Sprachen wie Java oder den dynamischen Sprachen wie Javascript beschäftigt. Teilweise ist das allerdings ein Widerspruch in sich selbst. Wenn man einmal ein größeres Programm in Javascript schreibt, ist die Bande frommer Scheu vor den Ressourcen sowieso schon gefallen.
Ein derartiges Buch könnte
Mitchell N., Schonberg E., Sevitsky G.: Efficient Java: A Practical Guide to Memory-Conscious Programming
sein. Es ist allerdings schon seit längerem angekündigt und noch nicht erschienen.
Lesen Sie weiter... ›
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 6 Rezensionen
9 von 9 Kunden fanden die folgende Rezension hilfreich
Classic on Practical methods of optimizing programs 8. August 2001
Von Richard Frantz Jr. - Veröffentlicht auf Amazon.com
Format: Taschenbuch
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.
8 von 9 Kunden fanden die folgende Rezension hilfreich
Dated, but still valuable 2. Juni 2002
Von Charles Ashbacher - Veröffentlicht auf Amazon.com
Format: Taschenbuch
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 situations where code must be improved and this book will teach you many facets of this essential skill.
2 von 2 Kunden fanden die folgende Rezension hilfreich
Classic that is still worth reading 10. Oktober 2012
Von Marc Magrans De Abril - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I read this book because I came across its name several times from different respectable sources. As far as I remember it was cited at least in Code Complete and Network Algorithmics. However, I also remember seeing the same reference in other places.

So, after considering several times the usefulness of reading something from the 1982, I read it. I was surprised by the applicability of the book on today's programs. I guess that these tricks are of less importance if you work on Ruby/Python/etc. Nonetheless, it helps to understand the possibilities and limitations of computers.

It is worth the time you will spent reading its 170 pages.
2 von 2 Kunden fanden die folgende Rezension hilfreich
Computer Science 26. September 2008
Von Carlos Jorge - Veröffentlicht auf Amazon.com
Format: Gebundene Ausgabe
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.
1 von 1 Kunden fanden die folgende Rezension hilfreich
Writing Efficient Programs (Paperback) by Jon Louis Bentley 22. Juli 2012
Von Daniel - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
Jon Bentley is a master at teaching efficient programming methods using the AWK programming language as an example language. This shoudl be required reading for programmers.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.