Microsoft Technology Licensing, LLC

Christopher L Anderson

Anthony J Moore

Anders Hejlsberg

Donald F Box

Clemens Alden Szyperski

David S Ebbo

Krzysztof J Cwalina

Shawn Patrick Burke

Erik B Christensen

Gopala Krishna R Kakivaya

Christopher Wellington Brumme

Michael M Magruder

Raja Krishnaswamy

David Bau

Brian LaMacchia

Lance Olson

Henry L Sanders

Julie D Bennett

James S Miller

Sean Edwin Trowbridge

Travis Muhlestein

Jonathan C Hawkins

Randy S Kimmerly

Seth Mitchell Demsey

Brian M Grunkemeyer

Stefan Harrington Pharies

Yung-Shin Lin

Loren Kohnfelder

Erik B Olson

Yann Christensen

Fabio A Yeon

Jeffrey M Cooperstein

James H Hogg

Martin James Gudgin

Craig T Sinclair

Corina Eva Feuerstein

Adam Wade Smith

David S Mortenson

Caleb L Doise

Alan Geoffrey Boshier

Shajan Dasan

Manish S Prabhu

Radu Rares Palanca

Joseph L Roxe

John I McConnell

Tarun Anand

Suzanne Maurine Cook

Ramasamy Krishnaswamy

Hany E Ramadan

Jesus Ruiz-Scougall

Joe Dennis Long

Jayanth V Rajan

Daniel Takacs

Gregory Darrell Fee

Quetzalcoatl Bradley

Joshua Ryan Williams

Jeffrey S Pinkston

David Owen Driver

Stephen James Millet

Giovanni Moises Della-Libera

Michael John Hillberg

Brian Keith Pepin

Nicholas M Kramer

Chad W Royal

Mark A Boulter

Sreeram Nivarthi

David K Peck

Stephen Michael Danton

Robert Andrew Little

Alexander Douglas James

Yan Valerie Leshinsky

Oliver H Foehr

Nikhil Kothari

Bradford H Lovering

Jerry Jay Dunietz

Jeffrey Lawrence Bogdan

Scott David Guthrie

Michael Pizzo

Mark A Alcazar

Srikanth Mandadi

Jeffrey C Schlimmer

John Raymond Justice

David Ornstein

Joseph Ternasky

Luca Bolognese

John David Doty

Keith W Ballinger

Alex Mogilevsky

Mark T Anders

Namita Gupta

Jun Fang

Charles P Jazdzewski

Susan M Warren

Manu Vasandani

Robert Michael Howard

Eric Kenneth Zinda

Bradley Moore Abrams

Mark W Fussell

Omri Gazitt

Margaret L Goodwin

A nominal type framework can be configured to efficiently correlate different nominal types together based on a minimum set of common type shapes or structures. In one implementation, a developer identifies a number of different nominal types of interest (source types), and identifies the minimum set of common type shapes to be accessed by an application program. The minimum set of common type shapes can then be used to create an intermediate type (target type) to which each of the other different source types can be mapped. For example, one or more proxies can be created that map shapes of the one or more source types to corresponding shapes of the created target type. The application program created by the developer, in turn, can access, operate on, or otherwise use the mapped data of each different source type through a single target type.

Efficiently correlating nominally incompatible types

Declaratively implementing a command. A method includes declaring an input gesture in a declarative programming language. Declaring an input gesture includes declaring one or more user performed actions. A command name is declared in a declarative programming language. A workflow is declared in a declarative programming language. Declaring a workflow includes declaring schedulable activities that are to be performed without specific specifications of the low level algorithms that are used to accomplish the activities. In an alternative example, workflows may be declared by declaring a wrapper to wrap imperative programming commands. The declared input gestures are bound with the declared workflow through the declared command name.

Declarative commands using workflows

A common data type structure can be used to correlate access requests between applications that implement data in accordance with different types or type structures. In one implementation, a common data structure includes schemes for operations, sequences, records, and atoms (i.e., undefined). The system can then map any type structure to the schemes of the common data structure. In operation, a request for data by an application can involve identifying one or more proxies used by an application to map the data to the common data structure. The proxies map the data to the common data structure based on the shape of the data (to the extent it can be identified). The proxies then can return one or more data structures that comprise the identified mapping information. The application can then perform operations directly on the received data structures.

Accessing different application data via a common data structure

Facilitating translation of data between object oriented programs and database storage tables. A method includes receiving user input from a user. The user input includes a plurality of parts. Each part includes a specification of a source (such as a type source), optionally a filter, and a projection. Each projection assigns values to table columns. Based on the plurality of parts received, the method includes generating one or more views. The one or more views describe relationships between model extents and database tables.

Pragmatic mapping specification, compilation and validation

Modular content framework and document format methods and systems are described. The described framework and format define a set of building blocks for composing, packaging, distributing, and rendering document-centered content. These building blocks define a platform-independent framework for document formats that enable software and hardware systems to generate, exchange, and display documents reliably and consistently. The framework and format have been designed in a flexible and extensible fashion. In addition to this general framework and format, a particular format, known as the reach package format, is defined using the general framework. The reach package format is a format for storing paginated documents. The contents of a reach package can be displayed or printed with full fidelity among devices and applications in a wide range of environments and across a wide range of scenarios.

Method and apparatus for document processing

User experience in a designer tool manages cogeneration of a database application and a database accessible through the application. A user places a visual representation of an application element designed to control a relational or hierarchical dataset. Code is automatically called to add the application element to the application, and automatically invoked to create database schema elements designed to implement the dataset in the database under application element control. Users verify that an application element has been automatically added, and confirm that database schema elements implementing the dataset(s) under control of the application element have been automatically created. A tutorial illustrates a workflow utilizing a designer tool to cogenerate a database application and a database without a data design step. A wizard utilizes the designer tool to cogenerate a database application and a database that collectively implement a calendar, a diagram, a tree, a wiki, and/or a list.

Cogeneration of database applications and their databases

Declartive commands using workflows

Component domains used to define a binding between various components associated with the component domain. The component domain tracks the various services to be imported by each component, and tracks the various services exported by each component. At runtime, rather than at compile time, the various interrelations between the components are bound using the service import and export data. Accordingly, depending on the components available and their characteristics, the bindings may differ. This permits applications to be much more flexible.

Implicit composition of component bindings

Component domains used to define a binding between various components associated with the component domain. The component domain tracks the various services to be imported by each component, and tracks the various services exported by each component. At runtime, rather than at compile time, the various interrelations between the components are bound using the service import and export data. Accordingly, depending on the components available and their characteristics, the bindings may differ. This permits applications to be much more flexible. In one implementation, the binding is performed iteratively. For example, if after one iteration of binding service imports to service exports, some components may expand the services that they export, or the services that they desire to import.

Iterative component binding

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

Software programming models are provided for supporting host-environment agnostic content that can be hosted in different hosting environments (e.g., browser or window) without needing to rewrite the content. The models comprise a host-environment abstraction wrapper that provides a transparent layer of abstraction between content and host-environment specific instructions. The host-environment abstraction wrapper supports the use of host-environment independent interaction instructions or declarative statements in content by invoking host-environment specific implementation details on behalf of the content. The host-environment independent interaction instructions represent particular interactions between some content and a hosting environment, but do not provide host-environment implementation instructions that are specific to any particular hosting environment.

Object models enabling hosting content in a plurality of environments

An application program interface (API) provides a set of functions for application developers who build Web applications on Microsoft Corporation's .NET&#x2122; platform.

Computing system and method for allowing plurality of applications written in different programming languages to communicate and request resources or services via a common language runtime layer

An application program interface (API) provides a set of functions, including a set of base classes and types that are used in substantially all applications accessing the API, for application developers who build Web applications on Microsoft Corporation's .NET&#x2122; platform.

Application program interface for network software platform

Growing community of inventors

Redmond, WA, United States of America

Christopher L Anderson