Abstract: A processor may run a background process to identify a first task being initiated by a first user on a device, where the first task is associated with a first application. The processor may identify the first user of the device. The processor may analyze one or more interactions of the first user associated with the first application on the device. The processor may allocate, based at least in part on identification of the first user, identification of the first task, or analysis of the one or more interactions of the first user, computing resources to one or more hardware components on the device.

Abstract: The present invention relates to novel techniques for monitoring changes to source code of Infrastructure as Code systems to detect attempted anomalous changes and block such changes from the code. For example, a method may comprise learning a security architecture and history of an infrastructure as code system to be deployed in at least one cloud account, monitoring changes to source code of the infrastructure as code system that are made before deployment of the infrastructure as code system to detect an anomaly, determining whether the detected anomaly affects regulated resources of the infrastructure as code system, and blocking changes to the source code of the infrastructure as code system that produce the detected anomaly that affects regulated resources of the infrastructure as code system.

Abstract: A system, for managing application specific configuration data, that receives, from a local server, a standardized configuration object, at a configuration engine, for a configurable entity, generates at least one configuration object file for the configuration entity, wherein the standardized configuration object is generated based on the application specific configuration data according to a system wide metadata specification. The system can further write each configuration object file to a shared memory structure associated with a configuration file of a configurable entity. The system receives the configuration object, compares the configuration object with another standardized configuration object, and interfaces the configuration object with the configuration engine. The interfaced configuration object can be a piece of configuration. The system permits read access to the configuration engine to the configuration object, permits read and write access to the management server to the configuration object.

Abstract: The present disclosure provides systems and methods for compressing and/or distributing machine learning models. In one example, a computer-implemented method is provided to compress machine-learned models, which includes obtaining, by one or more computing devices, a machine-learned model. The method includes selecting, by the one or more computing devices, a weight to be quantized and quantizing, by the one or more computing devices, the weight. The method includes propagating, by the one or more computing devices, at least a part of a quantization error to one or more non-quantized weights and quantizing, by the one or more computing devices, one or more of the non-quantized weights. The method includes providing, by the one or more computing devices, a quantized machine-learned model.

Abstract: A system and method for automatically generating a dependency graph based on input and output requirements of information. The method includes obtaining, by a processing device, an object representing a plurality of modules executing on one or more processing devices. The plurality of modules is associated with a plurality of input requirements and a plurality of output requirements. Each module is configured to generate an output dataset of a respective output requirement of the plurality of output requirements based on an input dataset of a respective input requirement of the plurality of input requirements. The method includes generating, by the processing device, a dependency hierarchy of the plurality of modules based on the plurality of input requirements and the plurality of output requirements. The dependency hierarchy indicates one or more routes for the output datasets between at least a subset of the plurality of modules.

Abstract: A software library recommendation engine provides an analysis and aggregate dashboard comparison of metrics denoting maintainability trends in a plurality of libraries from a publicly available software repository. Maintainability trends include regularity and magnitude of changes (commits), resolution of user inquiries for issues, problems and bugs, and an estimation of core contributors for estimating inertia and longevity of a plurality of candidate libraries under consideration for a particular usage. Usage metrics coalesce and summarize usage data of libraries under consideration for comparison, and a dashboard of computed metrics provides an indication of trends that indicate reliability or longevity to mitigate vulnerability of the library user from dependence on the collaborative intent of the library author and contributors.

Abstract: Methods, systems, and computer program products for verifying confidential machine learning models are provided herein. A computer-implemented method includes obtaining (i) a set of training data and (ii) a request, from a requestor, for a machine learning model, wherein the request is accompanied by at least a set of test data; obtaining a commitment from a provider in response to the request, the commitment comprising a special hash corresponding to parameters of a candidate machine learning model trained on the set of training data; revealing the set of test data to the requestor; obtaining, from the requestor, (i) a claim of performance of the candidate machine learning model for the test data and (ii) a proof of the performance of the candidate machine learning model; and verifying the claimed performance for the requestor based on (i) the special hash and (ii) the proof of the claimed performance.

Abstract: Verifying control coupling and data coupling analysis in testing of software code that implements components; identifying control couples by performing static analysis on the source code; defining and executing control couple test runs of the software code including of the identified control couples that test runs using dynamic analysis; identifying control coupling coverage of the source file based on the dynamic analysis; identifying data couples within the source file, the data couples being a variable and a parameter of the components; defining data couple tests for each of the components containing of the identified data couples, the data couple tests using dynamic analysis; executing the data couple tests on the source file; identifying data coupling variable use coverage of the source file based on the dynamic analysis; and generating a report based on the identified control couple coverage and identified data coupling variable use coverage of the source file.

Abstract: A computer-implemented method, system and computer program product for analyzing test result failures using artificial intelligence models. A first machine learning model is trained to differentiate between a bug failure and a test failure within the test failures based on the failure attributes and historical failures. The failure type for each failed test in test failure groups is then determined using the first machine learning model. The failed tests in the test failure groups are then clustered into a set of clusters according to the failure attributes and the determined failure type for each failed test. A root cause failure for each cluster is identified based on the set of clusters and the failure attributes. The root cause of an unclassified failure is predicted using a second machine learning model trained to predict a root cause of the unclassified failure based on identifying the root cause failure for each cluster.

Abstract: A method, which may be performed by a computing system, involves determining that a plurality of notifications, including a first notification, is to be sent to a first client device, the first notification indicating a first task that is to be performed with respect to a resource accessible to the computing system; determining that a second task has a dependency relationship with the first task; determining at least one first parameter relating to the first task and at least one second parameter relating to the second task; determining, based at least in part on the at least one first parameter and the at least one second parameter, a first priority score corresponding to the first notification; and causing the plurality of notifications to be presented by the first client device in an order that is determined based at least in part on the first priority score.

Abstract: Illustrative systems and methods enable a virtual machine (“VM”) to be powered up at any hypervisor regardless of hypervisor type, based on live-mounting VM data that was originally backed up into a hypervisor-independent format by a block-level backup operation. Afterwards, the backed up VM executes anywhere anytime without needing to find a hypervisor that is the same as or compatible with the original source VM's hypervisor. The backed up VM payload data is rendered portable to any virtualized platform. Thus, a VM can be powered up at one or more test stations, data center or cloud recovery environments, and/or backup appliances, without the prior-art limitations of finding a same/compatible hypervisor for accessing and using backed up VM data. An illustrative media agent maintains cache storage that acts as a way station for data blocks retrieved from an original backup copy, and stores data blocks written by the live-mounted VM.

Abstract: We describe a computing machine, called an ex-machine, that uses self-modification and randomness to enhance the computation. The name ex-machine is derived from the latin extra machinam because its can evolve as it computes so that its complexity increases without an upper bound. In an embodiment, an ex-machine program can compute languages that a Turing or standard machine cannot compute. In an embodiment, the ex-machine has three types of instructions: standard instructions, meta instructions and random instructions. In an embodiment, the meta instruction self-modify the machine as it is executing so that new instructions are added. In an embodiment, the standard instructions are expressed in the C programming language or VHDL dataflow language. Random instructions take random measurements from a random source. In an embodiment, the random source produces quantum events which are measured. In an embodiment, an ex-machine receives a computer program as input, containing only standard instructions.

Abstract: Initiating the processing of resource events across disparate real-time processing networks, such as networks located international. In order to facilitate such resource events determinations are made that authorize the resource event participants to conduct the resource event across the international real-time processing networks. Once properly authorized the present invention provides for processing parameters to be determined, which may be specific to anyone of the resource participants and/or international real-time processing networks. Such processing parameters may be related to rules associated with settlement of the resource event, conversion rules for the international conversion of resources, resource sponsorship and the like. Once the resource event has been authorized and processing parameters determined, commands are sent to the respective interconnected international real-time processing networks that initiate the real-time processing of the resource event.

Abstract: In an embodiment, a method includes deploying a learning bot onto a system of bots, where the learning bot monitors a first bot of the system of bots, the first bot executing a first automated process. The method further includes determining a learning phase of the learning bot. The learning bot utilizes a plurality of learning phases including a first learning phase, a second learning phase and a third learning phase. The method also includes, responsive to a determination that the learning bot is in the third learning phase, the learning bot: monitoring activity related to the first automated process; collecting data related to the monitored activity; analyzing at least a portion of the collected data; identifying an automatic tuning adjustment responsive to the analyzing; and automatically making the automatic tuning adjustment to the first automated process.

Abstract: A system and method for software checkpoint-restoration between distinctly compiled executables is disclosed. A first compiled version of the software, such as Version A, is executed. After which, checkpointing is performed in order to generate a checkpoint image. After checkpointing, restarting execution is performed with at least some of a second compiled version of the software, such as Version B, being executed using a switching function that is configured to switch execution upon restart at least partly to the second compiled version of the software. In this way, different executable versions may be used during the restart than during the initial execution, such as an unoptimized build during the restart versus an optimized build during the initial execution, so that software testing and/or debugging may be performed more efficiently.

Abstract: The estimation and visualization of a degree of change between a further edited state of code and a selected version of the code. For each of some counted added or deleted portions (e.g., code lines) of code, the system estimates that the added (or deleted) portion complies with a non-review characteristic. The added (or deleted) code lines that comply with a non-review characteristic are excluded from the estimation of the degree of change. Thus, the estimation excludes consideration of added or deleted portions that need no substantial review, while considering more substantial added or deleted portions in the estimations. The estimation is then visualize giving the developer or the reviewer a better idea of the scale of changes that has really been made since the selected version of the code.

Abstract: A set of attributes of software packages may be determined by analyzing a first set of software packages, where the set of attributes of software packages may be useful for uniquely identifying software packages in the first set of software packages. A heuristic may be created or a machine learning model may be trained that combines the set of attributes of software packages to uniquely identify software packages in the first set of software packages. The heuristic or the trained machine learning model may be used to categorize a second set of software packages, or determine relationships among a second set of software packages.

Abstract: Responses of software applications to spatiotemporal events can be tested using simulated environments. In one example, a system can generate a simulated environment having simulated distributed devices positioned at various spatial locations in the simulated environment. The system can then simulate a spatiotemporal event propagating through the simulated environment by modifying a device simulation property of each simulated distributed device based on the spatiotemporal event and a respective spatial location of the simulated distributed device in the simulated environment. This can produce simulation outputs impacted by the spatiotemporal event. The system can then provide the simulation outputs as input to a target software application to test a response to the spatiotemporal event by the target software application.

Abstract: Approaches presented herein enable hot upgrading a microservices sequence in a cloud computing environment. More specifically, a next microservice of microservice subsequence in a running sequence is obtained, in response to a message to invoke the microservice or subsequence. The running microservice sequence includes at least one unexecuted microservice or subsequence that is to be hot upgraded. The running microservice sequence is generated based on a sequence that is to be hot upgraded which comprises an ordered list of microservices and/or subsequences. The approach may include determining the status of a next microservice or subsequence. The approach may further include invoking the next microservice or subsequence in the running sequence, in response to the status of the next microservice or subsequence being upgrade-complete.

Abstract: Techniques are described for using graph partitioning techniques to identify refactoring candidates to decompose monolithic software applications as part of software modernization processes. An application modernization system constructs a graph model of a software application based on an analysis of application artifacts associated with the software application. The graph model includes nodes each representing an independent application component and further includes edges representing identified dependency relationships among the application components. An application modernization system further generates application profile metrics associated with the identified dependencies, and weights derived from such metrics are applied to the edges of the graph model. Once a weighted graph model is obtained, a graph partitioning algorithm is applied to identify a plurality of subgraphs each representing a candidate subunit of the application for refactoring.