Microsoft Technology Licensing, LLC

Jeffrey C Schlimmer

Donald F Box

Bradford H Lovering

David E Langworthy

John David Doty

Martin James Gudgin

Luis Felipe Cabrera

Paul J Leach

Erik B Christensen

Kenneth David Wolf

William Michael Zintel

Andrew Donald Gordon

Shyamalan Pather

Geoffrey M Kizer

Holly Knight

John Lawrence Hamby

Peter Sewall Ford

Amar S Gandhi

Ye Gu

Gavin Mark Bierman

Daniel R Weisman

Ting Cai

Christopher M Rude

Donald R Ryan

Christopher G Kaler

David Wortendyke

Craig Andrew Critchley

Elliot Lee Waingold

Geary L Eppley

Michael Steven Vernal

Christian F Huitema

Steven E Lucco

John Peter Shewchuk

Gopala Krishna R Kakivaya

Richard L Hasha

Giovanni Moises Della-Libera

Henrik Frystyk Nielsen

Edmund Samuel Victor Pinto

Michael John Hillberg

Jeffrey Bruce Parham

John Raymond Justice

Christopher L Anderson

Alfred Lee

Charles P Jazdzewski

Robert A Relyea

David Edwin Levin

Natasha Harish Jethanandani

Jeffrey S Pinkston

Siddhartha Puri

Gopal Kakivaya

Yaniv Pessach

Brian Faris Chapman

Joel David West

Michael Grodin

Shane H Hilton

Scott C Catlin

Don Box

A spectator client device receives a plurality of spectator update frames that include respective actual physics state information for game objects of respective participants in a multiplayer game session. The spectator client device buffers respective ones of the spectator update frames for respective participants, and determines based on respective downlink spectator update frames buffered for the respective participants, respective simulated playback physical states at a common playback time of a current simulation period. A particular simulated playback physical state for a particular participant is determined based on actual physics state information obtained from at least two respective downlink spectator update frames buffered for the particular participant. The spectator client device renders a delayed depiction of the multiplayer game session at the common playback time of the current simulation period based on the playback physical states determined, for the respective participants, for the current simulation period.

Spectating simulation

Innovations in the area of controlling behavior of computer-controlled entities such as cars in a computer-represented environment are presented herein. In various examples described herein, the behavior of computer-controlled cars is controlled by an artificial intelligence ('AI') behavior engine. The AI behavior engine performs operations to determine if the behavior (driving pattern, etc.) of a computer-controlled car should change for a funnel section. If so, the AI behavior engine switches the computer-controlled car to a trailing mode configuration and selects a candidate car to follow in the funnel section based on various criteria. The AI behavior engine also determines how to follow the candidate car by selecting a racing path and setting rules to determine the speed to use for following the candidate car. Control values are then set. The described innovations also generally apply to other racing scenarios, self-driving/autonomous cars, and other applications with robotic equipment and devices.

Controlling behavior of entities in funnel sections of a computer-represented environment

A common intermediate representation for a data scripting language is provided for efficient representation and direct specification of programming constructs in memory. The common intermediate representation of data scripts allows data intensive applications to be created and analyzed in a machine accessible format, and the elements of the common intermediate representation can be stored independent of underlying storage specifics. Stored elements of the common intermediate representation of code are thus available for fast loading in memory when desired by other applications and programs by mapping the stored elements to the in memory intermediate representation.

Common intermediate representation for data scripting language

An efficient, logical and expressive type system is provided for flexibly defining types of a declarative programming language so that efficient and structurally compact data intensive applications can be generated. The type system supports the combination of refinement types and type membership expressions, as well as a top type that encompasses all valid values as members. With the type system, types can be expressed as intersections and/or unions of other types. Thus, types can be efficiently represented for a full range of types of data as may be found in real world data stores.

Type system for declarative data scripting language

An efficient, logical and expressive type system supports the combination of refinement types and type membership expressions, as well as a top type that encompasses all valid values as members. A bidirectional type checking algorithm is provided for the type system including synthesis and checking steps to statically verify types of code based on the type system.

Bidirectional type checking for declarative data scripting language

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

The integration of two runtimes. The integration may be accomplished via the sharing of all or a portion of the environments of each of the runtimes with each other. For instance, as one runtime executes a particular application, control may be passed at an appropriate point to the second runtime. The second runtime may pass control back to the first runtime at an appropriate time. This passing of control between runtimes may happen perhaps a number of times during the execution of the application. The applications might be expressed entirely declaratively in a manner that integrates both runtimes as the application executes. Thus, the application may take advantage of the strengths of each runtime at the appropriate time.

Integration of runtime environments

An efficient, logical and expressive type system supports the combination of refinement types and type membership expressions, as well as a top type that encompasses all valid values as members. Various embodiments verify the validity of subtyping relationships by translating to first-order logic, and invoking a general-purpose theorem prover with the first-order logic as input. In contrast to treating formulas as types, types are translated into formulas of standard first-order logic. Moreover, to represent data structures of the programming language as first-order logic, universal and existential quantifiers of first-order logic, and function symbols in terms, are exploited. Data intensive applications can be generated, verified, and deployed with greater speed and scale.

Semantic subtyping for declarative data scripting language by calling a prover

The subject disclosure relates to a syntax for a scripting language that allows data intensive applications to be written in a compact, human friendly, textual format. The scripting language can be a declarative programming language, such as the 'D' programming language, which is well suited to the authoring of data intensive programs. A compact query syntax is provided for D that simplifies the expression of complex and data intensive programs. In another non-limiting aspect, conventional operator precedence is modified to accommodate the compact syntax and other unique features of a general purpose declarative programming language.

Compact syntax for data scripting language

Activity callbacks in a continuation-based runtime. At framework-definition time, a framework activity is authored. The framework activity may have an environmental logic portion the processes input or output parameters whose values will be supplied to and/or received from an activity callback. The framework activity also includes a callback invocation portion that, during execution time, will actually provide parameter value(s) to and/or receive parameter value(s) from the activity callback. The framework activity serves as a framework that operates with any activity callback that has one or more characteristics. Such activity callbacks may not even be defined at framework-definition time. Instead, the framework activity may be used multiple times in the same applications, or in different applications to thereby provide core framework functionality, while allowing application developers to plug in activity callbacks that meet the custom needs of the application.

Continuation-based runtime callback invocation

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

Systems and methods for open content model Web service messaging in a networked computing environment are described. In one aspect, a transport neutral message is generated that includes message recipient, endpoint addressing information, and one or more reference properties. The reference properties include selectively opaque message context. The transport neutral message is bound to a transport protocol for communication to the message recipient. At least a portion of the selectively opaque message context is not directed to the message recipient.

Open content model Web service messaging

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

Example embodiments provide for a new set of binding extensions that allow individual messages within a contract of a Network Protocol Description Language data structure (e.g., a portType of a WSDL document or file) to flow over different transports and to different network transport addresses. Further, example embodiments provide for a concise expression of protocol choices through the use of a default element for specifying one of a plurality of binding mechanisms. Moreover, the present invention also provides for not only defining services within a document or data structure through standard URLs, but also for allowing the addressing of a service using an endpoint reference as defined by, e.g., WS-Addressing. This allows for a more robust way to address a service in a document by providing a lightweight, extensible, self-contained description of the service.

Binding heterogeneous transports to a message contract

Growing community of inventors

Redmond, WA, United States of America

Jeffrey C Schlimmer