Remapping debuggable code

Abstract

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.

What is claimed is: 
     
       1. A method, comprising:
 determining a capability of a virtual machine (VM) configured to execute a host application in a runtime environment; 
 instrumenting a function in user script code developed for execution in the host application with a guard based upon the capability of the VM, the instrumenting comprising at least one of:
 instrumenting the function with the guard at a location in the user script code, the location determined based upon the capability of the VM; or 
 instrumenting the function with a number of guards determined based upon the capability of the VM, the number of guards comprising the guard; 
 
 executing the user script code in the runtime environment; and 
 responsive to detecting an explicit debugging gesture using the guard, transforming the function to generate debuggable script code. 
 
     
     
       2. The method of  claim 1 , the runtime environment associated with an application execution and development framework. 
     
     
       3. The method of  claim 1 , the number of guards comprising two or more guards. 
     
     
       4. The method of  claim 1 , the location associated with a potential debugging stopping operation. 
     
     
       5. The method of  claim 1 , the instrumenting based upon a functional call speed capability of the VM. 
     
     
       6. The method of  claim 1 , comprising injecting a call to detect the explicit debugging gesture. 
     
     
       7. The method of  claim 6 , the injecting performed at least in part via a compiler. 
     
     
       8. A system, comprising:
 one or more processing units; and 
 memory comprising instructions that when executed by at least some of the one or more processing units, perform a method comprising:
 determining a capability of a virtual machine (VM) configured to execute a host application in a runtime environment; 
 instrumenting a function in user script code with a guard based upon the capability of the VM, the instrumenting comprising:
 instrumenting the function with the guard at a location in the user script code, the location determined based upon the capability of the VM; 
 
 executing the user script code in the runtime environment; and 
 responsive to detecting an explicit debugging gesture using the guard, transforming the function to generate debuggable script code. 
 
 
     
     
       9. The system of  claim 8 , the runtime environment associated with an application execution and development framework. 
     
     
       10. The system of  claim 8 , the instrumenting comprising instrumenting the function with a number of guards based upon the capability of the VM, the number of guards comprising the guard. 
     
     
       11. The system of  claim 8 , the location associated with a potential debugging stopping operation. 
     
     
       12. The system of  claim 8 , the instrumenting based upon a functional call speed capability of the VM. 
     
     
       13. The system of  claim 8 , the method comprising injecting a call to detect the explicit debugging gesture. 
     
     
       14. The system of  claim 13 , the injecting performed at least in part via a compiler. 
     
     
       15. A computer readable memory comprising instructions that when executed perform a method, comprising:
 determining a capability of a virtual machine (VM) configured to execute a host application in a runtime environment; 
 instrumenting a function in user script code with a guard based upon the capability of the VM, the instrumenting comprising:
 instrumenting the function with a number of guards determined based upon the capability of the VM, the number of guards comprising the guard; 
 
 executing the user script code in the runtime environment; and 
 responsive to detecting an explicit debugging gesture using the guard, transforming the function to generate debuggable script code. 
 
     
     
       16. The computer readable memory of  claim 15 , the runtime environment associated with an application execution and development framework. 
     
     
       17. The computer readable memory of  claim 15 , the instrumenting comprising instrumenting the function with the guard at a location in the user script code based upon the capability. 
     
     
       18. The computer readable memory of  claim 17 , the location associated with a potential debugging stopping operation. 
     
     
       19. The computer readable memory of  claim 15 , the instrumenting based upon a functional call speed capability of the VM. 
     
     
       20. The computer readable memory of  claim 15 , the method comprising injecting a call to detect the explicit debugging gesture.