Microsoft Technology Licensing, LLC

Krzysztof J Cwalina

John Joseph Duffy

Mircea Trofin

Brian M Grunkemeyer

Christopher L Anderson

Anthony J Moore

Erik B Christensen

Anders Hejlsberg

Gopala Krishna R Kakivaya

Christopher Wellington Brumme

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

Seth Mitchell Demsey

Shawn Patrick Burke

Stefan Harrington Pharies

Loren Kohnfelder

Yung-Shin Lin

Erik B Olson

Yann Christensen

Jeffrey M Cooperstein

Fabio A Yeon

James H Hogg

Craig T Sinclair

Corina Eva Feuerstein

Adam Wade Smith

Shajan Dasan

David S Mortenson

Caleb L Doise

Alan Geoffrey Boshier

Manish S Prabhu

Radu Rares Palanca

John I McConnell

Tarun Anand

Suzanne Maurine Cook

Joseph L Roxe

Ramasamy Krishnaswamy

Hany E Ramadan

Jesus Ruiz-Scougall

Joe Dennis Long

Jayanth V Rajan

Daniel Takacs

Patrick Henri Dussud

Gregory Darrell Fee

Jared Porter Parsons

David Owen Driver

Michael C Fanning

Bradley Moore Abrams

David M Kean

Jobst-Immo Landwerth

Michael Sinz

Alexander Daniel Bromfield

Yan Valerie Leshinsky

Stephen James Millet

Giovanni Moises Della-Libera

Nikhil Kothari

Colin Ray Anthony

Clemens Alden Szyperski

Scott David Guthrie

Michael Pizzo

Luca Bolognese

Keith W Ballinger

Brian Keith Pepin

Mark T Anders

Jun Fang

Susan M Warren

Manu Vasandani

Melur K Raghuraman

Robert Michael Howard

Barend Hermanus Venter

Nicholas M Kramer

Chad W Royal

Brent Rector

Mark W Fussell

Eric L Brechner

Mark A Boulter

Sreeram Nivarthi

Omri Gazitt

Nithyalakshmi Sampathkumar

Neetu Rajpal

Robert Allan Brigham, Ii

Dean Alan Slawson

Daniel Dedu-Constantin

Blaine J Dockter

G Shon Katzenberger

Oleg G Lvovitch

William A Adams

Matthew G Ellis

Mark P Ashton

Blake W Stone

Subhag P Oak

A computing device implemented method for building a mutable type is disclosed. A data structure is generated in a contiguous section of memory. The data structure includes an element portion and an over-allocation portion. The element portion stores elements accessible with an index. A gap object is inserted into the over-allocation portion. The gap object is garbage collected.

Mutable type builder

Various technologies and techniques are disclosed for switching threads within routines. A controller routine receives a request from an originating routine to execute a coroutine, and executes the coroutine on an initial thread. The controller routine receives a response back from the coroutine when the coroutine exits based upon a return statement. Upon return, the coroutine indicates a subsequent thread that the coroutine should be executed on when the coroutine is executed a subsequent time. The controller routine executes the coroutine the subsequent time on the subsequent thread. The coroutine picks up execution at a line of code following the return statement. Multiple return statements can be included in the coroutine, and the threads can be switched multiple times using this same approach. Graphical user interface logic and worker thread logic can be co-mingled into a single routine.

Techniques for switching threads within routes

Platform-agnostic source code can be augmented with one or more portions of source code annotated for different platforms and/or versions. The source code including both the platform-agnostic and platform-specific and/or version-specific portions can be compiled once to create a single executable that can be distributed to and can run on multiple device platforms and/or multiple versions of one or more platforms. Platform-specific or version-specific executables (e.g., assemblies, binaries, etc.) can be embedded into a binary or executable as resources (e.g., data). When the compiled code is executed on a device, the runtime can extract the platform-specific portion corresponding to the device on which the executable is being run, can bind the extracted portion to the executable and can load and execute the executable. Hence the same binary can produce different results or functionalities depending on the capabilities of the platform on which the binary runs.

Adaptive portable libraries

API (application program interface) features defined by a set of APIs provide a different cross-sectional view of an application or framework than the view provided by sectioning along class or library boundaries, or binding units, for example. An API feature includes a proper subset of a library of a framework used by an application, and/or APIs which collectively reside in different libraries. A functionality feature API set provides an exposed surface area of a functionality feature of an application. Upon receiving a compilation request and determining that an API feature is to be excluded, an attempt is made to produce a compiled version of the application without the feature's APIs. In some cases, the functionality feature is independent of a baseline functionality of the application. Developers can obtain smaller but fully functional binaries. Framework architects can identify dependencies between API implementations when creating or modifying a software framework's architecture.

Cross-library framework architecture feature sets

Techniques for switching threads within routines

The subject disclosure relates to enabling the evolution of a framework by providing public surface area factorings for both old and new public surface areas. The factoring can mitigate changes in the implementation of existing distributions of framework. The factoring can also mitigate breaking existing binaries. Further, the factoring can be provided while mitigating a degradation in the security guarantees of the linking model. The factorings can be applied for runtime and/or for a development toolkit. Thus, multiple, almost simultaneous, interoperable views of a framework implementation can be enabled at runtime and/or at design or build time. The views can represent different versions of the framework.

Mechanism for compatibility and preserving framework refactoring

A language extension that advances safety in system programming in that an entire type may be declared to be immutable in the case in which all instances of that type are immutable. The immutable type declaration automatically causes any instances of that type to be treated as immutable, and automatically causes all directly or indirectly reachable members (e.g., fields, methods, properties) of the instance to also be treated as immutable. Furthermore, any construction time reference that allows for field assignment of the instance is not permitted to survive beyond the point at which the instance becomes accessible to its creator. Accordingly, this instance, and any other instance of that same type, will be immutable from the very time of construction. The ability to classify all such instances as immutable is beneficial as the immutable characteristic permits actions that normally would not be allowed due to resource access safety.

Resource access safety through immutable object types

The type definition of particular types such that different portions of the corresponding object graph may have different permissions assigned to those portions during instantiation. This allows structured permissions to be applied to instantiations of the object graphs of those defined types, allowing fine grained control over what access permissions are enforced against which portions of the object graph. In some embodiments, different instantiations of the object graph may apply permissions differently.

Object graph partial immutability and isolation enforcement

System and method to ensure resource access safety with immutable object types

A framework for open, dynamic, and reflective applications contains high level metadata that define blocks of composable elements using a service definition, which defines specific keys for using the block of code. The service definition may be exported from the code using reflection without having to load the code into memory, and decisions on which block of code and how to load the code may be made at runtime. The composable elements may be grouped into composable parts. Composable part definitions may be used to instantiate or produce composable parts. At runtime, dynamic applications may search from many composable elements, and instantiate and execute the composable element as part of the application.

Framework for open dynamic reflective applications

Creating and executing platform portable code. A method includes declaring an object as being a dynamic object in a program. The program is a program compiled using a static language, except that the dynamic object is excluded from static analysis on the object when the program is compiled. The dynamic object includes a dependent call to a platform specific API. The platform specific API is available on one or more platforms to which a compiled version of the program will be deployed, but not available on one or more other platforms to which the compiled version of the program will be deployed.

Dynamic adaptive programming

An assembly aggregate comprising a virtual, logical view of an arbitrarily defined collection of intermediate code and metadata can be authored, factored, accessed, modified, and distributed. Multiple physical containers of assembly information can be aggregated to create a single logical assembly called an assembly aggregate. An assembly can thus be redefined as a logical view against (or projection over) the assembly aggregate. Such an assembly can be targeted to the requester: that is, an assembly can be redefined according to tool and/or execution context rather than conforming to explicit or implicit requirements enforced by the runtime.

Logical extensions to intermediate code

Growing community of inventors

Redmond, WA, United States of America

Krzysztof J Cwalina