Debugging
Applications
Author: Tien Do
22-Dec-01
24mB Software Development

What We Will Cover
Defining the different types of bugs
Learn how to write applications with
fewer bugs in the first place
Developing a proactive process for
debugging that all great developers
follow

Today’s Agenda
The gestalt of bug
Avoid bug in the first place
The proactive debugging process

The Gestalt of Bug
24mB Software Development

What Are Bugs?
Inconsistent user interfaces
Unmet expectations
Poor performance
Crashes or data corruption

Process Bugs and
Solutions
Short or impossible deadlines
The \"code first, think later\"
approach
Misunderstood requirements
Lack of knowledge
Lack of commitment to quality

Short or Impossible
Deadlines
Unrealistic schedules
Underestimate how long to develop
a solid product
Leads to cut corners and a lower
quality product
Ship dates should be based on a
feature set

The “Code First, Think
Later\" Approach
Starts programming before they
start thinking
Very few like to write documents
Introduce more bugs into an
already unstable code
The solution is simple: plan your
projects

Misunderstood
Requirements
Feature creep causes more bugs
than almost anything else
\"paper prototypes\" the user
interface
Really understand the products'
requirements
Spend adequate time to understand
the problem domain

Lack of Knowledge
Don't understand the OS, the
language, or the technology
No one can be expected to know
the ins and outs of everything
Acknowledging the strengths and
limitations
Strengthening every developer's
weaknesses

Lack of Commitment To
Quality
The most serious problem
Company's commitment sets the
tone for the entire team
Make code the most robust and
extensible

Avoid Bug In The First
Place
24mB Software Development

Planning for Debugging
Think about debugging right from
the beginning
Plan for exactly what will change
Adding a feature doesn't affect just
the code
Goes together with planning for
testing
Code should tell you where the
bugs are

Prerequisites to
Debugging
Know your project
Know your language
Know your technology
Know your operating system
Know your CPU

Learning the Skill Set
Study continually just to keep up
The ultimate way to learn is by
doing
Look at other developers' code
Never be afraid to ask others
Read programming newsgroup

Assert, Assert, Assert, and
Assert
The key proactive programming tool
for debugging
Using in addition to normal error
checking
Tell where and why a condition was
invalid
Serve as reminders to others

How to Assert
Should never change any variables
or states of a application
Check a single item at a time
Strive to check the condition
completely
Assert against specific values
Real error handling immediately
follows the assertion

What to Assert
The parameters coming into a
function
The return values
Any assumption

Trace, Trace, Trace, and
Trace
Useful when used correctly with
assertions
Should associate with paths through
the code
Avoid putting trace statements
inside tight loops
Everyone uses a similar format

Comment, Comment,
Comment, and Comment
The only way to make code
maintainable
Doesn’t mean duplicate the code
Mean documenting assumptions,
approach, and reasons
Keep coordinated with the code
Well-placed trace, assertions, and
good naming conventions are also
good comments

Unit Testing
Unit testing is how you verify
yourself
Writing unit tests as soon as writing
code
Run unit tests all the time during
coding
Code coverage
Keep unit tests as part of the code
base

Bug Tracking Systems
Track all the bugs of the project
Keep notes and to-do lists in one
place
Better predict when your product
will be ready to ship
Hallmarks of a good software team

Frequent Builds and
Smoke Tests
Build the application once a day
Building both release and debug
versions at the same time
Build with the latest master sources
Checks product's basic functionality
Contain at least one test for every
feature

The Proactive Debugging
Process
24mB Software Development

The Steps Illustration

Step 1: Duplicate the Bug
The most critical step
Sometimes difficult, or even
impossible
Try to get bugs through multiple
paths
Some bugs can mask others
Log it, even can’t duplicate

Step 2: Describe the Bug
Both verbally and in writing
To be as descriptive as possible
Help you fix bug easier
Describe bugs so other can
understand them

Step 3: Always Assume
That the Bug Is Yours
Most of bugs are your fault
Only small % are result of compiler
or operating system
Check your code before looking for
bug elsewhere

Step 4: Divide and
Conquer
Start firming and testing your
hypothesis
Doing a little light debugging
Reevaluate hypothesis and try again
Debugging is like a binary search
algorithm
Update the bug description

Step 5: Think Creatively
Looking at the bug from different
perspectives
Walk away from the problem for a
day or two

Step 6: Leverage Tools
Tools may help you find bug in
minutes
Run code through tools before any
heavy debugging

Step 7: Start Heavy
Debugging
Spending time exploring your
application's operation
Use the debugger's advanced
features
Never poke around with the
debugger
Double-checking the changes you
made to fix the bug

Step 8: Verify That the Bug
Is Fixed
Test, test, and retest the fix
Test with all data conditions, good
and bad
Let the team know the changing

Step 9: Learn and Share
Quickly summarize what you
learned
Learn what you did wrong
Share the information with others

The Final Secret
Ask debugger the right questions
Have a hypothesis in mind

24mB Software Development
http://www.24mb.com