Debugging with GDB: The GNU Source-Level Debugger, Tenth Edition, for GDB version 22.214.171.12480116-git. This book is available for free at gnu.org. This book is printed in grayscale. The purpose of a debugger such as gdb is to allow you to see what is going on "inside" another program while it executes - or what another program was doing at the moment it crashed. gdb can do four main kinds of things (plus other things in support of these) to help you catch bugs in the act: - Start your program, specifying anything that might affect its behavior. - Make your program stop on specified conditions. - Examine what has happened, when your program has stopped. - Change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another.
The GNU Source-Level Debugger
Author: Richard Stallman,Roland Pesch,Stan Shebs
Many Linux and Unix developers are familiar with the GNU debugger (GBD), the invaluable open source tool for testing, fixing, and retesting software. And since GDB can be ported to Windows, Microsoft developers and others who use this platform can also take advantage of this amazing free software that allows you to see exactly what's going on inside of a program as it's executing. This new pocket guide gives you a convenient quick reference for using the debugger with several different programming languages, including C, C++, Java, Fortran and Assembly. The GNU debugger is the most useful tool during the testing phase of the software development cycle because it helps you catch bugs in the act. You can see what a program was doing at the moment it crashed, and then readily pinpoint and correct problem code. With the GDB Pocket Reference on hand, the process is quick and painless. The book covers the essentials of using GBD is a testing environment, including how to specify a target for debugging and how to make a program stop on specified conditions. This handy guide also provides details on using the debugger to examine the stack, source files and data to find the cause of program failure-and then explains ways to use GBD to make quick changes to the program for further testing and debugging. The ability to spot a bug in real time with GDB can save you hours of frustration, and having a quick way to refer to GBD's essential functions is key to making the process work. Once you get your hands on the GDB Pocket Reference, you'll never let go!
Author: Arnold Robbins
Publisher: "O'Reilly Media, Inc."
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.
Author: Norman Matloff,Peter Jay Salzman
Publisher: No Starch Press
This manual describes how to use Valgrind, an award-winning suite of tools for debugging and profiling GNU/Linux programs. Valgrind detects memory and threading bugs automatically, avoiding hours of frustrating bug-hunting and making your programs more stable. You can also perform detailed profiling, to speed up your programs and reduce their memory usage. The Valgrind distribution provides five tools for debugging and profiling: Memcheck (a memory error detector), Cachegrind (a cache profiler), Callgrind (a call-graph profiler, Massif (a heap profiler) and Helgrind (a thread error detector). These tools and their options are described in detail, with practical examples and advice. Valgrind is free software, available under the GNU General Public License. It runs on X86/Linux, AMD64/Linux, PPC32/Linux and PPC64/Linux systems. This is a printed edition of the official reference documentation for Valgrind 3.3.0. For each copy sold 1 USD will be donated to the Valgrind developers by Network Theory Ltd.
Advanced Debugging and Profiling for GNU/Linux Applications
Author: Julian Seward,Nicholas Nethercote,Josef Weidendorfer
Publisher: Network Theory.
You've experienced the shiny, point-and-click surface of your Linux computer—now dive below and explore its depths with the power of the command line. The Linux Command Line takes you from your very first terminal keystrokes to writing full programs in Bash, the most popular Linux shell. Along the way you'll learn the timeless skills handed down by generations of gray-bearded, mouse-shunning gurus: file navigation, environment configuration, command chaining, pattern matching with regular expressions, and more. In addition to that practical knowledge, author William Shotts reveals the philosophy behind these tools and the rich heritage that your desktop Linux machine has inherited from Unix supercomputers of yore. As you make your way through the book's short, easily-digestible chapters, you'll learn how to: * Create and delete files, directories, and symlinks * Administer your system, including networking, package installation, and process management * Use standard input and output, redirection, and pipelines * Edit files with Vi, the world’s most popular text editor * Write shell scripts to automate common or boring tasks * Slice and dice text files with cut, paste, grep, patch, and sed Once you overcome your initial "shell shock," you'll find that the command line is a natural and expressive way to communicate with your computer. Just don't be surprised if your mouse starts to gather dust. A featured resource in the Linux Foundation's "Evolution of a SysAdmin"
A Complete Introduction
Author: William E. Shotts, Jr.
Publisher: No Starch Press
This comprehensive reference guide offers useful pointers for advanced use of SQL and describes the bugs and workarounds involved in compiling MySQL for every system.
Documentation from the Source
Author: Michael Widenius,David Axmark,MySQL AB
Publisher: "O'Reilly Media, Inc."
This instructive book takes you step by step through ways to track, merge, and manage both open source and commercial software projects with Mercurial, using Windows, Mac OS X, Linux, Solaris, and other systems. Mercurial is the easiest system to learn when it comes to distributed revision control. And it's a very flexible tool that's ideal whether you're a lone programmer working on a small project, or part of a huge team dealing with thousands of files. Mercurial permits a countless variety of development and collaboration methods, and this book offers several concrete suggestions to get you started. This guide will help you: Learn the basics of working with a repository, changesets, and revisions Merge changes from separate repositories Set up Mercurial to work with files on a daily basis, including which ones to track Get examples and tools for setting up various workflow models Manage a project that's making progress on multiple fronts at once Find and fix mistakes by isolating problem sources Use hooks to perform actions automatically in response to repository events Customize the output of Mercurial Mercurial: The Definitive Guide maintains a strong focus on simplicity to help you learn Mercurial quickly and thoroughly.
The Definitive Guide
Author: Bryan O'Sullivan
Publisher: "O'Reilly Media, Inc."
Appropriate as a supplementary text for any course teaching C++ programming or using C++ as a programming language in departments of Computer Science, Engineering, CIS, MIS, IT, and Continuing Education. Practical Debugging in C++ is the first debugging text written expressly for the beginning to intermediate level programmer. For the beginning programmer, it is a short, clear debugging guide that serves as a valuable companion to their introductory programming text when writing C++ programs. For the more advanced programmer, the guide provides a quick primer in C++ debugging with a series of examples of common syntax and semantic errors and how they can be detected and corrected. The authors cover both tracing and interactive debugger techniques.
Author: Ann R. Ford,Toby J. Teorey
The definitive reference manual for the most widely used C compiler in the world, written by the program's original author and its current developers. Learn how GCC supports language standards and extends support beyond them; how to fine-tune programs for your specific platform; and all the Objective-C runtime features. Also contains the complete list of GCC command options, and shows many features of GCC's language support. For intermediate-level and above programmers who know either C, C++ or Objective C.
The GNU Compiler Collection Reference Manual
Author: Richard Stallman
A total guide to debuggers: what they do, how they work, and how to use them to produce better programs "Debuggers are the magnifying glass, the microscope, the logic analyzer, the profiler, and the browser with which a program can be examined."-Jonathan B. Rosenberg Debuggers are an indispensable tool in the development process. In fact, during the course of the average software project, more hours are spent debugging software than in compiling code. Yet, not many programmers really know how to constructively interpret the results they get back from debuggers. And even fewer know what makes these complex suites of algorithms and data structures tick. Now in this extremely accessible guide, Jonathan B. Rosenberg demystifies debuggers for programmers and shows them how to make better use of debuggers in their next projects. Taking a hands-on, problem-solving approach to a complex subject, Rosenberg explains how debuggers work and why programmers use them. Most importantly, he provides practical discussions of debugger algorithms and procedures for their use, accompanied by many practical examples. The author also discusses a wide variety of systems applications, from Microsoft's Win32 debug API to a large parallel architecture. Visit our Web site at: http://www.wiley.com/compbooks/
Algorithms, Data Structures, and Architecture
Author: Jonathan B. Rosenberg
"Covers GNU Make basics through advanced topics, including: user-defined functions, macros, and path handling; creating makefile assertions and debugging makefiles; parallelization; automatic dependency generation, rebuilding targets, and non-recursive Make; and using the GNU Make Standard Library"--
Author: John Graham-Cumming
Publisher: No Starch Press
The book will take an easy-to-follow and engaging tutorial approach, providing a practical and comprehensive way to learn ROS.If you are a robotic enthusiast who wants to learn how to build and program your own robots in an easy-to-develop, maintainable and shareable way, "Learning ROS for Robotics Programming" is for you. In order to make the most of the book, you should have some C++ programming background, knowledge of GNU/Linux systems, and computer science in general. No previous background on ROS is required, since this book provides all the skills required. It is also advisable to have some background on version control systems, like svn or git, which are often used to share the code by the community.
Author: Aaron Martinez,Enrique Fernández
Publisher: Packt Publishing Ltd
C++ Recipes: A Problem-Solution Approach is a handy code cookbook reference guide that cover the latest C++ 14 as well as some of the code templates available in the latest Standard Template Library (STL). In this handy reference, you'll find numbers, strings, dates, times, classes, exceptions, streams, flows, pointers and more. Also, you'll see various code samples, templates for C++ algorithms, parallel processing, multithreading and numerical processes. These have many applications including game development, big data analytics, financial engineering and analysis, enterprise applications and more. A wealth of STL templates on function objects, adapters, allocators, and extensions are also available. This is a "must have", contemporary reference for your technical library.
A Problem-Solution Approach
Author: Bruce Sutherland
This fully updated second edition includes 100+ pages of new material, including new chapters on Verifying Code, Predicting Errors, and Preventing Errors. Cutting-edge tools such as FindBUGS and AGITAR are explained, techniques from integrated environments like Jazz.net are highlighted, and all-new demos with ESC/Java and Spec#, Eclipse and Mozilla are included. This complete and pragmatic overview of debugging is authored by Andreas Zeller, the talented researcher who developed the GNU Data Display Debugger(DDD), a tool that over 250,000 professionals use to visualize the data structures of programs while they are running. Unlike other books on debugging, Zeller's text is product agnostic, appropriate for all programming languages and skill levels. Why Programs Fail explains best practices ranging from systematically tracking error reports, to observing symptoms, reproducing errors, and correcting defects. It covers a wide range of tools and techniques from hands-on observation to fully automated diagnoses, and also explores the author's innovative techniques for isolating minimal input to reproduce an error and for tracking cause and effect through a program. It even includes instructions on how to create automated debugging tools. The new edition of this award-winning productivity-booster is for any developer who has ever been frustrated by elusive bugs. Brand new chapters demonstrate cutting-edge debugging techniques and tools, enabling readers to put the latest time-saving developments to work for them. Learn by doing. New exercises and detailed examples focus on emerging tools, languages and environments, including AGITAR, FindBUGS, Python and Eclipse. The text includes exercises and extensive references for further study, and a companion website with source code for all examples and additional debugging resources.
A Guide to Systematic Debugging
Author: Andreas Zeller
Publisher: Morgan Kaufmann
Two leading Linux developers show how to choose the best tools for your specific needs and integrate them into a complete development environment that maximizes your effectiveness in any project, no matter how large or complex. Includes research, requirements, coding, debugging, deployment, maintenance and beyond, choosing and implementing editors, compilers, assemblers, debuggers, version control systems, utilities, using Linux Standard Base to deliver applications that run reliably on a wide range of Linux systems, comparing Java development options for Linux platforms, using Linux in cross-platform and embedded development environments.
Configuring, Using, and Maintaining a Complete Programming Environment
Author: Rafeeq Ur Rehman,Christopher Paul
Publisher: Prentice Hall Professional
The GNU Autotools make it easy for developers to create software that is portable across many UNIX-like operating systems. Thousands of open source software packages use the Autotools, but the learning curve is unfortunately steep, and it can be difficult for a beginner to find anything more than basic reference material on using the powerful software suite. InAutotools, author John Calcote begins with an overview of high-level concepts; then tackles more advanced topics, like using the M4 macro processor with Autoconf, extending the Automake framework, and building Java and C# sources. You'll learn how to: Master the Autotools build system to maximize your software's portability Generate Autoconf configuration scripts to simplify the compilation process Produce portable makefiles with Automake Build cross-platform software libraries with Libtool Write your own Autoconf macros Autotoolsalso includes a variety of complete projects that you're encouraged to work through to gain a real-world sense of how to become an Autotools practitioner. For example, you'll turn the FLAIM and Jupiter projects' hand-coded, makefile-based build systems into a powerful Autotools-based build system.
A Practitioner's Guide to GNU Autoconf, Automake, and Libtool
Author: John Calcote
Publisher: No Starch Press
The Linux professionals' guide to effectively and efficiently diagnosing software problems and system crashes in the Linux environment.
Mastering the Art of Problem Determination
Author: Mark Wilding,Dan Behman
Publisher: Prentice-Hall PTR
Software has bugs. Period. That's true, unfortunately. Even the good old "hello, world" program, known to virtually every C and C++ programmer in the world, can be considered to be buggy. Developing software means having to deal with defects; old ones, new ones, ones you created yourself and those that others brought to life. Software developers debug programs for a living. Hence, good debugging skills are a must-have. That said, I always found it regretable that debugging is hardly taught in engineering schools. Well, it is a tricky subject, and there are no good textbooks. The latter can be helped, I thought. That's how the idea for this book was born. "The Developer's Guide to Debugging" is a book for both professional software developers seeking to broaden their skills and students that want to learn the tricks of the trade from the ground up. With small inlined examples and exercises at the end of each chapter it is well suited to accompany a CS course or lecture. At the same time it can be used as a reference used to address problems as the need arises. This book goes beyond the level of simple source code debugging scenarios. In addition, it covers the most frequent real-world problems from the areas of program linking, memory access, parallel processing and performance analysis. The picture is completed by chapters covering static checkers and techniques to write code that leans well towards debugging. While the focus lies on C and C++, the workhorses of the software industry, one can apply most principles described in "The Developer's Guide to Debugging" to programs written in other languages. The techniques are not restricted to a particular compiler, debugger or operating system. The examples are structured such that they can be reproduced with free open-source software.
Author: Thorsten Grötker,Ulrich Holtmann,Holger Keding,Markus Wloka
For GNU Make Version 4.1 The Make program is indispensable to maintainers of free software systems. The GNU Make manual, written by the program's original authors, is the definitive tutorial. It also includes an introductory chapter for novice users. The Make utility automates the process of compilation; it is especially useful when the source files of large programs change. It is a small program with a lot of power. This book will show you: How to write your own makefiles Make's rule syntax and how to write your own rules How the Make utility can be configured to automatically put binary and source files in the right places. How to use make to create archive files automatically Define, set and use Make's variables How Make uses targets so that you can broaden or narrow Make's recompilation efforts on demand. And much more! This manual provides a complete explanation of Make, both the basics and extended features. There is also a convenient Quick Reference appendix for experts.
Author: Richard M. Stallman