Microsoft Technology Licensing, LLC

Microsoft Corporation

John David Doty

Donald F Box

Jeffrey C Schlimmer

David E Langworthy

Bradford H Lovering

James Ernest Johnson

John Lawrence Hamby

Max A Feingold

Kapil Gupta

Andrew Donald Gordon

Michael Ray Clark

Craig Andrew Critchley

Gavin Mark Bierman

Giovanni Moises Della-Libera

Clemens Alden Szyperski

Jonathan M Cargille

Geoffrey M Kizer

Randy S Kimmerly

Haroon Ahmed

William J Carley

Joshua Ryan Williams

Christopher G Kaler

Erik B Christensen

Kenneth David Wolf

Stephen James Millet

David Wortendyke

Tirunelveli R Vishwanath

Lance Olson

Richard Douglas Hill

David Michael Miller

Umesh Madan

Stefan R Batres

Michael James Coulson

Stefan Harrington Pharies

Christopher L Anderson

Vijay Gajjala

Uday Sooryakant Hegde

Michael Marucheck

Elliot Lee Waingold

Krishnan Srinivasan

Matthew Thomas Tavis

Geary L Eppley

Tomasz Janczuk

Michael Steven Vernal

Stephen T Swartz

David Edwin Levin

Martin James Gudgin

Shy Cohen

Dana D Groff

Harris Syed

Richard Dievendorff

Douglas M Purdy

Natasha Harish Jethanandani

Jeffrey S Pinkston

David Owen Driver

Siddhartha Puri

Saurab Nog

Aaron Stern

Andrew D Milligan

Douglas A Walter

Jesus Ruiz-Scougall

Anastasios Kasiolas

Ryan Thomas Sturgell

Vipul A Modi

Saji Abraham

Evgeny Osovetsky

Mohammad Makarechian

Alexander Martin DeJarnatt

Sowmyanarayanan K Srinivasan

Scott Christopher Seely

Jonathan T Wheeler

Erin Honeycutt

Chaitanya Dutt Upadhyay

Michael Thomas Dice

Yaniv Pessach

Mauro Ottaviani

Alfred M Lee, Iv

Eugene Shvets

Yasser Shohoud

Serge Sverdlov

Vaithialingam B Balayogan

Anand Rjagopalan

Mohamed-Hany Essam Ramadan

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

Data is accessed and updated in a data store at a field granularity. A user query specifies one or more non-unique fields of a record. The query is sent to a data store to retrieve the fields of the record at a field granularity, in satisfaction of the query. The fields of the record can also be modified by transmitting a record ID along with original content, while omitting some of the record data, and by also including the modification to be made.

Data framework to enable rich processing of data from any arbitrary data source

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

Computing responses to semantic queries. A method includes accessing a plurality of objects that represent source code for an input program. The source code is transformed into a plurality of immutable objects that are structured such that the immutable objects can be used to derive any response as defined by the semantic rules about the source code. A query is received from a requestor requesting a semantic characteristic of the input program. The semantic characteristic is calculated. The semantic characteristic is returned to the requestor. The semantic characteristic is cached in a cache. Information describing a dependency between the cached semantic characteristic and one or more of the objects in the plurality of objects is stored.

Partial on-demand lazy semantic analysis

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

Accessing data in a data store at a field granularity. A method includes receiving a query from a user. The query specifies one or more non-unique fields of a record. The method further includes sending the query to a data store to retrieve the fields of the record at a field granularity. The method further includes receiving data for the one or more non-unique fields of the record at a field granularity.

The setting up of a circular log implementation to be able to detect amnesia in a circular log, and to the determination of whether or not amnesia has occurred in such a circular log. Upon detecting a checkpoint trigger, information is preserved sufficient to detect whether or not the removed records ever existed in the circular log. If a request for information from a record were subsequently to be received by the circular log implementation, and if the record was not actually in the circular log, the preserved information could then be consulted to see if it indicates that the record had once existed in the circular log. If the information indicates that the record had once existed in the circular log, then amnesia has not occurred. If the information does not indicate that the record had once existed in the circular log, then amnesia has occurred. Accordingly, amnesia detection is made possible even in a complicated circular log implementation.

Circular log amnesia detection

A transaction manager virtualization layer is provided for supporting multiple active transaction managers in a cluster or node. By virtualizing the transaction managers, applications and services are enabled to migrate across cluster nodes or even outside a cluster that includes relevant recovery mechanisms for transactions that are not completed at the time of migration. Multiple implementations of a transaction manager may be enabled to run side-by-side in a node or cluster allowing a rolling upgrade of transaction managers in clusters.

Transaction manager virtualization

Log file amnesia detection is accomplished by associating a unique identifier with each record in a log file, where each record receives a unique log sequence number. Multiple time intervals are associated with the log file with different events triggering the beginning of a new time interval. The log file implementation marks the beginnings of these multiple time intervals with a unique identifier. Every time an event occurs that triggers a new time interval a new unique identifier is generated. This unique identifier will be associated with the records in the log file that are created thereafter until the next unique identifier gets generated, marking the beginning of a next time interval. Log file amnesia can be identified when a log client requests information about a record and then comparing the unique identifier and log sequence number of the record with all records in the log file.

Log file amnesia detection

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

A mechanism for negotiating a relatively transport agnostic communication protocol for use in accomplishing a distributed activity. The potential protocols subject to negotiation may be, for example, extensions to Web Services Coordination. In that case, when the initiator creates a transaction, the initiator also negotiates the desired protocol with its transaction manager. The transaction manager and any other participants in the transaction will then follow that negotiated protocol when communicating with the transaction manager. The protocol may be selected to improve performance and may be tailored to existing needs and capabilities.

Message exchange protocol extension negotiation

Growing community of inventors

Seattle, WA, United States of America

John David Doty