Intelligent Debugger Filtering User-Defined Code
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Debugging complex software applications is inefficient due to the need to traverse and examine both developer-written and system/tool-generated code, wasting developer time and resources.
Innovation Solution
A debugger that filters and displays only user-defined artifacts, marking and collapsing non-user-defined code, allowing developers to focus on debugging developer-written code while bypassing unnecessary system and tool-generated code.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If the debugger displays all code including system and tool-generated code, then complete debugging coverage is achieved, but developer time and resources are wasted
Solution Approach 1:
The debugger segments the code display by separating user-defined code from system and tool-generated code. It identifies and filters code based on authorship attribution, presenting only relevant user code in the primary view while maintaining the ability to access system code when needed. This segmentation resolves the contradiction by providing focused debugging coverage without overwhelming the developer with unnecessary code.
Solution Approach 2:
The debugger extracts and filters out system and tool-generated code from the primary debugging view. By automatically identifying and excluding non-user code from the displayed execution path, the system maintains complete debugging capability while removing distracting elements that waste developer time and resources.
2Measurement precision
If the debugger displays all variables including system and tool-generated variables, then complete state monitoring is achieved, but information overload occurs
Solution Approach 1:
The debugger segments variable display by categorizing variables as user-defined or system-generated. It presents user variables prominently in the primary variable view while organizing system variables separately or collapsing them by default. This segmentation maintains complete state monitoring capability while preventing information overload by highlighting only the variables most relevant to the developer's debugging objectives.
3Reliability
If the debugger steps through all code lines including system code, then complete execution path coverage is achieved, but productivity decreases
Solution Approach 1:
The debugger implements intelligent stepping that automatically skips over system and tool-generated code sections. When the execution path enters non-user code, the debugger rapidly advances through these sections without requiring developer intervention, while still maintaining accurate tracking of the execution flow. This allows complete execution path coverage to be achieved without forcing the developer to manually step through every line of system code, thereby maintaining productivity.
4Reliability
If the debugger monitors all threads including system threads, then complete thread analysis is achieved, but complexity increases
Solution Approach 1:
The debugger segments thread monitoring by distinguishing between user-created threads and system-generated threads. It presents user threads in the primary thread view with full monitoring capability, while organizing system threads in a separate category or collapsing them by default. This segmentation maintains complete thread analysis capability while reducing interface complexity by highlighting only the threads most relevant to the developer's debugging needs.
Data Source
AI summary
A method for displaying a user-defined artifact in a debugger view is provided. The user-defined artifact is defined in a software application that is developed by a computer software application developer. The software application is included in a packaged application that includes instructions, with each instruction being either a user-defined instruction or a non-user defined instruction. A breakpoint is defined at a desired instruction of the packaged application. The method includes initiating debugging of the packaged application and hitting the breakpoint defined at the desired instruction. Also included is identifying the user-defined artifact in the software application and obtaining data to populate the debugger view. Further included is filtering-in data associated with the user-defined artifact and displaying the debugger view showing the filtered-in data. The method also includes marking data not associated with the user-defined artifact and stepping through the user-defined instruction.