Microsoft Technology Licensing, LLC

David Michael Sauntry

Peter Gregg Miller

Marc Shepard

Kevin T Damour

Yadhu Nandh Gopalan

Larry Alan Morris

John Eldridge

Michael J Thomson

Mark Gilbert

Michael E Markley

James A Stulz

Susan A Dey

Bhawandeep Singh Panesar

Jonathan M Tanner

Eric J Horvitz

Mark H Lucovsky

Shaun Douglas Pierce

George M Moore

Murli D Satagopan

Raman Chandrasekar

William Alexander Stevenson

Jeroen Vanturennout

Lijiang Fang

Chetan S Shankar

Dmitri A Klementiev

Pradeep Ayyappan Nair

Mark A Groves

Paul Andrew Steckler

David S Bakin

Tara Sanathanan Prakriya

Upender Sandadi

Daniel Massey

Winnie C Wu

Michael Richard Yagley

Xiongjian Fu

Sandeep Kalarickal

Thomas Charles Knudson

Andrew L Nicholson

Rhae-Christie Shaw

Peter Fintan Leonard

John M Gehlsen

Ian M Bavey

Qin Zhou

Leon Chih Wen Wong

Somak Chattopadhyay

Lawrence Brozak Sullivan, Jr

Greg Hogdal

James Scott Boyle

Ana Sultana Bacioiu

Sindhura Tokala

Damien Gallot

Maisem Ali

Lilei Cui

Tom Keane

Siddhartha Pasumarthy

Shont Miller

Lu Jin

Maria Black

Elaine Lu

Christopher Geisbush

Kevin Thomas Damour

Lawrence Brozak Sullivan

Methods, systems, apparatuses, and computer-readable storage mediums are described for authorizing publishing of a message and/or a subscription from an Internet of Things (IoT) device. In an example system, a message broker receives a list of attributes from a claims provider. The message broker determines whether publishing of the message is authorized based at least on the list of attributes, and publishes the message if it is determined that the publishing is authorized. The message broker may also receive a subscription specifying a topic filter. The message broker determines whether the subscription is authorized for the IoT device based at least on the list of attributes, and transmits a subscription message to the IoT device if it is determined that the subscription is authorized.

Efficient attribute-based access control authorization for a message broker

Methods, systems, apparatuses, and computer-readable storage mediums are described for bridging brokers of messages from Internet of Things (IoT) devices. In an example system, a first message broker receives a message and an associated topic from an IoT device. A bridging coordinator accesses a topic-to-broker map that indicates, for a second broker, a list of topic filters for which the second message broker has at least one subscriber. The bridging coordinator determines whether the list of topics includes the associated topic. In response to a determination that the list of topic filters in the topic-to-broker map includes the associated topic, the bridging coordinator forward the message to the second message broker. In response to a determination that the list of topic filters does not include the associated topic, the bridging coordinator prevents forwarding of the message to the second message broker.

Efficient forwarding of messages through brokers by topic

Systems and methods for controlling an edge computing device. The method includes, receiving a user input requesting access to a resource of the edge computing device, determining whether the user has privileges to access the resource by: formulating a claims request which requests claims based on the determined identity of the user, sending the claims request to a local claims provider agent executed by a processor of the edge computing device, determining, based on claim request handling factors, whether the local claims provider agent can generate a token including the requested claims, and if so, generating the token with the requested claims; if not, a request may be sent to a cloud service-side claims provider to receive the token. The method includes authorizing access to the resource based on a predetermined policy that specifies the presence of a predefined resource parameter in the requested claims is sufficient.

Controlling access to resources of edge devices

Techniques allow DevOps personnel to perform incident management for cloud computing environments in a manner that maintains control over restricted data and the data plane. The DevOps personnel do not have access to restricted data or the ability to modify the cloud computing environment to gain access to restricted data. The incident management techniques include executing automatic operations to resolve an incident and allowing DevOps personnel to execute remote operations without providing the DevOps personnel access. A further incident management technique provides DevOps personnel with just-in-time (JIT) access that is limited to a certain level or type of access and limited in time. Still another technique for incident management is using an escort model, in which an escort session between operating personnel and DevOps personnel is established and connected to the cloud computing environment to allow the DevOps personnel access to the production environment while escorted by the operating personnel.

Incident management to maintain control of restricted data in cloud computing environments

A system and method for facilitating analysis of a software project. Intrinsic measures, activity-based measures, or dynamic measures associated with the project are received, including measures associated with physical program units and logical program units of the project. Mappings between physical program units and logical program units are generated. An architectural diagram including logical program units is received, and may include additional mappings of the logical program units. The mappings are used to roll up measures from physical project units to logical project units, and from logical project units to other logical project units. An overlay diagram is generated, including the rolled up measures. The overlay diagram includes the architectural diagram and a representation of rolled up measures associated with each logical project unit on the diagram. The representations employ a graphic format that facilitates a user determining risk areas of the software project. A user may view effects of project changes prior to checking them into source control.

Architectural data metrics overlay

A system and method for logging events processed by an operating system is provided. The events logged can include interrupt and non-interrupt events, and can include user-defined events. Information concerning the interrupt events is initially written, during event handling time, into a first buffer while information concerning non-interrupt events is initially written, during event handling time, into a second buffer. Information from the two buffers is then written to a third buffer not during event handling time. Separating the interrupt event buffer from the non-interrupt event buffer rather than having one buffer, and writing relatively small amounts of data during event handling time to memory, rather than transporting data to slower non-memory mapped devices allows the event logger to be less intrusive and facilitates greater accuracy in event logging. Data stored in the third buffer can be accessed by a viewing component, which facilitates displaying data in a manner useful to diagnose operating systems.

Operating system event tracking and logging

A human assisted method of debugging training data used to train a machine learning classifier is provided. The method includes obtaining a classifier training data set. The training data set is then debugged using an integrated debugging tool configured to implement a debugging loop to obtain a debugged data set. The debugging tool can be configured to perform an estimation and simplification step to reduce data noise in the training data set prior to further analysis. The debugging tool also runs a panel of prediction-centric diagnostic metrics on the training data set, and provides the user prediction based listings of the results of the panel of prediction-centric diagnostic metrics.

Method and apparatus for analysis and decomposition of classifier data anomalies

Methods, functional components and structures are disclosed for carrying out management of client/server processes operating within separate process spaces within a computer system. The disclosed methods, functional components facilitate and carry out management of client and server processes within a computer system such that a greater degree of control can be exhibited over their execution. An active server component process maintains a list structure identifying each client process that is currently using one of the server component process's interfaces. When a new client references a server, the list structure is augmented to include the system identification (e.g., handle) assigned by the operating system to the client process. A thread within the server process blocks while awaiting a triggering event (e.g., a client process in the list terminates). When the client process terminates, the block on the thread releases and the thread processes the change in client references. If the list of clients within the structure reaches zero, then the server process can immediately terminate.

Method and system for effective management of client and server processes

A schema-based device service that provides centralized access to per-user device data, wherein access to the device data is based on each user's identity. The device service includes a schema that defines rules and a structure for each user's data, and also includes methods that provide access to the data in a defined way. The device schema thus corresponds to a logical document containing the data for each user. A service such as a notification/alerts service accesses data in the logical document by data access requests through defined methods, such as in order to customize or modify a notification for a device based on the device characteristics. In one implementation, the device schemas are arranged as XML documents, and the services provide methods that control access to the data based on the requesting user's identification, defined role and scope for that role.

Schema-based services for identity-based access to device data

Operating system event tracker having separate storage for interrupt and non-interrupt events and flushing the third memory when timeout and memory full occur

Data capture and analysis for debugging embedded systems is disclosed. On a target, there is at least one data collector, each of which publishes predetermined data of the target, and a collection manager for managing the data collectors. On a host, there is at least one viewer, each of subscribes to the predetermined data of a data collector, for processing thereof, and a viewer manager for managing the viewers. Data collectors and viewers can be added, such that an extensible data capture and analysis embedded system architecture is provided.

Data capture and analysis for embedded systems

Target control abstraction for debugging embedded systems is disclosed. In an abstracted hardware model, there is a non-hardware-specific debugging interface, for communication between a debugger for the embedded system and the hardware of the embedded system. In an abstracted hardware-via-software model, there is a proxy to receive commands intended for the hardware of the embedded system from the debugger, and a component within a kernel of the embedded system to receive the commands and convey them to the hardware.

Target control abstraction for debugging embedded systems

An incremental garbage collector is disclosed. Upon termination of a function or program, the incremental garbage collector scans the object heap for objects allocated by the function or program that are not referenced outside the function or program that allocated the objects. Memory occupied by such objects is immediately reclaimed without having to wait for the garbage collector.

Incremental garbage collection

Combining multiple Java class files into a run-time image is disclosed. The run-time image of the Java class files is such that class files are in a preloaded and preparsed state for a Java virtual machine. Desirably, the run-time image is a DLL file stored in read-only memory (ROM), and comprises non-redundant data.

Combining multiple java class files into a run-time image

An inlining code generator, executing external to a runtime environment, reproduces the processing of an innerloop of an interpreter for the runtime environment. The inlining code generator processes a program in the interpreted language and produces a corresponding program in a compiled language. The compiled language program is compiled into a native language program using a standard compiler specific to the underlying hardware. Because the native language program operates within the framework of the runtime environment, functions and routines provided by the runtime environment are available to the native language program.

Generating a compiled language program for an interpretive runtime environment

Growing community of inventors

Redmond, WA, United States of America

David Michael Sauntry