Microsoft Technology Licensing, LLC

Steven E Lucco

Christopher G Kaler

Curtis Cheng-Cheng Man

John Peter Shewchuk

Yong Qu

Bradford H Lovering

Miladin Pavlicic

Justin Rogers

Travis Leithead

Nathan J E Furtwangler

Reza A Nourai

Giovanni Moises Della-Libera

David E Langworthy

Luis Felipe Cabrera

Erik B Christensen

Stephen James Millet

Anders Hejlsberg

David Edwin Levin

Donald F Box

Henrik Frystyk Nielsen

Robert S Wahbe

Charles P Jazdzewski

Louis Lafreniere

Lucas James Hoban

Paul J Leach

Robert George Atkinson

Richard F Rashid

Butler W Lampson

David Wortendyke

Patrick James Helland

Mads Torgersen

Jesse D McGatha

Allen L Brown, Jr

Scott A Konersmann

Jomo Fisher

Steven J Steiner

Joseph Pamer

Jedrzej Z Miadowicz

Michael Wayne Jackson

Yunus Kilic

Patrick Henri Dussud

Michael C Fanning

Jerry Jay Dunietz

Raja Krishnaswamy

Andrew Layman

Martyn S Lovell

Mahesh Prakriya

Elliot H Omiya

Stephen C Rowe

Ales Holecek

Tassaduq Basu

Noel Richard Cross

James F Springfield

Brent Rector

Kurt William Berglund

Paul Adrian Leathers

John P Shewchuck

John Joseph Duffy

Gopala Krishna R Kakivaya

Martin Taillefer

Vance Palmer Morrison

Peter Loren Engrav

Andrew R Sterland

Randy S Kimmerly

Jeffrey C Schlimmer

Malia Morioka Douglas

Christopher W Fraser

Stefan Harrington Pharies

Craig Andrew Critchley

Caitlin E Ashley-Rollman

Geary L Eppley

Stephen T Swartz

George Prentice Copeland

Frederico A Mameri

Douglas M Purdy

Natasha Harish Jethanandani

Rachel Sirkin

Aaron E Erlandson

Trevor J Harris

Mark Brian Shields

Sowmyanarayanan K Srinivasan

John P Shewchulk

David A Wortendyke

David E Levin

Dynamic code generation and coordination techniques are provided for display of dynamic markup documents including script code. A code generation process is not only guided by deferral of code preparation stages and sub-stages, but also informed by various information levels possessed concerning the code itself, either through interpretation or observation of execution, to not only generate modified code, but also to generate alternative code for alternative situations (e.g., generating different loop bodies that can thereafter be readily swapped in or out depending on a given function call by the browser application). A multi-core architecture further improves user experience by asymmetrically ensuring web site presentation and functionality is prioritized for the user experience.

Fast presentation of markup content having script code

Disclosed embodiments provide for collaborative access to a distributed data structure. Operations such as inserting, deleting, and annotating are performed by various clients participating in the collaboration. A serialization service enforcing a single order of these operations and ensures the operations and order are communicated to all of the clients participating in the collaboration. Once all clients have acknowledged particular operations, this information is also communicated to all of the clients, such that the clients may perform maintenance activities on the collaboration data structures. The result is a rolling collaboration window shared by all of the clients of the collaboration, with a bottom of the collaboration window defined by a lowest ordered operation not yet acknowledged by all clients of the collaboration, and a highest ordered operation as assigned by the serialization service.

Messaging to enforce operation serialization for consistency of a distributed data structure

Disclosed embodiments provide for collaborative access to a distributed data structure. The disclosed embodiments include collaboration participant devices or instances that each represent a distributed data structure via a tree data structure. The collaboration participants perform operations on the distributed data structure and communicate these operations to each other via a serialization service. The tree structure maintained by each of the collaboration participants stores unacknowledged operations and also collaboration participant specific length information for collaboration participants. Once a particular operation has been acknowledged by each of the collaboration participants, this is communicated to all of the participants by the serialization service. The collaboration participants may then perform maintenance on a portion of the tree structure represented the acknowledged operation. For example, nodes of the tree representing adjacent data in the distributed data structure may be combined, or data removed by an acknowledged operation may be removed from the tree.

Merge trees for collaboration

An apparatus for a real-time collaboration in calendar is described herein. The apparatus includes a state change module to receive a change notification at a second calendar client rendering a shared calendar. The apparatus also includes an identification module to retrieve an identification (ID) of calendar content, a change in a user interface state, and an extent of a calendar view from a first data structure. Finally, the apparatus includes a replica module of the second client to retrieve calendar content from a second data structure using the ID as an index value.

Real time collaboration in calendar

Aspects of the subject matter described herein relate to generating and caching software code. In aspects, a target device may receive software to install. The software may include source code that has not been compiled. The target device may install the software and indicate the source code of the package is to be compiled into intermediate or executable code that is persistently stored. If the target device receives a request to execute the software prior to it being compiled, the target device may compile and execute the software without delay. If the target device receives a request to execute the software after it is compiled, the target device may obtain and execute the compiled code. The behavior above may also be applied to scripting code obtained from a server remote to the target device.

Generating and caching software code

Aspects for conservative garbage collecting are disclosed. In one aspect, root objects included in a call stack are identified, which comprise integers and pointers. Integer representations are tagged and distinguishable from untagged pointer representations. Root objects are traced to corresponding memory locations such that a subsequent tracing is performed on the pointer representations and skipped on the integer representations. Memory allocated to objects unreachable by the call stack is then freed. In another aspect, an object graph associated with a call stack is tagged, and a heap is generated comprising objects included in an executed portion of the call stack. Objects included in an unexecuted portion of the call stack are traced to corresponding memory locations on the heap such that a subsequent tracing is only performed on the untagged pointer representations. Memory locations corresponding to heap objects unreachable by the unexecuted portion of the call stack are then cleared.

Conservative garbage collecting and tagged integers for memory management

Dynamic code generation and memory management techniques are provided for component object model (COM) objects with corresponding representations in script code and native code. A browser component can receive script code including the code representing the COM object and a marshaling component is provided that marshals, based on a request for native code representing the COM object, the code representing the COM object to the native code based on a pre-constructed intermediate data structure. The pre-constructed intermediate data structure, such as a virtual table, is pre-constructed based on a dynamic type representation associated with a prototype of the COM object and cached for re-use by the marshaling component. Other embodiments provide finalizer support for memory management of COM objects having script and native world representations including an implementation of a two-phase commit protocol that enables efficient and conservative recycling of objects and associated memory.

Dynamic code generation and memory management for component object model data constructs

Various embodiments provide an interface between a Web browser's layout engine and a scripting engine. The interface enables objects from the layout engine to be recognized by a memory manager in the scripting engine and interact in a streamlined, efficient manner. In accordance with one or more embodiments, the interface allows browser layout engine objects to be created as objects that are native to the scripting engine. Alternately or additionally, in some embodiments, the native objects are further configured to proxy functionality between the layout engine and the scripting engine.

Interface definition language extensions

Static type checking can be performed on types and values defined in modules in a system that dynamically composes programs from modules. The types and values do not share a global namespace. Each module defines its own module universe, disjoint from other modules. A language mechanism can establish a local name binding to one module within the content of another module. When type checking at compile time an environment can be established that corresponds to a runtime instance of the program. The static type system can be arranged to align with the runtime values, such that the names used to refer to objects at runtime are the same as the names used to refer to the types of those objects in the static type system. Aliases of a particular type are resolved to a known compile time description of the type.

Static type checking across module universes

Growing community of inventors

Seattle, WA, United States of America

Steven E Lucco