Microsoft Technology Licensing, LLC

Inprise Corporation

Microsoft Corporation

Anders Hejlsberg

Matthew J Warren

Henricus Johannes Maria Meijer

Dinesh Chandrakant Kulkarni

Luca Bolognese

Peter A Hallam

Mads Torgersen

Gary Shon Katzenberger

Erik Meijer

Erik B Christensen

Stefan Harrington Pharies

Andrew Eyring Kimball

Scott Michael Wiltamuth

Steven E Lucco

Christopher Wellington Brumme

Giovanni Moises Della-Libera

Christopher L Anderson

Shawn Patrick Burke

Lucas James Hoban

Gopala Krishna R Kakivaya

Michael M Magruder

Raja Krishnaswamy

David Bau

Brian LaMacchia

Lance Olson

Henry L Sanders

David S Ebbo

Julie D Bennett

Travis Muhlestein

James S Miller

Sean Edwin Trowbridge

Jonathan C Hawkins

Krzysztof J Cwalina

Christopher Lovett

Seth Mitchell Demsey

Brian M Grunkemeyer

Loren Kohnfelder

Yung-Shin Lin

Anthony J Moore

Charles P Jazdzewski

Erik B Olson

Yann Christensen

Jeffrey M Cooperstein

David Lawrence Remy

Fabio A Yeon

James H Hogg

Chia-Hsun Chen

Corina Eva Feuerstein

Adam Wade Smith

Craig T Sinclair

David S Mortenson

Caleb L Doise

Alan Geoffrey Boshier

Peter H Golde

Shajan Dasan

Manish S Prabhu

John Joseph Duffy

Yan Valerie Leshinsky

Donald F Box

Gregory Darrell Fee

Keith W Ballinger

Ralf Lammel

Peter F Sollich

Chad W Royal

Stephen Harris Toub

John Peter Shewchuk

Bradford H Lovering

Amanda K Silver

Randy S Kimmerly

Paul Allen Vick, Jr

Brian Keith Pepin

Jun Fang

Jomo Fisher

John Wesley Dyer

Nicholas M Kramer

Asad Jawahar

Patrick Dengler

Bradley Moore Abrams

Brian C Beckman

Stephen James Millet

Nikhil Kothari

Martin Taillefer

Vance Palmer Morrison

Michael Joseph Toutonghi

Niklas Gustafsson

John E Elsbree

Clemens Alden Szyperski

Scott David Guthrie

Avner Y Aharoni

David N Schach

Danny Van Velzen

Mark T Anders

Samuel Ng

Susan M Warren

Gavin Mark Bierman

Robert Michael Howard

Manu Vasandani

Dax H Hawkins

Tracy Sharpe

Terry A Adams

An operation (such as a relational query) may be processed on a processing engine (such as a relational database server) on behalf of a client. A conventional processing involves the delivery of the operation to the processing engine, which executes the entire operation to completion and returns a result data set. It may be more efficient to allocate part of the operation to be performed on the client, but a developer may be unable or unavailable to rewrite the operation in a distributed manner. Instead, the operation may be automatically partitioned into a pre-engine client portion, a processing engine portion, and a client portion, and the instructions of each portion may be automatically allocated respectively to the client, the server, and the client. The partitioning may be adjusted to conserve computing resources, such as bandwidth and storage, and the instructions may be reordered to improve the processing of the operation.

Automated client/server operation partitioning

Static type checking can be performed on types and values defined in modules in a system that dynamically composes programs from modules. The types and values do not share a global namespace. Each module defines its own module universe, disjoint from other modules. A language mechanism can establish a local name binding to one module within the content of another module. When type checking at compile time an environment can be established that corresponds to a runtime instance of the program. The static type system can be arranged to align with the runtime values, such that the names used to refer to objects at runtime are the same as the names used to refer to the types of those objects in the static type system. Aliases of a particular type are resolved to a known compile time description of the type.

Static type checking across module universes

Type inference is used to provide the benefits of static type checking without explicitly declaring type in the source code. Type inference that proceeds in a bottom up direction is augmented by contextual typing that proceeds in a top down direction. Contextual typing types enclosed expressions by associating the type of a directly enclosing expression with the enclosed expression. Object literals, function literals and array literals enclosed in assignment and call expressions, can be contextually typed.

Contextual typing

Statically extensible types allow a static type system to model the behavior of dynamic object model extension in dynamic runtime systems. Static types that model dynamically extended types can be extended using additional declarations in the same compilation. Declarations for a particular type can come from multiple independent sources which can have been defined at multiple points in time. Extension declarations can use the same syntax as the initial type declaration. Hence presence of one or more declarations for the same type in a compilation can indicate that the type has been extended. These features allow static type checking of dynamic plug-ins to be supported using statically extensible types. Declarations and extension declarations for a type can be merged together to create an extended type that enables different processing paths and dependencies.

Statically extensible types

A static type, called 'dynamic', is introduced into a statically bound programming language. An expression or subexpression that is defined as a static type called 'dynamic' in the source code of a program written in the statically bound programming language, is bound based on its runtime type instead of on its compile time type. Binding can be performed based on a mixture of compile time and runtime types that are based on the specification of types of expressions in source code. This type of binding is called hybrid binding. Operations are bound using the runtime type of constituent expressions (i.e., the runtime type of a receiver, an argument, or an operand) typed as dynamic and the compile time type of static constituents. If any constituent expression of an operation is dynamic, binding occurs at runtime instead of at compile time.

Dynamic binding directed by static types

An imperative framework having a more than one type is defined. At least one of the types is an immutable type, and the immutable type has at least one immutable field.

Immutable types in imperitive language

A dynamic programming environment includes a dynamic runtime infrastructure configured to receive static metadata as source text in a source code written in a dynamic programming language. The dynamic runtime infrastructure determines an object representation based on the static metadata from the source text in the source code.

Static metadata in dynamic programs

The present invention extends to methods, systems, and computer program products for transforming source code to await execution of asynchronous operations. Embodiments of the invention simplify authoring and use of asynchronous methods, by generating statements that use well-defined awaitable objects to await completion of asynchronous operations. For example, a computer system can transform a statement that requests to await the completion of an asynchronous operation into a plurality of statements that use a predefined pattern of members of an awaitable object corresponding the asynchronous operation. The pattern can include one or more members configured to return a completion status of the asynchronous operation, one or more members configured to resume execution of the asynchronous method at a resumption point when the asynchronous operation completes, and one or more members configured to retrieve completion results. Accordingly, the plurality of statements can use these members to await execution of the asynchronous operation.

Pattern-based compilation of asynchronous consumption

Data source queries may be specified in various languages, such as SQL, XQuery, and object-oriented languages, and each language may have various linguistic features that enable different types of queries. It may be advantageous to formulate mixed language queries having portions specified in a first language and portions specified in a second language, and to provide mixed language query evaluation components that can parse portions of queries of different languages. It may also be advantageous to permit the translation of single language queries into multiple languages to be parsed by such mixed language query evaluation components. Such techniques may permit queries to utilize linguistic features and processing techniques of one language that are less efficient, less direct, or simply unavailable in another language.

Data query translating into mixed language data queries

Queries targeting various data sources are processed in a query processing pipeline that parses the query into a set of operations (e.g., an expression tree or a translated SQL query) using a set of query operators, each handling a particular type of operation. The query operators are often designed in an unspecialized manner, such that each query operator handles one query operation in an atomic, generic manner (e.g., sorting generic data items for an ORDER BY clause.) More efficient queries may be devised by including specialized queries that operate in common but special cases, such as a sorting of a particular data type (e.g., a floating-point number sort) or a sequence of two or more operations that are often performed together (e.g., a WHERE test of an attribute followed by a SELECT of the same attribute.) The use of specialized operators may result in the formulation of more efficient queries.

Query processing with specialized query operators

The present invention extends to methods, systems, and computer program products for representing various programming elements with compiler-generated tasks. Embodiments of the invention enable access to the future state of a method through a handle to a single and composable task object. For example, an asynchronous method is rewritten to generate and return a handle to an instance of a builder object, which represents one or more future states of the asynchronous method. Information about operation of the asynchronous method is then passed through the handle. Accordingly, state of the asynchronous method is trackable prior to and after completing.

Using compiler-generated tasks to represent programming elements

A system and method for parsing XML is provided. The method includes associating an input stream with a pull model parser, accepting requests to selectively parse out XML items from the input stream and retrieving metadata information associated with the parsed out XML items. The method further includes checking the pulled XML item to determine whether it conforms to XML syntax and/or semantic standards and validating the pulled XML item to determine whether it conforms to a selected DTD.

Object-oriented pull model XML parser

An object reference is tagged with an isolation permission modifier. At least two permissions can be included, and in an example three permissions are included. In implementing the permissions, type modifiers for controlling access to type members through references pointing at an object are defined. One of the type modifiers is associated with each occurrence of a type name. Each of the of type modifiers defines a different access permission to restrict operations on the object to which the reference points.

Type system support for memory isolation permissions

A compiler supporting a language in which selected semantic objects are represented as data objects. The data objects may be used in multiple ways to expand the capabilities of the programming language. Data objects may be passed to applications and used to create executable instructions for that application. In this way, instructions written in the native language of the compiler may be used to control applications that accept programs in a language inconsistent with the native language of the compiler. The syntax checking and variable binding capabilities of the compiler may be used for those instructions that will be executed by an application separate from the object code generated by the compiler. The semantic objects represented as data objects may be selected based on express operations included in the source code or may be based on implicit type conversion.

Compiler supporting programs as data objects

Growing community of inventors

Seattle, WA, United States of America

Anders Hejlsberg