Abstract: Systems and methods that provide centralized communication across feature programming workflows using software development lifecycle tools that dynamically determine temporal alerts are disclosed herein. By dynamically determining events that are temporally relevant, the system accounts for changes in an application timeline that comprises a plurality of events, in which each event of the plurality of events indicates when a respective feature of the plurality of features is available for use by the application, and in which the location of each event constantly changes.

Abstract: Some embodiments provide a non-transitory machine-readable medium that stores a program. The program parses a knowledge graph comprising a plurality of nodes and a plurality of edges to identify metadata associated with the plurality of nodes and the plurality of edges. Each edge in the plurality of edges connects a pair of nodes in the plurality of nodes. Each node in the plurality of nodes represents an entity. Each edge in the plurality of edges connecting a particular pair of nodes in the plurality of nodes represents a relationship between two entities represented by the particular pair of nodes. The program further determines a set of token definitions. The program also generates a set of syntax rules based on the identified metadata and the set of token definitions.

Abstract: A test-driven development system utilizes a neural transformer model with attention to generate method bodies for a focal method given its associated test cases, and optionally a method signature and a docstring of the focal method. The candidate method bodies are validated for syntactic correctness, tested using the given test cases, and tested with a donor class in a target system. Those candidate method bodies passing the validation and testing are then ranked based on a PLUM score that analyzes the candidate method bodies against various quality and performance metrics.

Abstract: Using a code transformation tool, a portion of executable code is inserted into existing executable code, the existing executable code comprising an existing constructor of a class, the existing constructor, when executed, instantiating an object of the class. During execution of the existing constructor, execution of the portion is caused to occur, the execution generating a record, the record comprising execution tracing data of the object.

Abstract: Computer processing and outcome prediction systems and methods used to generate algorithm time prediction polynomials, inverse algorithm time prediction polynomials, determine race conditions, determine when a non-linear algorithm can be treated as if it were linear, as well as automatically generate parallel and quantum solutions from classical software or from the relationship between monotonic attribute values.

Abstract: Disclosed are an intermediate representation method and apparatus for parallel execution of graph computation. The method includes the following steps: S1: compiling a neural network into a computational graph on a computer; S2: defining branch states of tensor variables in the computational graph; S3: defining a data dependency relationship of the tensor variables in the computational graph; S4: defining a control dependency relationship of the tensor variables in the computational graph; S5: building a data dependency relationship graph of the tensor variables in the computational graph; S6: building a control dependency relationship graph of the tensor variables in the computational graph; and S7: transforming control dependencies into data dependencies. The present application derives, based on the dependency relationship, a parallel computing method that can execute the branch threads in parallel in the global computational graph, and optimizes the compilation efficiency of the computational graph.

Abstract: The present disclosure provides a scalable container-based system implemented in computer instructions stored in a non-transitory medium. The present disclosure further provides a method of creating and operating a scalable container-based system.

Abstract: A method performed by one or more processors comprises displaying code, receiving user selection of a portion of code, determining one or more settable data items, generating a template, displaying the template, receiving a user input value for the settable data items by the template, and executing the code with each of the settable data items set to the received user input value. A data processing pipeline is configured to pass a data item to a first transformer to provide first transformed data, store the first transformed data in a temporary memory, write the first transformed data to the data storage system, and pass the transformed data from the temporary memory to a second transformer.

Abstract: A method and apparatus for modifying a user interface. The method comprises receiving user interface data at a client from a first server, receiving modification computer program code at said client, and executing said modification computer program code at said client to modify said user interface data to generate modified user interface data. The modification computer program code can be received from said first server or from a further server.

Abstract: Aspects of the invention include a compiler detecting an expression in a loop that includes elements of mixed data types. The compiler then promotes elements of a sub-expression of the expression to a same intermediate data type. The compiler then calculates the sub-expression using the elements of the same intermediate data type.

Abstract: Provided is a method for implementing compiled embedded Python. The method comprises: traversing an abstract syntax tree of Python source code to obtain semantic information about a program and generating corresponding C++ code according to said semantic information (S1); performing type annotation of the Python source code and thus generating C++ variable definitions and function definitions (S2); using a translator to translate into C++ source files the Python source code processed in the steps described above (S3); storing said C++ source files together with embedded chip-related files to form a file package, and compiling and linking said file package and generating an ASCII text file (S4). The method implements a source code translator on the basis of type annotations and static analysis, and integrates the translator into an embedded platform, enabling the editing, compiling, linking, and programming of Python source files.

Abstract: A delta debugging method and system based on a probability model which includes: acquiring an initial probability model and historical test data; optimizing and iterating the initial probability model through the historical test data to obtain an optimized and iterated probability model; and performing delta debugging on a target program containing multiple lines of code based on the optimized and iterated probability model to obtain a debugging result that meets a first preset condition. Therefore, by adopting the embodiment of the present application, the initial probability model can be continuously optimized and iterated through the historical test data, and the target program can be debugged based on the optimized and iterated probability model, so that the debugging result can be improved, or the compression amount of the size of the target program can reach a target compression amount, or the debugging time can be greatly reduced.

Abstract: A computer-implemented method, system and computer program product for generating test cases for testing software. Log files are analyzed for indications of software defects resulting in software errors. For those log files that were found to indicate software errors, such log files are analyzed to determine if they contain personal data that needs to be anonymized based on an entropy score of the personal data. When the entropy score of the personal data is below a threshold value, anonymized variations of the personal data are generated. Trace logs are then created containing the anonymized variations of the personal data, which are returned to a software tester to create a test case for testing software using the created trace logs without having access to personal data. In this manner, the software tester may reproduce the software errors without having access to the personal data.

Abstract: In a method for operating a machine tool and a corresponding machine tool system, a generic first data model and engineering data are provided in an external server device. The engineering data contain information relating to a machine tool. After a user query regarding an operation of the machine tool, the first data model is translated and/or modified to become a second data model. This occurs in accordance with the engineering data and technical data of the user query by the external server device. The second data model is transferred from the external server device to the machine tool, and a control unit of the machine tool can operate the machine tool according to the second data model. The machine tool can thus be adapted outside the running time of the machine tool.

Abstract: Embodiments of the present disclosure relate to a method, a device, and a computer program product for managing virtual machine upgrade. Provided is a method for managing virtual machine upgrade, including: determining, based on a received upgrade file for a virtual machine, a state of the virtual machine; and controlling, based on determining that the state indicates the virtual machine not being accessible via a network, installation of the upgrade file on the virtual machine via a virtual machine agent or a virtual machine manager, the virtual machine agent being capable of modifying a virtual disk of the virtual machine. Through the embodiments of the present disclosure, the installation of the upgrade file on the virtual machine can be realized when the virtual machine is not accessible via the network, whilst simplifying the virtual machine configuration and reducing the network bandwidth occupancy.

Abstract: An aspect provides a computer-implemented method for processing computer code. The method comprises receiving a first editable code set. In response to a first signal the method processes the first editable code set into first executable code by a first compiler within a first code processing path generating the first executable code. In response to a second signal the method both processes the first editable code set into a second editable code set, and processes the second editable code set into second executable code by a second compiler within a second code processing path generating the second executable code.

Abstract: Methods, computer program products, and/or systems are provided that perform the following operations: determining that a log multi-process debug mode is specified; obtaining a log file for debugging a source code, wherein the log file includes a plurality of log records; inserting a plurality of process identifier fields into each current log record in the log file; inserting a new log record into the log file for a created new process; and providing for performance of debugging for the source code based in part on the plurality of process identifier fields inserted into each current log record.

Abstract: Disclosed herein are techniques for automatically reconfiguring code based on function and subfunction analysis. Techniques include determining, by parsing a code structure representing a plurality of functions, that at least one first function has a threshold degree of complexity; identifying, in response to the determination, a plurality of subfunctions based on the at least one first function, the plurality of subfunctions having a commonality with the at least one first function; and forming a second function by reconfiguring the first function to call at least one of the identified plurality of subfunctions.

Abstract: Standardized model packaging and deployment, including: generating a model package comprising: model definition data for a model; function code facilitating execution of the model; and at least one interface for at least one operating system.

Abstract: Example robotic process automation systems and methods are described. In one implementation, a processing system receives one or more configuration options for a Bot, where the configuration options are associated with a design specification for the Bot. The processing system generates the Bot using the configuration options and instantiates the Bot on the processing system. A workflow associated with the design specification is executed by the Bot.