Microsoft Technology Licensing, LLC

Highspot, Inc.

Erik B Christensen

Kenneth David Wolf

Stefan Harrington Pharies

David Wortendyke

Michael James Coulson

Stephen James Millet

Christopher G Kaler

David Edwin Levin

Bradford H Lovering

Yann Christensen

Michael Steven Vernal

Giovanni Moises Della-Libera

Lance Olson

Keith W Ballinger

Elliot Lee Waingold

Luis Felipe Cabrera

Anders Hejlsberg

Steven E Lucco

John Peter Shewchuk

David S Ebbo

Stephen Jared Maine

Oliver J Sharp

Robert S Wahbe

Anthony J Moore

Erik B Olson

Fabio A Yeon

Donald F Box

Henrik Frystyk Nielsen

Scott David Guthrie

Igor Sedukhin

Alfred Lee

Amol Kulkarni

Haoran Andy Wu

Nicholas Alexander Allen

Gopala Krishna R Kakivaya

Christopher Wellington Brumme

Michael M Magruder

Raja Krishnaswamy

David Bau

Brian LaMacchia

Henry L Sanders

Julie D Bennett

Sean Edwin Trowbridge

Andrew Layman

James S Miller

Travis Muhlestein

Jonathan C Hawkins

Krzysztof J Cwalina

Seth Mitchell Demsey

Brian M Grunkemeyer

Shawn Patrick Burke

Christopher L Anderson

Loren Kohnfelder

Yung-Shin Lin

Jeffrey M Cooperstein

Stephen T Swartz

James H Hogg

Yan Valerie Leshinsky

Nikhil Kothari

Tirunelveli R Vishwanath

Gregory Darrell Fee

Geoffrey M Kizer

Jeffrey C Schlimmer

Dmitry Robsman

Mark T Anders

Shanku Shivabrata Niyogi

Michael Marucheck

Susan M Warren

Shy Cohen

Clemens Alden Szyperski

Vladimir Pogrebinsky

Christopher Lovett

Girish Mittur Venkataramanappa

Craig Andrew Critchley

Uday Sooryakant Hegde

Tomasz Janczuk

Martin James Gudgin

Christian F Huitema

Paul A Viola

James Ernest Johnson

Shaun Douglas Pierce

Satish Ramchandra Thatte

David E Langworthy

Richard Douglas Hill

James M Lyon

Umesh Madan

John Raymond Justice

Stefan R Batres

Luca Bolognese

John David Doty

Brian Keith Pepin

Jun Fang

Vijay Gajjala

Sermet Iskin

Krishnan Srinivasan

Ferhan Elvanoglu

Geary L Eppley

Matthew Thomas Tavis

David Erb

Gopal Krishna R Kakivaya

Systems and methods for identifying semantically and/or visually related information among a set of content items, such content items that include similar concepts or that have similar visual aspects, are disclosed. The disclosed techniques provide tools for identifying related information among various content items, such as text pages and documents, presentation slides and slide decks, etc. The disclosed techniques provide improved methods for searching among content items, organizing content items into categories, and pruning redundant content. Furthermore, the disclosed techniques provide improvements to computation of various metrics, including usage, performance, and impact metrics.

Systems and methods for identifying semantically and visually related content

Systems and methods for selecting items of interest for an organization from a set of feeds, based on the interests that users have demonstrated through their interactions with existing content, are described herein. In some embodiments, the system is part of a content management service that allows users to add and organize files, media, links, and other information. The content can be uploaded from a computer, imported from cloud file systems, added via links, or pulled from various kinds of feeds.

News feed

A dynamic, lazy type system is provided for a dynamic, lazy programming language. Consequently, programs can benefit from runtime flexibility and lightweight notation in combination with benefits afforded by a substantial type system.

Dynamic lazy type system

Encoding and/or decoding of messages. On the encoding end, a composite encoder encodes message from an internal format that is used by internal system components into an external format. However, the composite encoder may encode the outgoing messages into different external formats on a per-message basis. For incoming message, a composite decoder decodes incoming messages from any one of a plurality of external formats into the internal format also on a per-message basis. A per-message report mechanism permits internal system components and the encoding/decoding components to communicate information regarding the encoding or decoding on a per message basis. XML messages can be converted automatically into Binary messages.

Conversion of hierarchical infoset type data to binary data

Embodiments described herein provide for allowing processing code of a message to attach state thereto. More specifically, as a SOAP message is processed, various states known as properties (e.g., message security, message identifier, etc.) can be attached to the message for various purposes. In other words, embodiments provide for a properties object that represents a set of processing-level annotations to a message. These properties (representing the processing state of the headers or other portions of the message) can then be used by other component or modules for further processing purposes. Typically, these properties can then be removed (or sustained if desired) prior to transporting the SOAP message on the wire.

Annotating portions of a message with state properties

Web sites are modeled using mappings from paths to expressions. A mapping data structure of expressions represents a web site's hierarchical structure, and an enumerator, an array of characters, or an array of bytes represents the web site's content. Expressions are written in a declarative programming language, and are lazily evaluated to provide results used in HTTP responses. A mapping may be recursive. An expression may contain a function call which returns contents of a file named in the HTTP request path, or the expression may evaluate to a text string, for example. Expressions may call functions which produce side-effects. An expression may recursively map a directory name to a mapping of a file name. Scalability is promoted by concurrently evaluating expression(s) on different machines in a stateless middle tier, and by streaming results. An arbitrarily large web site may be implemented in this manner.

Web site implementation by mapping expression evaluation

A mechanism for sending structured data using a corresponding byte stream. Upon accessing structured data such as a Simple Object Access Protocol (SOAP) envelope, a byte stream is generated. The byte stream includes bytes that represent the structured data, as well as a collection of bytes that represents properties about the byte stream such as, for example, a mode of communication. The byte stream may then be passed to a communication module (e.g., a TCP or Named Pipes module) capable of receiving and transmitting the byte stream.

Mechanism for binding a structured data protocol to a protocol offering up byte streams

Reader and writer XML processing APIs may process XML documents without blocking a thread by initiating any potential I/O necessary prior to reading from or writing to the XML processing API and by providing a callback which may be notified when the I/O, if any, is complete. The XML processing API may be able to simultaneously process multiple XML documents in various formats and sizes.

Efficient, non-blocking mechanism for incrementally processing arbitrary sized XML documents

The present invention extends to methods, systems, and computer program products for processing model based commands for distributed applications. Embodiments facilitate execution of model-based commands, including software lifecycle commands, using model-based workflow instances. Data related to command execution is stored in a shared repository such that command processors can understand their status in relationship to workflow instances. Further, since the repository is shared, command execution can be distributed and balanced across a plurality of different executive services. Embodiments also include model-based error handling and error recovery mechanisms.

Processing model-based commands for distributed applications

The present invention extends to using Simple Object Access Protocol ('SOAP') to exchange typed objects, such as, for example, parameters for invoking methods. A computer system accesses typed object parameters corresponding to a typed object. The typed object is annotated with one or more message contract attributes of a message contract model defining a mapping between typed object parameters and corresponding SOAP elements. The computer system utilizes the message contract attributes to map the typed object parameters into a SOAP element and inserts the SOAP element into a SOAP envelope. A receiving computer system accessing the SOAP element and utilizes the message contract attributes to map the SOAP element back into the typed object parameters.

Flexibly transferring typed application data

The present invention extends to methods, systems, and computer program products for managing software lifecycle. Based on declarative models and knowledge of their interpretation, embodiments of the present invention facilitate lifecycle management for model-based software applications. Lifecycle models, such as, for example, lifecycle state machine models are stored in a shared repository such that executive services can determine how software application lifecycles are to be managed and transitioned. Software lifecycle activities can verify that a transition is possible and identify any errors preventing a lifecycle transition. Model-based error handling and error recovery mechanisms can be used to correct any identified errors.

Managing software lifecycle

Growing community of inventors

Redmond, WA, United States of America

Erik B Christensen