The Art of Debugging with GDB and DDD und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
EUR 25,95
  • Alle Preisangaben inkl. MwSt.
Nur noch 1 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Menge:1
The Art of Debugging with... ist in Ihrem Einkaufwagen hinzugefügt worden
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
Alle 2 Bilder anzeigen

The Art of Debugging with GDB, DDD, and Eclipse (Englisch) Taschenbuch – 17. September 2008


Alle 3 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
Taschenbuch
"Bitte wiederholen"
EUR 25,95
EUR 17,81 EUR 16,81
58 neu ab EUR 17,81 10 gebraucht ab EUR 16,81

Hinweise und Aktionen

  • Sie suchen preisreduzierte Fachbücher von Amazon Warehouse Deals? Hier klicken.

  • Sichern Sie Ihre Daten kostengünstig und sicher im europäischen Amazon Web-Services-Rechenzentrum. So einfach geht‘s


Wird oft zusammen gekauft

The Art of Debugging with GDB, DDD, and Eclipse + Valgrind 3.3 - Advanced Debugging and Profiling for GNU/Linux applications + The Developer's Guide to Debugging: 2nd Edition
Preis für alle drei: EUR 59,63

Die ausgewählten Artikel zusammen kaufen
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: 264 Seiten
  • Verlag: No Starch Press; Auflage: 1 (17. September 2008)
  • Sprache: Englisch
  • ISBN-10: 1593271743
  • ISBN-13: 978-1593271749
  • Größe und/oder Gewicht: 17,8 x 2,3 x 23,5 cm
  • Durchschnittliche Kundenbewertung: 4.0 von 5 Sternen  Alle Rezensionen anzeigen (2 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 405.492 in Bücher (Siehe Top 100 in Bücher)
  • Komplettes Inhaltsverzeichnis ansehen

Mehr über den Autor

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

Produktbeschreibungen

Synopsis

Debugging is crucial to successful software development, but even many experienced programmers find it challenging. Sophisticated debugging tools are available, yet it may be difficult to determine which features are useful in which situations. The Art of Debugging is your guide to making the debugging process more efficient and effective. The Art of Debugging illustrates the use three of the most popular debugging tools on Linux/Unix platforms: GDB, DDD, and Eclipse. The text-command based GDB (the GNU Project Debugger) is included with most distributions. DDD is a popular GUI front end for GDB, while Eclipse provides a complete integrated development environment.In addition to offering specific advice for debugging with each tool, authors Norm Matloff and Pete Salzman cover general strategies for improving the process of finding and fixing coding errors, including how to: Inspect variables and data structures Understand segmentation faults and core dumps Know why your program crashes or throws exceptions Use features like catchpoints, convenience variables, and artificial arrays Avoid common debugging pitfalls Real world examples of coding errors help to clarify the authors' guiding principles, and coverage of complex topics like thread, client-server, GUI, and parallel programming debugging will make you even more proficient.

You'll also learn how to prevent errors in the first place with text editors, compilers, error reporting, and static code checkers. Whether you dread the thought of debugging your programs or simply want to improve your current debugging efforts, you'll find a valuable ally in The Art of Debugging.

Über den Autor und weitere Mitwirkende

Norman Matloff, a computer science professor at UC Davis, is the author of several popular public-domain software packages and online tutorials.

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


In diesem Buch (Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Hier reinlesen und suchen:

Kundenrezensionen

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

Die hilfreichsten Kundenrezensionen

1 von 1 Kunden fanden die folgende Rezension hilfreich Von B. W. am 9. Mai 2013
Format: Taschenbuch Verifizierter Kauf
This book is a good compendium for experienced developers, but there won't be any surprises or new information in it. For a beginner it is highly recommended.
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
2 von 3 Kunden fanden die folgende Rezension hilfreich Von Johann Horvat am 5. Januar 2011
Format: Taschenbuch
Sieht man vom Debuggen auf Embedded Systemen ab, bietet dieses Buch eine sehr gelungene Einführung in die Thematik des Debuggens mit gdb. Selbst Multithreading hat seinen Platz gefunden!
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: 19 Rezensionen
30 von 32 Kunden fanden die folgende Rezension hilfreich
Quite a gem! 3. Februar 2009
Von Mark K. - Veröffentlicht auf Amazon.com
Format: Taschenbuch
I must come clean first - I know the authors. Peter asked me to review one of the sections in the book many ages ago when the book was in its infancy. The book has progressed much since then, and I must admit this is much more than I was expecting from a book about debugging!

Chapters 1 through 3 are the starter chapters that discuss the core debugging paradigms such as breakpoints and variable analysis. Chapter 1 goes through some of the basic concepts of debugging for those new to the idea (e.g., hobbyists and just-out-of-college programmers) but it's probably less useful for those already familiar with the concept. Chapter 2 goes through the basic debugging operations, such as setting breakpoints and analyzing variables, with an emphasis on how breakpoints can be set, cleared, and triggered using various methods. Chapter 3 goes through more on how variables of different storages can be viewed and displayed.

Chapters 4 and 5 are where things start to get interesting. Chapter 4 discusses how the debugger can be used to analyze core dumps, and touches on operating system concepts just enough to be productive in debugging for those not familiar with OS architectures. Chapter 5 discusses debugging threaded applications. As examples, applications written using popular multi-threaded and multi-process libraries such as pthread, MPI, and OpenMP are discussed, which makes the chapter more practical.

Chapter 6 is an interesting chapter. Section 6.1 goes through some common compiler error messages and how one should interpret them. They're concepts all first semester programming course students should read. It should be read either before chapter 1 or immediately after for beginning programmers, but it's also an entertaining section to read for the experienced programmers who goes through what the section discusses on a daily basis without ever giving it a second thought anymore. Section 6.2 should be a great read for anyone whose hair turned gray trying to debug Curses or NCurses applications under UNIX.

Chapter 7 discusses various tricks programmers use to write less buggy programs. Most of these are widely known concepts that are rarely taught in class - Vim tricks for matching parentheses, syntax highlighting, using errno and perror, libraries for catching buffer overflows, etc. Mentioning of the __LINENO__ directive is strangely lacking in this chapter, and I'm not sure how useful lint is these days but the chapter looks as complete as one would expect. The chapter also delightfully introduces strace and ltrace, though more examples would be helpful for those not familiar with OS concepts.

The final chapter is for those that want to use GDB/DDD/Eclipse in other languages. I have never felt the need to use debuggers with scripts but I probably would sing a different tune once I start using it.

The book admittedly has a Linux slant to it, but practical examples need a practical platform under which to give the examples and Linux is as accessible as it gets for most people. Most of the discussions are applicable in any platform, but they are especially applicable in Linux and UNIX variants. Chapters 1 and 6 should be a part of all introductory programming courses and should provide a good starting point to which a seasoned programmer can point a new programmer. The remaining chapters are relatively easy read yet packed with useful information to which programmers will refer back asking themselves, "what was that command that does ...?"
13 von 14 Kunden fanden die folgende Rezension hilfreich
Much better than man gdb 6. September 2010
Von talkaboutquality - Veröffentlicht auf Amazon.com
Format: Taschenbuch
The Art of Debugging isn't really much about the "art", although there is a very brief "principles of debugging" section at the beginning. It is about how to use GDB, DDD, and Eclipse effectively and completely. Very detailed guidance and examples. It's 250 pages but looks like less. If you want to become an expert at debugging software systems, there's probably no substitute for experience, but a concise tutorial on GDB and its various GUIs is a great start.
7 von 8 Kunden fanden die folgende Rezension hilfreich
A useful book about debugging 14. September 2013
Von Hugh C. Lauer - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
There are not many books about debugging. This one is a useful compendium of the various techniques that any software engineer should know, So if you do not have a reasonable book about debugging, get this one. However, the title says "with GDB, DDD, and Eclipse." The book is mostly about GDB, with about 15% devoted to DDD and 5% devoted to Eclipse. That is probably okay, because it takes much more instruction to do almost any task in GDB than it does in either of the other two. However, Eclipse-only users will probably be disappointed. (There are many other books about Eclipse, but I could not find any specifically devoted to debugging.)
2 von 2 Kunden fanden die folgende Rezension hilfreich
Good beginning Intro to GDB 23. Oktober 2011
Von Ken - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
This is a good book for those new to GDB, which is what I was looking for. It's easy to read, and gets you into GDB quickly. At each step, the reader is shown how to do essential things like setting breakpoints, inspecting memory, and stepping through your program with easy to follow examples. The authors also show how both DDD and Eclipse work in debugging programs, as GDB is the back end for each.

The book isn't meant to be a comprehensive GDB reference, which is fine. Other books fill that role.
1 von 1 Kunden fanden die folgende Rezension hilfreich
Quickest Way to Learn Debugging in Linux 15. September 2013
Von Michael Gautier - Veröffentlicht auf Amazon.com
Format: Kindle Edition Verifizierter Kauf
Command line versus Visual Debugging. When the software is in production on a server, someone else's computer, out in the field, or you need a quick answer, a command-line debugger is the best tool to have available. GDB may already be on the system or you can install it quickly enough not to impact the operating environment. This book is the valuable resource you need to properly understand GDB and use it quickly and precisely for your situation.

My experience with command-line debugging has been trail and error which is useful when information is lacking. When you have a more complete body of information about a tool or process, then you can optimize your efforts and achieve better results. Such is the case with this book and how it will equip persons with the concepts of command-line debugging that they can use in any environment where such debuggers may be available.

gautiertalksopentech.wordpress.com/2013/06/26/definitive-allegro-c-linux-command-line-compile
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.