Abstract: Techniques are described that enable restoring interrupted program execution from a checkpoint without the need for cooperation from the computer's operating system. These techniques can be implemented by modifying existing code using an automated tool that adds instructions for enabling restoring interrupted program execution.

Abstract: A debugging pipeline may be developed to create a debugging experience for computer code operating in an execution environment, using a debugging tool outside of the execution environment. A producer can publish a debugging pipeline, configured to link the producer to a consumer (e.g., a debugging tool) by exposing a debugging pipeline interface object to a consumer. The debugging pipeline can implement a set of debugging protocols, comprising: protocol for processing of debugging requests for computer code in at least one of at least two computer languages; a protocol configured for processing of computer code language types in respective signatures without exposing operating system specific constructs; and a protocol for a first debugging pipeline to be isolated from one or more second debugging pipelines. Additionally, a consumer component can provide debugging of the computer code in the execution environment.

Abstract: User script code that is developed to be run in a host application, for example, as a macro can be transformed into debuggable code so that the host application may continue to operate during a debugging stop operation. Traceback methods can be created that call back into the host application to allow the host application to cooperatively operate and update its user-interface. The user script code can be transformed by injecting callbacks to the traceback methods at respective locations in the code where a stopping operation may be installed during debugging. Further, two or more debugging features can be combined into a single user script code transform using an iterator pattern function.

Abstract: A server exposes debugger services to a plurality of debugger clients. One or more debugger clients can select a debug operation and establish a debug session in a thread of a server process for debugging user code. A two-way debug communication pipeline can be established between a debugger client and the server using standard encoding protocols and standard network transport protocols. A two-way debug communication pipeline can be established using HTTP where the server can initiate a communication with the debugger client using a long polling technique. When one of the threads of the server process is suspended, the other threads in the server process continue to execute.

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.

Abstract: Interface optimization is provided using a closed system in which all the individual software components in the system are known to the compiler at a single point in time. This knowledge enables significant opportunities to optimize the implementation of interfaces on a set of implemented objects. When code is compiled, because the compiler knows the full list of interfaces and the objects which implement the interfaces, it can improve execution and working set (i.e., recently referenced pages in a program's virtual address space) when implementing the interfaces on objects. This improvement may be realized by reducing the size of interface lookup tables which map each interface to the object types which implement that particular interface.

Abstract: Various domains may wish to specify different implementations of the type; e.g., a compilation domain may describe the type statically, an execution domain may instantiate objects of the given type, while a debugging execution domain may associate additional debugging information such as a symbol name. This may be achieved by specifying a type implementation of a particular type within respective domains which all implement a common type interface. A type binding instruction set may then select a type implementation for the type within the target instruction set according to the domain, and may bind type instances of the type within target instruction set to the selected type implementation for the current domain. This technique yields domain-specific variance in type implementation without having to reconfigure the target instruction set or perform domain-checking logic there-within.

Abstract: The present invention extends to methods, systems, and computer program products for script debugging. Embodiments of the invention serve as a plug-in to an existing debugger. The plug-in leverages the debugger's user-interface and engine. The plug-in can be a controller that subscribes to common notifications and is guided by a state machine, which stitches together a script control channel with an existing debug channel.

Abstract: The present invention extends to methods, systems, and computer program products for creating text functions form a spreadsheet. Embodiments of the invention extract functions from spreadsheets and represent the functions in textual form. Representation in textual form promotes code reuse, clarify, expressive power, and better performance. Text can be rendered in virtually any programming language, such as, for example, C#, C++, Visual Basic (“VB”), etc. In some embodiments, programming language extensibility to support spreadsheet compatible data types and functions is utilized.

Abstract: The present invention extends to methods, systems, and computer program products for simulating operations through out-of-process execution. When a diagnostic operation is to be performed for a target execution context, a separate execution context is created based on the same executable code used to create the target execution context. An execution boundary separates the target execution context and the separate execution context such that execution in the separate execution context does not influence the behavior of the target execution context. State data from the target execution context is marshaled and transferred to the separate execution context. The separate execution context reconstitutes the state data and uses the state data to perform the diagnostic operation. Accordingly, performance of the diagnostic operation is simulated in the separate execution context without influencing the behavior of the target execution context.

Abstract: A low privilege debug pipeline publisher advertises a debugging pipeline. Instead of having a client to which a debugger on the server has been attached interrogate the server for debugging information, the client requests information from the server. Control is returned to the server which can refuse to provide the requested information to the client. A debuggee server executes client code being debugged in an isolated context so that pausing the code at a breakpoint does not block the server. The server can apply transforms to compiled code to make the code cooperate with debugging services so that a privileged component to inspect the debuggee code is not needed.

Abstract: The present invention extends to methods, systems, and computer program products for implementing parallel loops with serial semantics. Embodiments of the invention provide a semantic transforms and codegen patterns that provide more efficient parallel loop implementations with serial loop semantics. Embodiments of the invention support assignments within for-loop bodies, support break/return constructs within for-loop bodies, and run transformations to covert serial constructs to parallel constructs.

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.

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 an application virtual machine used for the host application can be determined, and the user script code can be instrumented with guards for detecting explicit debugging gestures based on a virtual machine's (VM') capabilities. 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.

Abstract: A method and system to implement debugging interpreted input is described herein. One or more Intermediate Language (IL) islands are generated. Each IL island maps to one or more lines of source code. The interpreter reads a line of source code and parses the line of source code for a command. Before executing the command, the interpreter may call into the corresponding IL island. The IL island may include a breakpoint that corresponds to a set breakpoint in the mapped one or more lines of source code. The IL island may include a function. When calling the IL island, the interpreter may pass in a function pointer, one or more states of one or more variables, a representation of a call stack, or any other parameters. The IL islands enable a debug tool to do source-level debugging of languages executed by an interpreter without architectural changes to the interpreter.

Abstract: Techniques are described that enable restoring interrupted program execution from a checkpoint without the need for cooperation from the computer's operating system. These techniques can be implemented by modifying existing code using an automated tool that adds instructions for enabling restoring interrupted program execution.

Abstract: A server exposes debugger services to a plurality of debugger clients. One or more debugger clients can select a debug operation and establish a debug session in a thread of a server process for debugging user code. A two-way debug communication pipeline can be established between a debugger client and the server using standard encoding protocols and standard network transport protocols. A two-way debug communication pipeline can be established using HTTP where the server can initiate a communication with the debugger client using a long polling technique. When one of the threads of the server process is suspended, the other threads in the server process continue to execute.

Abstract: The present invention extends to methods, systems, and computer program products for simulating stepping through interpreted code. Embodiments of the present invention facilitate debugging interpreted code. Thus, existing debugger technologies (e.g., those configured for use with compiled code) can be utilized to debug interpreted code. More specifically, existing debugger technologies can be used to step through interpreted code, without stepping into the code of interpreter itself. Accordingly, users developing interpreted code can be provided a stepping experience of relatively the same quality provided to developers developing compiled code, without having to reengineer debuggers to compensate for interpreted code.

Abstract: Instruction sets in computing environments may execute within one of several domains, such as a natively executing domain, an interpretively executing domain, and a debugging executing domain. These domains may store values in a shared region of memory in different ways. It may be difficult to perform operations on such values, particularly if a domain that generated a particular value cannot be identified or no longer exist, which may obstruct shared accessing of values and evaluative tasks such as stack walks. Instead, accessors may be associated with a stored value that perform various operations (such as low-level assembly instructions like Load, Store, and Compare) according to the standards of the value-generating domain, and domains may be configured to operate on the value through the accessors. This configuration may promote consistent accessing of values without having to identify or consult the value-generating domain or reconfiguring the instruction sets.

Abstract: Various technologies and techniques are disclosed for testing intermediate language operations. A debugger harness is provided that instruments an intermediate language stream to replace intermediate language operations with equivalent virtual intermediate language operations. A particular intermediate language operation is intercepted from the intermediate language stream and the equivalent virtual intermediate language operation is determined. The virtual machine runs under a debugger harness so that one or more managed applications are executed using the equivalent virtual intermediate language operations. This allows a functionality of the debugger to be tested.