Microsoft Technology Licensing, LLC

Anthony J Moore

Christopher L Anderson

Erik B Christensen

David S Ebbo

James S Miller

Brian M Grunkemeyer

Stefan Harrington Pharies

Erik B Olson

Yann Christensen

Fabio A Yeon

Adam Wade Smith

Suzanne Maurine Cook

Jayanth V Rajan

Scott David Guthrie

Krzysztof J Cwalina

Susan M Warren

Anders Hejlsberg

Gopala Krishna R Kakivaya

Christopher Wellington Brumme

Michael M Magruder

Raja Krishnaswamy

David Bau

Brian LaMacchia

Clemens Alden Szyperski

Lance Olson

Henry L Sanders

Julie D Bennett

Sean Edwin Trowbridge

Travis Muhlestein

Jonathan C Hawkins

Seth Mitchell Demsey

Shawn Patrick Burke

Loren Kohnfelder

Yung-Shin Lin

Jeffrey M Cooperstein

James H Hogg

Craig T Sinclair

Corina Eva Feuerstein

Shajan Dasan

David S Mortenson

Caleb L Doise

Alan Geoffrey Boshier

Radu Rares Palanca

Manish S Prabhu

John I McConnell

Tarun Anand

Joseph L Roxe

Hany E Ramadan

Jesus Ruiz-Scougall

Joe Dennis Long

Ramasamy Krishnaswamy

Daniel Takacs

Stephen James Millet

Nikhil Kothari

Gregory Darrell Fee

Keith W Ballinger

Mark T Anders

Robert Michael Howard

Manu Vasandani

David Owen Driver

Mark A Boulter

Donald F Box

Randy S Kimmerly

Geoffrey M Kizer

Steven Alfred Isaac

Joshua Ryan Williams

Melitta Andersen

Ariel Weinstein

Yan Valerie Leshinsky

Giovanni Moises Della-Libera

Bradford H Lovering

Michael Pizzo

Luca Bolognese

Brian Keith Pepin

Alessandro Catorcini

Jun Fang

Nicholas M Kramer

Bradley Moore Abrams

Chad W Royal

Mark W Fussell

Sreeram Nivarthi

Omri Gazitt

Nithyalakshmi Sampathkumar

Robert Allan Brigham, Ii

Neetu Rajpal

Daniel Dedu-Constantin

Blaine J Dockter

Ryan A Byington

Curt Oliver Hagenlocher

John F Lam

William A Adams

Mark P Ashton

Subhag P Oak

George D Fee

Josh Free

Various technologies and techniques are disclosed for providing a common generic interface for numeric types in statically typed languages. The common generic interface defines basic arithmetic operations, thereby allowing basic arithmetic operations to be performed on the numeric types. The common generic interface provides support for overflow detection when a result of an operation being performed on a particular numeric type will result in an overflow situation when the operation does not fit within a range supported by the particular numeric types. The common generic interface provides support for one or more mathematical properties to be retrieved for a particular one of the numeric types being used in a particular circumstance.

Generic interface for numeric types

Using language add-ins with one or more static extensibility points of an application host. The method includes searching for user code in a user code store. Some user code is found in the user code store. A determination is made as to the language of the user code from among a plurality of predefined languages. The user code is provided to a language provider for the determined language. A function invocation is received from an application host. The function invocation is matched to at least a portion of the user code. The at least a portion of user code corresponding to the function invocation is executed via the language provider.

Dynamic languages for static hosts

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

An observation system includes mechanisms for efficiently tracking the state of source components, which include functions, arguments, or values, etc. In one implementation, an observing component requests that a source component processes a request. The observation system then identifies all possible components in a dependency chain for the request, and all such components that are configured for change notifications. A dependency registry stores a representation of each identified component that is configured for change notifications. Any time any component configured for change notifications changes, including indirectly related components, the observing component can be immediately notified of the change, without having to reprocess the entire set of component dependencies.

Observing and reporting changes in complex software dependencies

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

A method and system for implementing a safe buffer is described herein. The method includes implementing a buffer class that ensures that accesses to memory are performed in a safe manner. The buffer class may be a handle to protected resources in memory. The buffer class may exploit methods to read and write to memory that ensures that read and writes are performed to valid memory locations within buffer bounds.

Safe buffer

Various technologies and techniques are disclosed for providing a numeric tower that represents a structure supporting statically defined numeric data types. The numeric data types each are operable to implement a different but accurate representation of a particular value. Numeric operations are supported for the numeric tower that can be performed with any of the statically defined numeric data types. The numeric tower is extensible, and allows for additional statically defined numeric data types to be added, as well as operations. The numeric tower is also operable to detect overflow situations. For example, suppose a result of an operation will result in an overflow situation because the operation does not fit within a range supported by the particular numeric type. The system converts the numeric type to a different one of the numeric data types when the result does not fit within a range supported by the first one.

Tower of numeric types

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

Application program interface for network software 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.

Web control validation may be defined using one or more declarations that are included in an ASP+ file by the web page author. The declarations specify server-side objects that validate the input data received in the web page and provide error handling in the event of a validation failure error. Validation declaration parameters specify the validation criteria against which the input data is validated. Example validation operations involve regular expressions, required fields, data comparison, range comparison and custom validation. Validation parameters can also specify either server-side validation or client-side validation, depending on the client browser's capabilities. In a server-side scenario, a server-side validation object processes the input data received in an HTTP request from the client. In a client-side scenario, a server-side validation object renders the appropriate client-side code to validate the input data without a round trip between the client and the server.

Web controls validation

A first exemplary method implementation for designing an application programming interface (API) includes: preparing multiple code samples for a core scenario, each respective code sample of the multiple code samples corresponding to a respective programming language of multiple programming languages; and deriving the API from the core scenario responsive to the multiple code samples. A second exemplary method for designing an API includes: selecting a core scenario for a feature area; writing at least one code sample for the core scenario; and deriving an API for the core scenario responsive to the at least one code sample. A third exemplary method for designing an API includes: deriving an API for a scenario responsive to at least one code sample written with regard to the scenario; performing one or more usability studies on the API utilizing multiple developers; and revising the API based on the one or more usability studies.

Design of application programming interfaces (APIs)

An application program interface includes a first class to provide information regarding a current HTTP request. The application program interface also includes a second class to manage HTTP output to a client and an object to provide access to server-side utilities and processes. Particular application program interfaces include additional classes to manipulate cookies, handle file transfers, provide exception information, or control operation of an output cache.

Application program interface that enables communication for a network software platform

Growing community of inventors

Seattle, WA, United States of America

Anthony J Moore