Microsoft Technology Licensing, LLC

Rahul Sudhir Kumar

Chad Steven Estes

Gupta Garuda

Jamie Marconi

C Douglas Hodges

Karvell Li

David John Law

Wook Jin Chung

Gilbert Martin McQuillan

Thomas Ernest Osborne

Ionut Ciprian Gradinaru

Miriam Borkenhagen

Thomas J Ball

William John Winter

Todd Haugen

Jason Joseph Weber

Christian Alma Bird

Chetan Bansal

Ranjita Bhagwan

Vladimir A Levin

Timothy R Sullivan

Munir Mahmood

Paul Sean Harrington

Izydor Gryko

Balasubramanyan Ashok

Spencer Wong Low

Christopher Joseph Burrows

Joshua Christopher Shepard

Scott David Smith

Chandra Sekhar Maddila

Kevin Perry

Michael Joseph Papale

Eleonora O Bounimova

Sonu Mehta

Svetlozar Emilov Keremidarski

Paul Leonard Kompfner

Diane Melde

Jemy Huang

Aaron T Burcham

James Kal Yu Lau

Eric Lee Chin-Sang

Jiong Ouyang

Aditya Kumar

Sumit Asthana

Urja Madhukar Shah

Tomoko Kwan

David Immanuel Millet

Philip Edward Hiatt

Gil Mcquillan

Brian Ka-Hing Fung

Described herein is a system and method for detecting correlated changes (e.g., between code files and configuration files). For a plurality of code files and a plurality of configuration files, a correlated change model is trained to identify correlated changes across the code files and the configuration files using a machine learning algorithm that discovers change rules using a support parameter, and, a confidence parameter, and, a refinement algorithm that refines the discovered change rules. The correlated change model comprising the change rules is stored. The correlated change model can be used to identify potential issue(s) regarding a particular file (e.g., changed code or configuration file(s)). Information regarding the identified potential issue(s) can be provided to a user.

Detecting misconfiguration and/or bug(s) in large service(s) using correlated change analysis

One or more techniques and/or systems are disclosed for rendering online ads on a webpage. A first inter-frame communication channel is created, which comprises a first communication channel between a first cross-domain frame and a host page, such as the webpage. The first cross-domain frame comprises content from a domain that is different than that of the host page domain. A second inter-frame communication channel is created comprising a second communication channel between the first cross-domain frame and a second cross-domain frame in the host page.

Securely rendering online ads in a host page

A target web page may embed resources hosted by a source server. However, this embedding may result in compatibility and/or security issues; e.g., the dimensions of the embedded resource may skew the layout of the target web page. Instead, a source web page may be rendered separately from a target web page, and a source region of the source web page (e.g., a region defined by a set of coordinates) may be extracted from the source web page and may be presented in a target region of the target web page. The elements of the source region may be displayed and executed in isolation within the source web page, and may operate within a source domain (e.g., communicating with the source server and accessing cookies stored by the source server), yet may not interact with the elements of the target web page, thereby alleviating many compatibility and security problems.

Presenting source regions of rendered source web pages in target regions of target web pages

One or more techniques and/or systems are disclosed for providing a customized service error message to a user of a service. An error encountered during a user action related to the service may be compared to one or more identified service outages to determine if the error may be attributable to any of the service outages. If the error may be caused by one or more of the identified service outages, the customized service error message can be provided, where the customized service error message comprises information about one or more of the identified service outages that cover the error. The customized service error message may be displayed to the user so that the user knows that the error is server/service side (e.g., as opposed to an issue on the user's local device), a timeframe within which the error is expected to be resolved, etc.

Service outage details in an error message

One or more techniques and/or systems are disclosed for identifying an in-application message to display to a user. A user may perform a user action in an application, which can be identified. The identified user action can be compared to metadata data associated with a plurality of in-application messages for the application, and an in-application message that is eligible for display to the user can be identified based on the user action. A determination can be made whether to display the eligible message to the user in the application, based upon one or more in-application messages that the user may have previously viewed, as may be found or tracked in a user message viewing history.

Determining whether to display message to user in application based on user message viewing history

An analysis engine is described for performing static analysis using CEGAR loop functionality, using a combination of forward and backward validation-phase trace analyses. The analysis engine includes a number of features. For example: (1) the analysis engine can operate on blocks of program statements of different adjustable sizes; (2) the analysis engine can identify a subtrace of the trace and perform analysis on that subtrace (rather than the full trace); (3) the analysis engine can form a pyramid of state conditions and extract predicates based on the pyramid and/or from auxiliary source(s); (4) the analysis engine can generate predicates using an increasingly-aggressive series of available discovery techniques; (5) the analysis engine can selectively concretize procedure calls associated with the trace on an as-needed basis and perform other refinements; and (6) the analysis engine can add additional verification targets in the course of its analysis, etc.

Program analysis through predicate abstraction and refinement

The functionality of a core application is extended using an add-on application (module) by extending native data types on the core application with custom data types and custom actions on the module. The module provides metadata associated with its custom data types and custom actions to the core application, which creates a dynamic type/action table. In some cases, native data types may be extended with custom data types and their associated actions. In other cases, native data types may be extended with custom actions from the module. The custom actions may be enabled for instances of native data types that have been extended. When a custom action is selected, code corresponding with the selected custom action is called from the module and run to perform the selected custom action.

Extending native data types

Devising a centralized usage database for tracking and recording the usage of various services by various users may be difficult for several reasons, including the volume of data generated by each user in interacting with each service. Techniques are disclosed for streamlining usage data transmitted between the services, the users, and the usage database, such as by redistributing a portion of the computational burden to the users, and by characterizing the usage data based on the role of each user in interacting with each service. Additional techniques are disclosed for caching and authenticating the usage data, and for improving the response rate in the interaction of the usage database with users in order to provide a better user experience.

Role-based user tracking in service usage

User profile data that may be spread across different service providers and that may vary across different service providers can be aggregated to provide an aggregate user profile. An aggregate user profile can be generated regardless of, among other things, varying user profile semantics, differing data formats, data item conflicts, evolving server protocols and interfaces, and updates to the number, identity, location, and type of servers upon which the service providers are maintained.

User profile aggregation

An extensible project system for software development is provided by allowing a flavor, with a specific purpose, to be applied to a base project system. More than one flavor may be applied. Where components are distributed objects, such as where COM (component object model) is used, the project system is assembled by aggregation of a base project object, which contains some data for creating a project system with a flavor object, which modifies the project system. The base project object is the participating object in the aggregation and the flavor object is the controlling object. Multiple flavors may be applied to create a project system intended for multiple purposes, corresponding to the applied flavors.

Reusable customized project system

Systems and methods for applying both profile and user customizations to an application user interface are provided. Profile customizations, created for a specialized use or field, are adapted to an application user interface, which has command-menu-toolbar contributions from various add-in modules. The user has access to the customizations through a user interface. Then, as a user is customizing the application, through commands, toolbars, and menus, the user customizations are tagged. A priority and group is assigned to each customization to allow for relative positioning of each customization. The difference between the user's final desired state and a reset state is computed. This difference computation is used to track the changes made to the application and to assist in resets of the customizations.

Method and system for customizations in a dynamic environment

Growing community of inventors

Kirkland, WA, United States of America

Rahul Sudhir Kumar