Microsoft Technology Licensing, LLC

Avner Y Aharoni

Henricus Johannes Maria Meijer

David N Schach

Brian C Beckman

Paul Allen Vick, Jr

Peter Drayton

Amanda K Silver

Ralf Lammel

Adam Wiener

Alexander Vaschillo

Aleksey V Tsingauz

Timothy Yat Tim Ng

Bertan Ari

Alex Laskos

Mads Torgersen

Andrew Eyring Kimball

Todd F Pfleiger

Kevin Wagner Halverson

Lisa Feigenbaum

Scott Daniel Wisniewski

Anders Hejlsberg

Wolfram Schulte

Matthew J Warren

Raja Krishnaswamy

Erik Meijer

Luca Bolognese

Haroon Ahmed

Chris A Suver

Samuel Ng

Steven D White

Jared Porter Parsons

Peter H Golde

Andrew Conrad

Neal M Gafter

Michael Shneerson

Srinivasa Rao Burugapalli

Timothy Ng

Kevin Pilch-Bisson

Lucian Wischik

Karen Liu

Rotem Bennet

Jason Zhengnan Zhu

Renaud Paquay

Olivier Michel Destrebecq

Ghanashyam Chandrasekhar Namboodiripad

Joseph Tyler Whitney

Priyamvadha P Lakshminarayanan

Ilker Cengiz

Sravani Kothapalle

Vladimir G Sadov

Abel Valadez Martinez

Sophia Salim

Jonathan Paul Aneja

Edward T Maurer

Efficient immutable syntax representation with parent pointers under incremental change is enabled by creating a data structure comprising at least one tree structure that allows both upward and downward references in the tree and a tree structure that is immutable (read-only), and allows parts of itself to be re-used in other data structures. The data structure described enables tools to search and target particular sub trees. The fragment of the tree representing the targeted sub tree is produced as it is used. The rest of the tree is not produced. The read-only tree retains relative information, allowing it to be reassembled and shared.

Efficient immutable syntax representation with incremental change

Embodiments that relate to providing a low-latency interaction in a virtual environment are provided. In one embodiment an initial image of a hand and initial depth information representing an initial actual position are received. The initial image is projected into the virtual environment to an initial virtual position. A segmented version of the initial image is provided for display in the virtual environment at the initial virtual position. A subsequent image of the hand and depth information representing a subsequent actual position are received. The subsequent image is projected into the virtual environment to a subsequent virtual position. A segmented version of the subsequent image is provided for display at the subsequent virtual position. A collision is detected between a three-dimensional representation of the hand and a virtual or physical object.

Virtual interaction with image projection

Compiler functionality is componentized to enable use across different contexts. Conventionally tightly coupled functionality is decoupled and an interface afforded to facilitate interaction with compiler components/subcomponents in various scenarios. In one instance, compiler components can be employed across compile time and runtime. Compile time functionality can be employed at runtime and runtime functionality utilized at compile time thereby blurring the line between time dimensions.

Componentization of compiler functionality

When a user enters text into an application, the application can utilize an auto-complete feature to provide the user with estimations as to a complete term a user is attempting to enter into the application. Visualization can be provided along with an estimation to disclose the likelihood the estimation is what the user intends to enter. Furthermore, a rationale can be provided to the user for the reason an estimation was provided to the user.

Visualization techniques for imprecise statement completion

Systems and methods that enhance and balance a late binding and an early binding in a programming language, via supplying an option component to opt-in (or opt-out) late binding, and wherein a late binding is triggered based on a static type for the variable (e.g., object or a type/string.) Additionally, the variable is enabled to have different static types at different regions (e.g., a program fragment) of the programming language.

Type inference and type-directed late binding

A design time debugging tool provides debugging information available from the compiler during design time, as if a user were debugging code that provided the debugging information, by exposing information available from the compiler without initiation of a debugging session and without executing the program being debugged.

Time debugging

An architecture that that extends conventional computer programming languages that compile into an instance of an extensible markup language (XML) document object model (DOM) to provide support for XML literals in the underlying programming language. This architecture facilitates a convenient short cut by replacing the complex explicit construction required by conventional systems to create an instance of a DOM with a concise XML literal for which conventional compilers can translate into the appropriate code. The architecture allows these XML literals to be embedded with expressions, statement blocks or namespaces to further enrich the power and versatility. In accordance therewith, context information describing the position and data types that an XML DOM can accept can be provided to the programmer via, for example, an integrated development environment. Additionally, the architecture supports escaping XML identifiers, a reification mechanism, and a conversion mechanism to convert between collections and singletons.

Embedding expressions in XML literals

A batch compiler is employed to enable compilation of code provided at runtime. A managed application receives code during execution and invokes the compiler to transform the code to enable it to execute within the context of the receiving application. Among other things, employment of a batch compiler preserves investments made to such compilers while also opening up new scenarios in application scripting and/or hosting that are otherwise unavailable.

Compiler in a managed application context

Systems and methods that enhance expressibility in a programming language (e.g., Visual Basic) via relaxation of artificial restrictions and extension of delegates associated therewith, without changing the runtime infrastructure. A stub is employed that can replace an impermissible expression in the programming language, to leverage the existing permissible expressions.

Relaxed and extended delegates

The present invention extends to methods, systems, and computer program products for compile time interpretation of markup codes. Embodiments of the invention can be used to specify custom behaviors to be taken in response to any of a number of ways that markup codes (e.g., XML data) can be constructed and in response to any number of ways that markup codes can be accessed. At compile time, the construction of objects and/or the modes of access for objects using mark up codes are known. As such, the compiler, type-system and development environment can use a known set of custom behaviors to regulate or give feedback on what constructions or modes of access are allowed, and what their characteristics are.

Compile time interpretation of markup codes

Reshaping of streams is provided to facilitate utilizing the streams without rapidly increasing memory requirements as the size of the stream increases. The streams can be pushed to alternative storage upon being reshaped, for example, such as to a persistent storage. If the streams lose structure, for example if a hierarchical stream is reshaped into a flat structure for storage in a database, structural information can be stored along with the streams and utilized to shape the stream to its original structure upon request for data, for example. Streams can be pulled from an exposing device or application, and portions of the stream can be transformed and stored according to a set of stop elements; the stop elements can be associated with functions that take action on the stream upon reaching a stop element, such as transforming and storing a portion thereof.

Composite nested streams

Modified compilers and other development tools provide implied line continuation within a sequence of syntax tokens of a programming language grammar which includes multiple semantic contexts and which uses line termination as presumptive statement termination. When source code parsing encounters a line terminator adjacent a context-dependent implicit line continuation token in an associated semantic context, an explicit decision is made whether to imply line continuation. Line continuation may also be implied in response to other specified tokens.

Implicit line continuation

User assemblies can be created by a compiler that can handle more than one type definition during execution. Local copies are created for respective authoritative types in a code library, and the local copies are marked with a local type identifier. An authoritative type identifier (e.g., a globally unique identifier (GUID)) is copied from the authoritative type to the local type, and functions and properties associated with the local type are also copied from the authoritative type. Authoritative types are resolved for requested types when a local assembly references a local type from a compiled user assembly. The local type can be identified by a local type identifier, and an authoritative type can be retrieved from the code library that has a same authoritative type identifier as the requested type. A local copy of the retrieved authoritative type can be copied to the local assembly under compilation. The compiler can then emit user assemblies that comprise merely local types.

Handling multiple definition of types

Growing community of inventors

Seattle, WA, United States of America

Avner Y Aharoni