Debugging: Concepts and Techniques

Debugging Concepts and Techniques

• Debugging identifies and corrects program errors causing unexpected behavior
• It is a critical and challenging part of programming
• It usually involves examining symptoms, identifying the cause by tracing code, and fixing the error

Debugging Techniques

• Understanding the problem being solved is vital before changing code; reproduce the issue and gather information
• Backtracking, or backward debugging, starts at the point a problem began and works backward to find the cause; useful for complex issues
• Debugging tools give insights into code function, variables, and memory usage to save time
• Examples of debugging tools are Chrome DevTools, Testsigma, and dbForger
• Breakpoints temporarily halt program execution to inspect functionality state
• Stepping manually moves through each line of code to study variables and data structures
• Binary search narrows the scope of issues in complex problems by dividing code into halves to find the bug location
• Rubber Ducking involves explaining the problem to someone else, such as a rubber duck, to facilitate critical thinking
• Log Analysis places log statements in strategic code areas, which provides debugging information; understanding the code execution flow and variable values helps in debugging
• Clustering bugs groups error reports for common causes or patterns; fixing a bug in a class resolves other bugs or provides insights
• Taking breaks from debugging is advisable to refresh the mind and allow breakthroughs
• Taking notes to document the debugging process and the solutions used helps in future debugging challenges

Basic Exception Handling

• An exception is an unexpected error condition in programming
• Examples of potential exceptions include:
  • Attempts to read a non-existent file
  • Attempts to write to a full or unformatted disk
  • Invalid data type input by the user
  • Division by zero
  • Array access with an out-of-bounds subscript
• Exceptions are not necessarily "bad" and are not usual occurrences
• A company profit exceeding the maximum int value is an exception
• Exception handling uses object-oriented techniques to manage or resolve errors
• An unplanned exception during execution is a runtime error
• An exception discovered during compilation is a syntax error
• Java has two basic classes of errors:
  • Error Class: It is for serious errors from which a program cannot recover, such as insufficient memory
  • Exception Class: Less serious errors indicating unusual conditions during runtime that a program can recover from, such as an invalid array subscript

Exception and Error Classes

• Both Error and Exception classes descend from the Throwable class, originating from the Object class
• The Throwable class is the superclass for all errors and exceptions in Java

Highlighted Exceptions and Errors

• IOException: Base class for exceptions during file, directory, and stream access
• RuntimeException: It is only detected during application execution
• ArithmeticException: Raised when a mathematical operation is wrong during runtime
• IndexOutOfBoundsException: Thrown when an index is invalid in arrays, lists, or strings
• ArrayIndexOutOfBoundsException: Indicates array access with an illegal index (negative or beyond array size)
• NoSuchElementException: Element requested does not exist
• InputMismatchException: User input does not match the expected type or is out of range
• VirtualMachineError: Java Virtual Machine is broken or lacks resources
• OutOfMemoryError: Insufficient memory to allocate an object
• InternalError: Unexpected internal error in the Java Virtual Machine

Division Class Example

• The Division class declares three integers, prompts the user for two values, and calculates the division of the first two values
• In Execution #1, the user enters valid values, and the program runs normally
• In Execution #2, the user enters '0' as the denominator, triggering an ArithmeticException and causing the program to crash
• In Executions #3 and #4, the user enters non-integer data for the denominator, a string and a floating-point value triggering an InputMismatchException
• The list of error messages showing each method called during execution is a stack trace history list

Try, Catch, and Finally Blocks

• In OOP, the try block encloses code that might cause an error; methods detecting errors throw exceptions
• A catch block is used to process an exception
• A try block includes the try keyword and curly braces, with statements that might cause exceptions
• A catch block, added after a try block, handles exceptions thrown by the try block
• A throw statement sends an Exception object to be handled elsewhere, and a catch block can catch this thrown Exception
• A catch block includes the catch keyword, curly braces, an Exception type, and an identifier for an instance
• Finally, a catch block has statements to handle the error condition
• A catch block resembles a method but lacks a return type and cannot be called directly; someException represents an object of the Exception class or its subclasses
• If an exception occurs in the try block, it is thrown, and the catch block executes
• If no exception happens, the catch block is skipped
• The code after the catch block executes normally

DivisionMistakeCaught Class

• In the DivisionMistakeCaught class, the try block attempts division
• If an invalid integer division occurs, an ArithmeticException is created, and the catch block executes
• In Execution #1, a valid denominator results in the try block executing and bypassing the catch block
• In Execution #2, a '0' denominator causes the try block to be abandoned, and the catch block executes
• Whether the denominator is valid or not, the "End of program" message is displayed

Finally Block

• Actions performed at the end of a try...catch sequence use a finally block
• The finally block code executes whether or not the try block identifies an Exception
• It's used for cleanup tasks, regardless of exceptions
• When a finally block is included, its statements execute before the method is abandoned, even prematurely

Example

• Pseudocode that reads a file and handles an IOException includes a finally block to ensure the file is closed
• The code in the finally block executes no matter the outcome, closing the file and preventing data leaks