Remapping Debuggable Code via Gesture Detection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current debugging processes in computer applications often result in the host application freezing when a breakpoint is hit, which can impact user experience and efficiency, especially when transitioning from older to newer scripting platforms.
Innovation Solution
The user script code is remapped into debuggable code based on explicit debugging gestures, with instrumentation techniques such as injecting guards and splitting functions, tailored to the capabilities of the virtual machine, allowing for efficient debugging without freezing the host application.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If user script code is fully transformed into debuggable script code, then debuggability is improved, but execution efficiency deteriorates
Solution Approach 1:
The patent segments the script code transformation process by dividing functions into smaller units and selectively transforming only those portions where debugging gestures are detected, rather than transforming the entire script code base. This allows debuggability to be improved in specific locations without unnecessarily impacting overall execution efficiency.
Solution Approach 2:
The patent applies partial transformation of script code into debuggable code based on debugging gestures. Instead of fully transforming all code (excessive action), the system transforms only the necessary portions where debugging is actually requested, achieving sufficient debuggability while minimizing performance overhead.
2Reliability
If debugging features are added to script code, then debugging capability is improved, but host application responsiveness deteriorates
Solution Approach 1:
The patent introduces an intermediary mechanism (debugging gesture detection system) that mediates between the debugging requirements and the host application execution. The system detects explicit debugging gestures and selectively activates debugging features, allowing debugging capability to be improved without causing the host application to freeze or become unresponsive.
Solution Approach 2:
The patent makes the debugging feature activation dynamic rather than static. Debugging features are activated only when and where explicit debugging gestures are detected during runtime, allowing the system to adapt between debugging mode and normal execution mode, thereby maintaining host application responsiveness while providing debugging capability when needed.
3Speed
If virtual machine functional call speed is high, then more guards can be injected, but code complexity increases
Solution Approach 1:
The patent changes the parameter of guard injection based on the virtual machine's functional call speed. When the VM exhibits high call speed, the system increases the number of guards injected into the code. This parameter-based adaptation allows the system to optimize between debugging coverage and code complexity based on runtime performance characteristics.
Data Source
AI summary
User script code that has been developed for execution in a host application can be remapped to debuggable script code, based on explicit debugging gestures, allowing for appropriate debugging coverage for the code while mitigating execution (in)efficiency issues. Capabilities of a virtual machine used for a host application can be determined, and the user script code can be instrumented with guards for detecting explicit debugging gestures based on capabilities of the virtual machine. The instrumented user script code can be executed in a runtime environment, for example, by a just-in-time compilation service. If an explicit debugging gesture is detected, a function where the gesture was detected can be transformed into debuggable script code, in one embodiment, based on the debuggable gesture detected.