Software Debugging Techniques

• Debugging identifies and fixes program errors causing unexpected behavior.
• It's a critical, time-intensive, and challenging part of programming.

Debugging Process

• Examine error symptoms like crashes and unexpected behavior.
• Identify the root cause by tracing code execution to find the problematic lines.
• Fix the error by making necessary corrections to ensure the code works correctly.

Debugging Techniques

• Fully understand the problem before changing code; reproduce the issue if you can.
• Backtracking, also called backward debugging, starts from the point of the error and works backward.
• Debugging tools offer insights into code function, including variable and memory use; examples are Chrome DevTools, Testsigma, and dbForger.
• Set breakpoints to halt execution at suspected problem areas and inspect the program's state.
• Use stepping to move through code line by line, examining variables and data structures.
• Binary search isolates issues by dividing code into halves to narrow down the bug location.
• Rubber ducking helps by explaining the problem to someone (or something) to force critical thinking.
• Log Analysis involves placing log statements in code to understand execution flow and variable values at different points.
• Clustering bugs group error reports by common cause or pattern to resolve multiple bugs at once.
• Take breaks to clear the mind and get a fresh perspective on the problem.
• Document the debugging process and solutions for future reference.

Exception Handling

• An exception is an unexpected error condition during programming.
• Potential exceptions include file not found, disk full, invalid data type, division by zero, and array index out of bounds.
• Exceptions aren't always "bad" but represent unusual occurrences, like a profit exceeding the maximum integer value.
• Exception handling manages or resolves these errors using object-oriented techniques.
• Runtime errors are unplanned exceptions during program execution.
• Syntax errors are exceptions found during program compilation.
• Error Class: Represents severe errors (e.g., insufficient memory) that the program cannot recover from.
• Exception Class: Represents less serious errors (e.g., invalid array subscript) that the program can recover from.
• In Java, both Error and Exception classes inherit from the Throwable class, which originates from the Object class.

Specific Errors and Exceptions

• IOException: Base class for exceptions thrown when accessing files, directories, and streams.
• RuntimeException: Detected during the application's execution.
• ArithmeticException: Raised when a math operation error occurs during runtime.
• IndexOutOfBoundsException: Thrown when using an invalid index for arrays, lists, or strings.
• ArrayIndexOutOfBoundsException: Signals an attempt to access an array with an illegal index.
• NoSuchElementException: Indicates that the requested element does not exist.
• InputMismatchException: Occurs when the user enters the wrong input type.
• VirtualMachineError: The Java Virtual Machine is broken or lacks necessary resources.
• OutOfMemoryError: Not enough space to allocate an object.
• InternalError: An unexpected internal error in the Java Virtual Machine.

Try, Catch, and Finally Blocks

• "try" procedures that might cause errors.
• A method detecting an error "throws an exception".
• A block of code processing the error is said to "catch the exception".
• try block: Encloses code that might cause an error.
• catch block: Handles exceptions thrown by the try block.
• throw statement: Sends an Exception object to be handled elsewhere.
• The general format of a method including try...catch:
  • try { // Code that might generate an exception } catch(Exception e) { // Actions to take if an exception occurs }
• A catch block resembles a method named catch() that takes an Exception argument.
• If the try block encounters an exception, the catch block executes; otherwise, it's bypassed.
• finally block: Executes code at the end of a try...catch sequence, regardless of exceptions.
• Used for cleanup tasks that must always happen, such as closing files.
• When a finally block is included, its statements execute before the method is abandoned.
• In a pseudocode example for reading a file, the finally block closes the file, ensuring it's closed no matter the outcome of the try block.