Microsoft Technology Licensing, LLC

Other

John Lawrence Hamby

David Charles Wrighton

Mircea Trofin

Michal Strehovsky

Fadi M Hanna

Patrick Henri Dussud

Donald F Box

Bradford H Lovering

David E Langworthy

John David Doty

Jeffrey C Schlimmer

Atsushi Kanamori

Rudi Martin

Morgan Asher Brown

Manish Kumar Jayaswal

Turgut Isik

Fatma Didem Gokbulut

Robert Yung-Yi Fu

Niklas Gustafsson

Aleksey V Tsingauz

Tomas Matousek

Andrew Casey

Li Zhang

Giovanni Moises Della-Libera

Michael M Magruder

Vance Palmer Morrison

Patrick James Helland

Clemens Alden Szyperski

Amanda K Silver

Sean Edwin Trowbridge

James S Miller

David Michael Miller

Paul Allen Vick, Jr

Brian Robert Crawford

Peter A Hallam

Jason L Zander

James H Hogg

Sam Spencer

Joshua Ryan Williams

William G Evans

John Joseph Rivard

Jeffrey S Pinkston

Douglas Jay Rosen

Steven J Steiner

Jason P Allen

Ian H Carmichael

Harish Venkata Kantamneni

Mario Chenier

Jennifer A Hamilton

Lawrence B Sullivan

Gen Lu

Ghanashyam Chandrasekhar Namboodiripad

Habib Heydarian

Tanner Evan Gooding

Cameron Beccario

The present invention extends to methods, systems, and computer program products for controlling runtime access to application programming interfaces Embodiments of the invention allow library developers to more precisely and easily control which of their libraries' APIs can be called dynamically. Thus, their servicing and versioning burden can be more appropriately controlled. Further, application developers can control which such APIs to further exclude from dynamic calling scenarios, to minimize the runtime support overhead (e.g., preventing generation of metadata).

Controlling runtime access to application program interfaces

Instrumentation is extensible because the language construct to be instrumented and the particular instrumentation desired for the language construct can be provided to the compiler for each individual compilation using input provided during compilation of a program using a dynamic analyzer. The dynamic analyzer can identify the programming language construct to be instrumented and the instrumentation to be inserted into the code. The dynamic analyzer can analyze the data that is collected.

Extensible instrumentation

A compiler can instrument a program during the front end of compilation to collect data about runtime behavior when the program is executed. Instrumentation can occur during source language processing rather than later in the compilation chain. The instrumentation can occur in between semantic analysis and code generation. The instrumentation can occur in an instrumenting rewriting phase. The instrumentation can occur in a first lowering phase in which high level constructs in a programming language are rewritten as lower level constructs in intermediate representation (IR). The compiler can inject the instrumentation code at particular points in the source code based on specified language constructs in the source program. The types of instrumentation injected can be extended by providing additional information to the compiler at compilation time, without the need to reprogram the compiler.

Instrumenting program code

Metadata tables can provide the link between the instrumentation information collected and the location in the source code of the programming language construct that was instrumented. The metadata tables enable the relationship between the programming construct in the source code and the dynamic analysis information collected to be exact rather than an estimate. During compilation information is collected that enables a mapping between document table and analysis table to occur.

Mapping dynamic analysis data to source code

Support for dynamic behavior is specified while reducing reliance on JIT compilation and large runtimes; semantic characteristics are selectively attached to types and type members outside source code. A directives document contains human-readable directives in a parsable format for submission to an innovative compiler. The directives specify whether a type T or type member M is required, optional, or prohibited in a runtime environment. Some reference an application, library, assembly, or namespace group, and others reference group components: type, type instantiation, method, method instantiation, field, property, or event. Some directives force a generic instantiation. Some directives indirectly reference a type through a parameter, type parameter, or generic directive. Some directives reference degrees to manage runtime activation of type instances, runtime introspection over types, reflection, and/or runtime or static serialization. Degrees may enable or disable types, instance constructors, property setters, property getters, fields, or all type members. Directives may be composed.

Hierarchical directives-based management of runtime behaviors

The portable tray for a folding chair is a table. The portable tray for a folding chair is configured for use with a drink holder. The portable tray for a folding chair attaches to the drink holder such that a portion of the load path of the portable tray for a folding chair transfers through the drink holder to the supporting surface that supports the structure containing the drink holder. The portable tray for a folding chair comprises a tray, a telescopic stanchion, and a stabilizer. The tray is a horizontal surface that is used to support objects. The telescopic stanchion is a vertical support that raises the tray above the supporting surface. The stabilizer is a device that attaches the tray to the drink holder. The vertical span of the telescopic stanchion is adjustable.

Portable tray for a folding chair

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

Controlling runtime access to application programming interfaces

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 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

Embodiments of tree-based directed graph programming structures for a declarative programming language are provided. In various embodiments, complex graph structured data, referred to as 'DGraphs' herein in one non-limiting implementation, is authored using a compact, human friendly syntax without the use of explicit identifiers. In one non-limiting aspect, the syntax includes support for conformance relationships, also referred to as factored relationships. In another non-limiting aspect, the semistructured graph data is a tree-based representation and the syntax includes lexical resolution of references or lexical scoping, and/or non local initialization.

Tree-based directed graph programming structures for a declarative programming language

Growing community of inventors

Seattle, WA, United States of America

John Lawrence Hamby