Facebook Twitter Pinterest <Einbetten>
Gebraucht kaufen
EUR 17,85
+ EUR 3,00 Versandkosten
Gebraucht: Sehr gut | Details
Verkauft von MEDIMOPS
Zustand: Gebraucht: Sehr gut
Kommentar: Von Europas Nr.1 für gebrauchte Bücher und Medien. Gelesene Ausgabe in hervorragendem Zustand.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Hörprobe Wird gespielt... Angehalten   Sie hören eine Hörprobe des Audible Hörbuch-Downloads.
Mehr erfahren
Dieses Bild anzeigen

Why Programs Fail. A Guide to Systematic Debugging (Englisch) Taschenbuch – 11. Oktober 2005

5.0 von 5 Sternen 2 Kundenrezensionen

Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Preis
Neu ab Gebraucht ab
Taschenbuch
"Bitte wiederholen"
EUR 34,59 EUR 17,85
6 neu ab EUR 34,59 7 gebraucht ab EUR 17,85
click to open popover

Es wird kein Kindle Gerät benötigt. Laden Sie eine der kostenlosen Kindle Apps herunter und beginnen Sie, Kindle-Bücher auf Ihrem Smartphone, Tablet und Computer zu lesen.

  • Apple
  • Android
  • Windows Phone

Geben Sie Ihre Mobiltelefonnummer ein, um die kostenfreie App zu beziehen.

Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.



Produktinformation

Produktbeschreibungen

Pressestimmen

"James Madison wrote: 'If men were angels, no government would be necessary.' If he lived today, Madison might have written: 'If software developers were angels, debugging would be unnecessary.' Most of us, however, make mistakes, and many of us even make errors while designing and writing software. Our mistakes need to be found and fixed, an activity called debugging that originated with the first computer programs. Today every computer program written is also debugged, but debugging is not a widely studied or taught skill. Few books, beyond this one, present a systematic approach to finding and fixing programming errors." - from the foreword by James Larus, Microsoft Research "Andreas Zeller seeks to equip you with a comprehensive arsenal of techniques and the appropriate mind-sets for employing them." Rick Wayne, Software Development, January 2006

Synopsis

"Why Programs Fail" is about bugs in computer programs, how to find them, how to reproduce them, and how to fix them in such a way that they do not occur anymore. This is the first comprehensive book on systematic debugging and covers a wide range of tools and techniques ranging from hands-on observation to fully automated diagnoses, and includes instructions for building automated debuggers. This discussion is built upon a solid theory of how failures occur, rather than relying on seat-of-the-pants techniques, which are of little help with large software systems or to those learning to program. The author, Andreas Zeller, is well known in the programming community for creating the GNU Data Display Debugger (DDD), a tool that visualizes the data structures of a program while it is running. This title is a winner of a 2006 Jolt Productivity Award for Technical Books. It shows how to reproduce software failures faithfully, how to isolate what is important about the failure, and to discover what caused it. It also describes how to fix the program in the best possible way, and shows how to create your own automated debugging tools.

It includes exercises and extensive references for further study, and a companion website with source code for all examples and additional debugging resources.

Alle Produktbeschreibungen

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?

Kundenrezensionen

5.0 von 5 Sternen
5 Sterne
2
4 Sterne
0
3 Sterne
0
2 Sterne
0
1 Stern
0
Beide Kundenrezensionen anzeigen
Sagen Sie Ihre Meinung zu diesem Artikel

Top-Kundenrezensionen

Format: Taschenbuch
Die Übersicht im Tool Bereich ist klasse und sehr ausführlich.
Es werden verschiedene valgrind plugins gezeigt, genau wie
Debugger, asserts und Logging (z.B. log4j).
Immer wieder wird auf das systematische testen von Thesen eingegangen. Der Autor baut von einfachen Mitteln wie dem führen
eines Logbuches bis zum maschinellen finden der Bug-relevanten Diffs Schritt für Schritt die Methodik auf.
Der rote Faden, die Systematik beim debuggen, ist wirklich gut dargestellt und wird mit gut gewählten Beispielen untermauert.
Ich kenne nichts vergleichbares in diesem Themengebiet: ein sehr empfehlenswertes Buch.
Kommentar 7 Personen fanden diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden
Format: Taschenbuch
Die Übersicht im Tool Bereich ist klasse und der rote Faden,
die Systematik beim debuggen, ist wirklich gut dargestellt.
Ein sehr empfehlenswertes Buch.
Kommentar Eine Person fand diese Informationen hilfreich. War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Missbrauch melden

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 4.7 von 5 Sternen 6 Rezensionen
15 von 17 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen From the creator of the GNU Data Display Debugger (DDD)... 26. Juli 2006
Von Fernando Berzal Galiano - Veröffentlicht auf Amazon.com
Format: Taschenbuch
"Why programs fail" attempts to provide a systematic approach to finding, reproducing, and fixing programming errors, with a strong focus on the automation of many debugging techniques. Zeller covers the whole debugging process:

- Problem-tracking systems are discussed, not only as tools for tracking and managing problem reports, but also as valuable idea repositories and requirements management systems.

- You will also find advice on how to set up automated tests that support debugging tasks.

- Apparently straightforward, reproducing problems can be harder that it seems, as "heisenbugs" testify (i.e. when debugging tools interfere with the problem so that it disappears when it is being observed).

- Delta debugging, an interesting application of the classical divide-and-conquer strategy, provides an automated method to simplify test cases (and focus on the truly relevant part of the problem).

- Applying the scientific method is the right way to debug (i.e. reasoning about programs to create hypotheses and performing experiments to validate or discard those hypotheses). Here, the use of a debugging logbook helps to make debugging explicit by writing down all hypotheses and observations.

- Plenty of techniques for creating hypothesis and determining the failure cause of an observed problem are covered, from static analysis tools and introducing assertions, to experimental techniques that try to make debugging more efficient.

"Why programs fail" is outstanding. Many interesting (and practical) ideas are explored. If you would like to improve your detective skills, this book is highly recommended.
8 von 8 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Elevate your Debugging 25. August 2008
Von Claude E. Smoot - Veröffentlicht auf Amazon.com
Format: Taschenbuch
Andreas Zeller created the GNU Data Display Debugger. That
fact set my expectations for this book. I was not
disappointed. Being a developer for over 15 years, I was
pleasantly surprised at the advances in debugging presented
in this book.

The great benefit of this book is that it uses the
scientific method to create a formal discipline for
debugging. This discipline can be automated in ways that
were unthought-of until recently. One example of this is
the DDCHANGE plug-in for Eclipse that automatically
identifies which of multiple code changes has introduced a
given bug.

I found no major faults in this book. The author's style
of writing is very enjoyable. The only thing I'd change is
to drop the second chapter as it contains material on defect
tracking that is covered elsewhere (unlike the rest of the
material where this book is pretty much the sole source of
information).

This is a fabulous book that any serious developer should
read.
6 von 10 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Extremely thoughtful 5. November 2005
Von ALQ - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
As a practionner I am delighted to see a systematic method applied to software. Too often is writing software compared to art or magic, while more often that not it is a matter of rigour, analysis and rational thinking (intuition does not hurt of course). The author attacks the problem of dealing with software defects with method and his analysis is sound. This book is a very welcome help to developers but can also help the quality assurance departement.
5 von 9 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen Lots of interesting ideas 2. Juni 2006
Von Paul Floyd - Veröffentlicht auf Amazon.com
Format: Taschenbuch
This book contains perhaps a bit too much general background. After all, there are already many shelfloads of books out there that cover things like design and project management.

Otherwise, there are lots of things that sound quite interesting. Plenty of references to real products (both commercial and freeware). Clearly the author has extensively researched the field (being one of the authors of DDD probably helped).

Delta debugging, parallel debugging and omniscient debugging all look very interesting. There seem to be more tools available for Java than for other languages. This is probably a reflection of the ease of debugging the JVM. As a C and C++ programmer, I was a bit envious of this situation.
1 von 3 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Building Manageable Software 29. Dezember 2008
Von coder - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I think this should be the title of this book, because "Andreas Zeller" not only talking about dry methods of managing and debugging software code but he teaches how to draw a full picture of your software project "from the design till delivering fixes and updates", this book helps you solve future software problems by building software that is fixable and manageable. "Andreas Zeller" is a good text book writer he move by subject from the bottom up smoothly to support deep understand, so, I ask him to write a book about "Software Design Patterns and System Resources Management" using same way followed in writing his book and with cooperation with the Author of "Design Patterns" "Christopher G. Lasater" he is a good writer too.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.