Debugging Source Code via Execution History and Runtime Snapshots
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Complexity in source code navigation and debugging increases with sophisticated computer programs, especially due to parallel execution on server farms and distributed code changes, making it difficult to effectively locate and remediate errors.
Innovation Solution
A system and method for debugging source code based on execution history, allowing for both time and spatial traversal of source code, using a user interface to display spatial listings and graphic displays of runtime values, enabling selective cross-referencing of command lines with their execution histories.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Power
If computer programs are executed with massive scale of parallelism on server farms, then processing power and functionality are improved, but debugging complexity and difficulty of detecting errors increase
Solution Approach 1:
The execution history is segmented into multiple threads, each representing a separate execution path. The debugger displays these as separate threads with their respective command lines and runtime values, allowing users to navigate and analyze each thread independently. This segmentation transforms the complexity of parallel execution into manageable, discrete units that can be systematically investigated.
Solution Approach 2:
The patent introduces an execution history data structure as an intermediary between the parallel program execution and the debugging process. This intermediary captures and organizes runtime data from multiple threads, providing a structured representation that the debugger can manipulate and display. The execution history acts as a mediator that translates complex parallel execution into an analyzable format.
2Adaptability or versatility
If multiple versions of source code are concurrently maintained with changes and updates, then adaptability and functionality are improved, but navigation and error tracking become more difficult
Solution Approach 1:
The system performs preliminary capture of execution history data during program execution, before the user needs to debug. Runtime values, command lines, and execution timing are recorded in advance, creating a frozen snapshot of the execution state. This preliminary action preserves the state of multiple code versions at specific points in time, making it easier to navigate and compare differences without the complexity of concurrent maintenance.
Solution Approach 2:
The patent creates copies of execution state data from multiple source code versions. Instead of working with the complex reality of concurrent version management, the system captures and stores replicated execution histories that represent specific states of different versions. These copies can be independently analyzed and compared, simplifying the navigation and error tracking process.
3Adaptability or versatility
If source code becomes increasingly sophisticated and feature-rich, then functionality is improved, but time required for navigation and error location increases
Solution Approach 1:
The system extracts relevant execution information from the complex program execution process. By capturing and isolating specific runtime values, command lines, and execution timing data, the debugger presents only the essential information needed for error analysis. This extraction filters out the complexity of sophisticated program functionality, leaving a streamlined view that accelerates error location without sacrificing accuracy.
Solution Approach 2:
The patent adds a temporal dimension to the traditional spatial navigation of source code. Instead of only navigating through lines of code in sequence, the system enables navigation through execution history in time, allowing users to jump between different execution states and observe how code behaves over time. This dimensional change provides new perspectives for error detection that complement traditional spatial navigation.
Data Source
AI summary
A system and method are provided for enhanced navigation along execution time and code space in a debugger to assist a user in remediating errors, streamlining, or reverse engineering a computer program and the source code thereof. Snapshots of system states are recorded, a causality tree of commands is constructed through execution of the program to be debugged, and an intelligent display of system states captured during runtime and indexed or cross-referenced by time are displayed to the user in an intelligent manner to aid the user with certain debugging tasks. Additionally, further features in assisting the user to locate a root cause of an error or unexpected value and remediate that cause are also provided.