Visual Debugging Tools for Declarative Software Abstraction
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional debuggers often fail to provide an optimal representation of a software program's state, especially in declarative programming, as they rely on source code, stack, thread, and data views, which may not adequately depict the program's state, and can be ineffective when source code is obscured or unavailable.
Innovation Solution
The development of debugging tools that allow debugging at various levels of abstraction, including source code and higher levels, by mapping computer code and its execution states to visual representations, enabling breakpoints and inspections within these visual representations, and switching between visual and source code views.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If conventional debuggers use source code, stack, thread and data views to represent program state, then debugging functionality is provided, but the representation is not optimal or complete especially for declarative programming and when source code is obscured
Solution Approach 1:
The patent introduces visual representations (diagrams, schematics, flow charts, tables) as an additional dimension beyond traditional source code views. These visual representations provide a higher-level abstraction that complements the detailed source code perspective, enabling developers to understand program state at multiple levels of abstraction simultaneously.
Solution Approach 2:
The debugging system is designed to work with multiple programming paradigms including both procedural/functional programming (with source code) and declarative programming (with visual representations). The system can adapt its representation method based on the programming paradigm being used, making it universally applicable across different types of software development.
2Ease of operation
If source code level debugging is used, then detailed inspection capability is provided, but debugging is ineffective when source code is obscured or unavailable
Solution Approach 1:
When source code is obscured or unavailable, the system creates visual representations that copy or replicate the essential structure and state information of the program. These visual copies (diagrams, flow charts, tables) serve as substitutes for the original source code, allowing debugging to continue without direct access to the source code text.
Solution Approach 2:
The visual representation system acts as an intermediary between the obscured source code and the developer. Instead of requiring direct access to source code, the intermediary visual layer provides the necessary debugging information through diagrams and visual structures that represent the program state without exposing the actual source code.
3Adaptability or versatility
If multiple levels of abstraction are made accessible simultaneously, then comprehensive debugging capability is provided, but system complexity increases
Solution Approach 1:
The debugging system segments the representation into distinct layers or views (source code view, visual representation view, stack view, data view). Each segment serves a specific purpose and can be accessed independently. The system manages these segments through organized data structures that map between different levels of abstraction, reducing the perceived complexity for the user.
Data Source
AI summary
Debugging tools to allow a developer to debug software at a higher level of abstraction than the source code. These tools may be configured to recognize certain source code, and map it to visual representations that can be shown to the developer. The tools may allow the developer to set breakpoints in those visual representations, and they may allow the debugger to stop at those breakpoints, show the developer the visual representation and indicate the stopped location of the program being debugged, for example, by highlighting a particular component of the visual representation. The tools may also map breakpoints in visual representations to actual source code breakpoints.