Software Debugging Techniques

• Debugging identifies and resolves program errors, representing a challenging and time-intensive coding phase.

Typical Debugging Process

• Examining error symptoms involves identifying issues like crashes and error messages
• Identifying the cause involves tracing code execution to find the source of the problem
• Fixing the error means making necessary code changes to ensure correct functionality

Debugging Techniques

• Understanding the problem is crucial before altering code; reproduce the issue and gather data
• Backtracking, or backward debugging, starts at the point of the error and traces back
• Debugging tools, such as Chrome DevTools, Testsigma, and dbForger, provide insights into code behavior, variables, and memory usage
• Breakpoints halt program execution at specific points to inspect functionality
• Stepping involves manually moving through each code line to study variables and data structures
• Binary search narrows issue scope by dividing code and systematically finding the bug location
• Rubber ducking uses explaining the problem to someone else or a rubber duck to encourage critical thinking
• Log analysis uses log statements to provide debugging information and to understand code execution and variable values
• Clustering bugs groups related error reports to find common causes
• Taking breaks from debugging clears the mind and can lead to breakthroughs
• Taking notes of the debugging process and solutions is useful for future challenges

Basic Exception Handling

• An exception is an unexpected error condition in the program
• Potential exceptions include trying to read nonexistent files, writing to a full disk, invalid user input, dividing by zero, or accessing an array with an out-of-bounds index
• Exceptions aren't always "bad"; a company profit exceeding an integer's capacity is still an exception
• Exception handling uses object-oriented techniques to manage or resolve errors
• A runtime error is an unplanned exception during execution
• A syntax error is an exception found during program compilation

Java Error Classes

• Error Class represents severe errors that a program cannot recover from, like insufficient memory
• Exception Class represents less serious errors, like an invalid array subscript, that the program can recover from by assigning a valid value

Exception and Error class inheritance hierarchy.

• The Error and Exception classes are from the Throwable class, which originates from the Object class
• Throwable is the superclass for errors and exceptions in Java

Common exceptions and errors include

• IOException is the base class for exceptions when accessing data
• RuntimeException is only detected during runtime
• ArithmeticException is raised during runtime when a math operation is wrong
• IndexOutOfBoundsException is thrown when using an invalid index in arrays, lists, or strings
• ArrayIndexOutOfBoundsException indicates illegal access to an array index
• NoSuchElementException means the element requested does not exist
• InputMismatchException occurs when the user input is of an incorrect data type or is out of range.
• VirtualMachineError indicates the Java Virtual Machine is broken.
• OutOfMemoryError is thrown when there isn't sufficient space to allocate an object.
• InternalError indicates an unexpected error in the Java Virtual Machine.

Division Class Example

• Demonstrates integer declaration, user input, and calculations
• The main() method declares three integers, prompts for two values, and calculates the third by division of first two

Division CLass Executions

• Execution #1: The program execution is normal with usable values
• Execution #2: An ArithmeticException occurs and the program crashes when the denominator is zero
• Execution #3: A InputMismatchException exception is thrown when a string is entered as the denominator
• Execution #4: A InputMismatchException exception is thrown when a float is entered as the denominator
• A stack trace history list displays error messages and the methods called

Try, Catch and Finally Blocks

• Programmers can "try" a potentially erroneous procedure to mitigate errors
• A method detects the error and then throws the exception
• A block of code then catches the exception

Try Block

• Contains code where errors might occur
• Includes the try keyword with curly braces, and executable statements that might cause exceptions

Catch Block

• Handles thrown exceptions and is added after the try block
• The method handles an exception that the try block that precedes it might throw
• A throw statement sends an exception such that it can be handled by a catch block
• The catch keyword is followed by curly braces
• Within the parentheses, is an Exception type with an identifier
• Additionally has actions to take to handle the error condition

Catch Block Example

• It has methods with try...catch pair

returnType methodName(optional arguments) {
         // optional statements prior to code that is tried
    try {
         // statement or statements that might generate an exception
    }
    catch(Exception someException) {
         // actions to take if an exception occurs
    }
        // optional statements that occur whether the catch block executes or not
}

• A catch block resembles a method, taking an Exception-type argument; it isn't a method because it doesn't have a return type
• someException in the sample format is a object representing the exception class
• During execution of the try block, if an exception occurs, the exception is thrown, the catch block executes, and otherwise the catch block does not

DivisionMistakeaught class example

• Execution #1: When a valid denominator is entered, the try block executes with out issue
• Execution #2: When zero is entered for the denominator, the catch block executes the error message and the try block is abandoned

Finally block

• Used when action must be performed at the end of try...catch sequence
• The code will always execute weather the blocks identify an exception or not
• This is useful for clean up tasks

Try, Catch, Finally example

try {
    // statements to try
}
catch(Exception e) {
    // actions that occur if an exception was thrown
}
finally {
    // actions that occur whether catch block executed or not
}

• If the finally block is included, there is the assurance that the statements in it will execute before being abandoned
• Pseudocode reads a file and handles an IOException using these methods together.

try {
   // Open the file
   // Read the file
   // Place the file data in an array
   // Calculate an average from the data
   // Display the average
}
catch(IOException e) {
   // Issue an error message
   // System exit
}
finally {
// If the file is open, close it
}

• With the finally block, the file will be closed before returning to operating system, especially if a try block has occurred