Microsoft Technology Licensing, LLC

Martin James Gudgin

Donald F Box

Todd R Manion

Shiraz Jitendra Cupala

Zhangwei Xu

Curt Andrew Steeb

Jeffrey C Schlimmer

Jeremy Lee Dewey

Christopher L Anderson

Min Liu

Anthony Vincent Discolo

Kean Ee Lim

Grant Gardner

Edmund Hon-Sum Lui

Ryan B Elgram

Clemens Alden Szyperski

Quetzalcoatl Bradley

Joshua Ryan Williams

Jeffrey S Pinkston

Christopher G Kaler

Erik B Christensen

Kenneth David Wolf

Elliot Lee Waingold

Michael Steven Vernal

David E Langworthy

Michael John Hillberg

Geoffrey M Kizer

John Raymond Justice

John David Doty

Charles P Jazdzewski

Robert A Relyea

Natasha Harish Jethanandani

Siddhartha Puri

Gopal Kakivaya

Yaniv Pessach

Brian Faris Chapman

Joel David West

Device linking is described. In one or more implementations, data is maintained at a network service that describes characteristics of a plurality of devices that are associated with a user account of the network service. A communication is formed to be received by one of the plurality of devices that includes a portion of the data that pertains to another one of the plurality of devices and that is suitable by the receiving device to discover the other one of the plurality of devices to initiate a local network connection between the devices.

Device linking

A nominal type framework can be configured to efficiently correlate different nominal types together based on a minimum set of common type shapes or structures. In one implementation, a developer identifies a number of different nominal types of interest (source types), and identifies the minimum set of common type shapes to be accessed by an application program. The minimum set of common type shapes can then be used to create an intermediate type (target type) to which each of the other different source types can be mapped. For example, one or more proxies can be created that map shapes of the one or more source types to corresponding shapes of the created target type. The application program created by the developer, in turn, can access, operate on, or otherwise use the mapped data of each different source type through a single target type.

Efficiently correlating nominally incompatible types

A common data type structure can be used to correlate access requests between applications that implement data in accordance with different types or type structures. In one implementation, a common data structure includes schemes for operations, sequences, records, and atoms (i.e., undefined). The system can then map any type structure to the schemes of the common data structure. In operation, a request for data by an application can involve identifying one or more proxies used by an application to map the data to the common data structure. The proxies map the data to the common data structure based on the shape of the data (to the extent it can be identified). The proxies then can return one or more data structures that comprise the identified mapping information. The application can then perform operations directly on the received data structures.

Accessing different application data via a common data structure

A mechanism for sending structured data using a corresponding byte stream. Upon accessing structured data such as a Simple Object Access Protocol (SOAP) envelope, a byte stream is generated. The byte stream includes bytes that represent the structured data, as well as a collection of bytes that represents properties about the byte stream such as, for example, a mode of communication. The byte stream may then be passed to a communication module (e.g., a TCP or Named Pipes module) capable of receiving and transmitting the byte stream.

Mechanism for binding a structured data protocol to a protocol offering up byte streams

Bookmarking of tokens in a set of streaming tokens, each representing an instantiation instruction or instantiation context. A navigator receives a set of streaming tokens, and provides the tokens to the instantiation manager. However, if the navigator receives an instruction to bookmark a particular token, the navigator buffers the set of streaming instructions at least beginning at the bookmarked token (and possible even earlier if there were prior bookmarks). The navigator replays the set of streaming tokens beginning at a bookmark in response to an instruction from an instantiation manager. The instantiation manager receives the set of streaming tokens. If the instantiation manager is not presently capable of handling the instruction of a particular token, the instantiation manager instructs the navigator to bookmark the particular token. When the instantiation manager later receives a token that permits the instantiation manager to return to the bookmark, the instantiation manager returns to the bookmark to replay the instantiation instructions beginning at the bookmark.

Streaming object instantiation using bookmarks

Determining compatibility of data structures. A method may be practiced in a computing environment. The method includes accessing a first type defined in a mark-up object. The first type includes a first structure including a first plurality of fields. A second type defined in a mark-up object is accessed. The second type includes a second structure including a second plurality of fields. The first structure and the second structure are compared. Based on the comparison, a determination is made that the first type is compatible with the second type.

Data description language for record based systems

Structuring a data structure that is of a particular type that has a particular schema used for validation, in a manner that permits selected components of the data structure to be optionally transformed while retaining the ability to validate the data structure. The data structure includes information that is sufficient to identify one or more transformations that may occur on at least one component of the data structure while still being valid.

Valid transformation expressions for structured data

A sending computer system can identify one or more available network resources at one or more network computers by sending a request for services using Simple Object Access Protocol (SOAP) over User Datagram Protocol (UDP). In particular, the sending computer system prepares a SOAP message that includes a request for available resources. The sending computer system then encapsulates the SOAP message into a user datagram, and sends the user datagram to one or more identifiable computer systems on the network. In one implementation, the sending computer system sends the user datagram to a multi-cast Uniform Resource Identifier (URI). The receiving computer system receives the message through UDP, unpacks the message, and responds to the SOAP message request. Accordingly, the sending computer system can query multiple computer systems in an efficient manner without necessarily incurring the overhead otherwise associated with connection-oriented communication.

Querying for services using soap over UDP

Growing community of inventors

Sammamish, WA, United States of America

Martin James Gudgin