Microsoft Technology Licensing, LLC

Gregg Bernard Miskelly

Robert Alan Paveza

Timothy Scott Rice

Andrew R Sterland

Christopher Douglas Edmonds

Michael C Fanning

Jackson Michael Davis

Patrick Nelson

Felix Gerard Torquil Ifor Andrew

Paul Maybee

Simon Calvert

Jonathon Michael Stall

Elliot H Omiya

Samuel Ng

Richard Byers

Harold L Pierson, Iii

Eric H Feiveson

Daniel James Moseley

Gearard Boland

Francisco Javier Wong

Zhaochuan Gao

Andriy Stasyuk

Jeffrey T Fisher

Taylor C Woll

Karthik Vivek Nadig

Stephen Harris Toub

Brian Robert Crawford

Mikhail Arkhipov

John A Cunningham

Feng Yuan

Paul Matthew Pietrek

Dmitry Lomov

Abhijit Rao

Daniel Moth

Roger Wolff

Nikhil Khandelwal

Azeemullah Khan

Wai Hang Tang

Johan Marien

Jonathan Michael Stall

Ian William James Halliday

Andrew Richard Sterland

Paul E Maybee

The present invention extends to methods, systems, and computer program products for stepping through JavaScript code in a debugger without landing on errors in library or open source code. A debugger receives user inputs designating one or more segments of the JavaScript code as library code. The debugger then performs debugging operations on the JavaScript code. The debugging operations including a stepping operation for stepping through the JavaScript code to identify errors only in user-generated segments of the JavaScript code, wherein the user-generated segments correspond to code that was not designated as library code.

Javascript debugging using just my code

A method for diagnosing computer readable instructions related to transfers of control is disclosed. A state transition of a unit of execution within a logical operation providing an event handler for a Document Object Model is logged during runtime of the computer readable instructions. Diagnostic information of the logical operation is associated with the state transition. The state transition and associated diagnostic information is provided for retrieval at a selected point in the computer readable instructions.

Diagnostics of state transitions

A method for diagnosing computer readable instructions related to transfers of control is disclosed. A state transition of a unit of execution within a logical operation is logged during runtime of the computer readable instructions. Diagnostic information of the logical operation is associated with the state transition. The state transition and associated diagnostic information is provided for retrieval at a selected point in the computer readable instructions.

Object marshaling techniques in a marshaling system for computer networks are disclosed. A gesture is provided to the object marshaling system that a reference object has expired on a sender side and a target side when the reference object is closed. Parent and child relationships are recognized in a descendent reference object to the reference object. The descendent reference object closes when the reference object closes.

Object marshaling

Just My Code debugging allows developers to work on problems within their own code without noise from libraries, plugins and other unrelated code. Typical debugger behaviors may be modified based upon the identification or characterization of JavaScript code as 'My Code,' 'Library Code,' or &#x201c;Unrelated Code.&#x201d; The debugger behaviors that may be modified depending upon the code's characterization include, for example, first-chance exception handling, unhandled exception handling, the behavior of the debugger at explicit user breakpoints, the behavior when a user directs the debugger to break upon the next statement, and the behavior of the debugger when the user executes a stepping gesture. The debugger's visualizes core elements of the program state, such as the call stack, depending upon the identification or characterization of the code.

Exception and debugging behaviors for JavaScript debugging using just my code

Just My Code debugging allows developers to work on problems within their own code without noise from libraries, plugins and other unrelated code. Typical debugger behaviors may be modified based upon the identification or characterization of JavaScript code as 'My Code,' 'Library Code,' or &#x201c;Unrelated Code.&#x201d; The debugger behaviors that may be automatically determined using heuristics or set using a code-characterization file provided by a host application. The debugger receives project file information from the host application via a debugger-host interface. The debugger applies code-designation heuristics to undesignated code segments. If a code characterization file is received with the project information, the debugger designates application code segments based upon definitions in the code-characterization file. Once the debugger has characterized the code segments, it performs debugging operations on the application code. The behavior of the debugging operations may be selected depending upon the designation of the application code segments.

Classification of JavaScript code for debugging using just my code

An expression can be evaluated in a remote debugging environment with one single round trip across the network. An expression evaluator on a local machine can compile the expression into a language-independent intermediate language (IL) that encodes all the information needed to evaluate the expression in the absence of a symbol table. The IL can include instructions that manipulate state inside the debuggee process, as well as logical operations needed to process the information. The IL language can be turing complete so that any computation needed to determine the state to read and write and how the information gathered is to be combined can be performed. The IL can be sent to the remote computer and can be interpreted on the remote computer. The IL can be interpreted on the remote computer using a stack based mechanism, without the need to access symbolic information on the local computer.

Reducing network trips for remote expression evaluation

A system for organizing messages related to tasks in a distributed application is disclosed. The system includes a work-list creator to create a work list of the top-level work items to be accomplished in performing a task. Work-item processors are distributed in the system. The work-item processors process the top-level work item included in a task and also append additional work items to the work list. A work-list scheduler invokes the work-item processors so local work-item processors are invoked prior to remote work-item processors.

Work item processing in distributed applications

Stepping out of an asynchronous process. A method includes, as part of a computer program execution, at a caller, making an asynchronous function call from the caller to a callee. Associated with the asynchronous function call a continuation waits for the completion of the callee with respect to the asynchronous function call. The method further includes correlating a debugging indicator to the callee indicating that a user wishes to step out of the caller when the callee returns. An indication of completion of the callee with respect to the asynchronous function call and that a user wishes to step from the callee to the continuation is received. The debugging indicator is referenced and based on the debugging indicator execution at entry into the continuation is stopped.

Stepping out of an asynchronous method into its continuation in a debugger

Launching a debugging process. A method includes at a compute node on a cluster private network, receiving a debug job via a scheduler of a head node from a client on a public network. The head node is connected to both the cluster private network and the public network. The public network is external to the cluster private network. The method further includes beginning processing the debug job, and as a result initiating debugging by starting one or more debugger remote agents at the compute node. The method further includes beginning processing a user job in the presence of the started debugger remote agents at the compute node. The client is informed that the one or more debugger remote agents are ready to debug the user job. A debugger client at the client is connected to the one or more debugger remote agents.

Debugger launch and attach on compute clusters

Simultaneous debugging of code running in multiple types of runtime environment can be performed by an n-way interoperative debugging environment. Code running within a particular runtime can be debugged simultaneously with a code running within other runtimes within a single process. Out-of-process debugging support is provided for inspection and execution control. A compatible debugger or runtime communication protocol is used. Transitions from one runtime to another runtime can be detected. Exceptions thrown in one runtime can be caught by another runtime. Stepping operations can occur in multiple runtimes. A callstack including frames from multiple runtimes can be walked.

N-way runtime interoperative debugging

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.

Simulating operations through out-of-process execution

The present invention extends to methods, systems, and computer program products for mapping breakpoints between Web based documents. Embodiments of the invention facilitate extracting corresponding client script blocks from different Web based documents to disassociate the client script blocks with their relative locations within the Web based documents. From the extracted client side script blocks, a position for mapping a breakpoint from one client side script block another client side script block can be determined. The breakpoint is then copied from the one client script block and inserted into the determined position in the other client script block. The client script blocks can then be re-associated with their relative locations in the Web based documents from which they were extracted.

Mapping breakpoints between web based documents

Threads operating in a computing environment often invoke service functions, such as methods of a programming library. Such invocations may sometimes cause a blocking of the thread, which may be protracted. A long pendency of the service function invocation and blocking of the thread may be acceptable in some operating contexts, such as the ordinary processing of the thread, but may be unacceptable in other operating contexts, such as while performing a function evaluation during debugging. Such blocking may be mitigated by redirecting a service function to an abort function if the service function is capable of blocking the thread and the thread is operating in a safe mode. The thread may then be permitted to execute, and the potentially blocking service functions may be avoided, resulting in a function evaluation abort (e.g., an exception) rather than a blocked thread and a failed debugging scenario.

Service function redirection for avoiding function evaluation blockages

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.

Growing community of inventors

Seattle, WA, United States of America

Gregg Bernard Miskelly