Abstract: In various examples, techniques for performing software code verification are described. Systems and methods are disclosed for generating, using intermediate code and user input, a call graph that represents source code for software. For instance, the call graph represents at least functions (e.g., internal functions, external functions, etc.) associated with the software, calls (e.g., direct calls, call pointers, etc.) between the functions, and register information associated with the functions (e.g., variables used by the functions, assembly code used by the functions, etc.). The systems and methods may further use the call graph to perform software code verification by verifying rules from design specifications for the software and/or rules from various certification standards.

Abstract: The techniques disclosed herein enable systems to reduce the time required to terminate a set of microservices for an application while ensuring high availability and preventing request failures. This is accomplished through a termination manager which retrieves request queues for the microservices to analyze outstanding requests that require processing prior to termination. Based on the outstanding requests, the termination manager constructs call graphs for each request. The call graphs capture the operational flow of the associated request by defining a sequence of microservices whose functionality is invoked by the request. From an initial analysis, the termination manager can determine that some of the microservices do not appear in the call graphs, indicating that the microservices are not needed to process the outstanding requests. Accordingly, the unneeded microservices are terminated.

Abstract: A method is configured to perform a continuous software testing. A processor receives, from a code developer computer, a request to commit a code portion for a microservice to a code repository including a source code for a plurality of microservices. The processor executes, using the source code into which the code portion is incorporated, a test transaction routine including tests respectively associated with the plurality of microservices. The processor determines if one or more errors occurred in response to the executing the test transaction routine. If no errors occurred, the code portion is committed to the code repository, and, if one or more errors occurred, a notification is sent to the code developer computer regarding the one or more errors without committing the code portion to the code repository.

Abstract: An apparatus for executing a software program, comprising processing units and a hardware processor adapted for: in an intermediate representation of the software program, where the intermediate representation comprises blocks, each associated with an execution block of the software program and comprising intermediate instructions, identifying a calling block and a target block, where the calling block comprises a control-flow intermediate instruction to execute a target intermediate instruction of the target block; generating target instructions using the target block; generating calling instructions using the calling block and a computer control instruction for invoking the target instructions, when the calling instructions are executed by a calling processing unit and the target instructions are executed by a target processing unit; configuring the calling processing unit for executing the calling instructions; and configuring the target processing unit for executing the target instructions.

Abstract: Systems and methods support updates peripheral devices that may be coupled to an Information Handling System (IHS), such as provided at shared-use workstations. The IHS reports, to a remote orchestrator, an inventory of peripheral devices that are coupled to the IHS. In response, the remote orchestrator provides the IHS with files for updates to some or all of the coupled peripheral devices. As part of the updates, the remote orchestrator also designates a specific peripheral device as a proxy for making updates to other peripherals of the shared-use workstation. The IHS transmits the files to the proxy peripheral device, where the files are stored in a memory of the proxy peripheral device. The proxy peripheral device uses the files to update the other peripherals of the shared-use workstation, such as when the peripherals are not in use by the IHS, or after the IHS has been disconnected.

Abstract: Systems, computer program products, and methods are described herein for implementing a code debugger platform in a virtual environment. The system is configured to authenticate a plurality of users via an authentication portal and initialize an instance of a virtual environment for each of the plurality of users. The system is configured to extract a plurality of computer instructions, and display, in the virtual environment, a debugging platform of an integrated development environment, the debugging platform configured to receive the plurality of computer instructions and receive input from at least one of the plurality of users, and initiate a debugging protocol. The debugging protocol may include a breakpoint in at least one of the plurality of computer instructions, wherein the breakpoint is received as an input from the at least one of the plurality of users.

Abstract: Embodiments of the present invention provide a system for generating and transmitting visualized software code release and deployment functions to a mixed reality environment. The system is configured for determining that a user has submitted a software code associated with a software code release of a software application, identifying, one or more components in the software code, generating a release file comprising at least information associated with the one or more components, generating a summary file comprising a summary of the release file, transmitting the summary file to a distributed computing environment, converting the summary file to an immersive visualized file in the distributed computing environment, and displaying the immersive visualized file to one or more users comprising the user in the distributed computing environment, wherein the distributed computing environment is integrated with a mixed reality environment for displaying the immersive visualized file to the one or more users.

Abstract: An embodiment of the disclosed invention is a computer-implemented method for performing automated decision-making, which includes operating one or more loop(s) of sequential steps that receive data from the environment or from another source, interpret the data, decide on a course of action, and then execute the course of action. During the operation of the one or more loop(s), the method includes a self-monitor function that detects and corrects errors. Another embodiment is a loop architecture for performing automated decision-making that includes an API, three support modules, a receive module, an interpret module, a decide module, an execute module, and an orchestration layer. Another embodiment is a method for implementing a loop architecture to perform a task, wherein the method includes implementing handlers to perform the receive, interpret, decide, and execute functions, and implementing a topology definition.

Abstract: Provided is a control system, including: an acquisition unit, configured to acquire, from an mobile object, version information of each of a plurality of programs for controlling each of a plurality of mobile object control units included in the mobile object; a storage control unit, configured to store the acquired version information; a selection unit, configured to select an update program of at least one mobile object control unit among the plurality of mobile object control units; and an output control unit, configured to output the selected update program to the mobile object, wherein the selection unit is configured to select update program of at least one mobile object control unit among a plurality of mobile object control units included in the mobile object, based on the newly acquired version information, when the newly acquired version information newly acquired is not consistent with the stored version information.

Abstract: Computing systems, for example, multi-tenant systems deploy software artifacts in data centers created in a cloud platform using a cloud platform infrastructure language that is cloud platform independent. The system receives a declarative specification for creating a datacenter on a cloud platform. The system generates an aggregate pipeline comprising a hierarchy of pipelines. The system generates an aggregate deployment version map associating data center entities of the data center with versions of software artifacts targeted for deployment on the datacenter entities. The system collects a set of software artifacts according to the aggregate deployment version map. The system executes the aggregate pipeline in conjunction with the aggregate deployment version map to create the datacenter in accordance with the cloud platform independent declarative specification.

Abstract: A mobile application development device having a platform processor, a native application converter engine, and a mobile platform framework engine configured to facilitate the development and deployment of mobile applications configured to be run on different mobile operating systems from code that is developed independently and agnostic of the mobile operating system on which it will ultimately run.

Abstract: While a compiler compiles source code to create an executable binary, code is added into the compiled source code that, when executed, identifies and stores in a metadata table base and bounds information associated with memory allocations. Additionally, additional code is added into the compiled source code that enables hardware to determine a safety of memory access requests during an implementation of the compiled source code by performing an out-of-bounds (OOB) check in hardware using the base and bounds information stored in the metadata table. This enables the identification and avoidance of unsafe memory operations during the implementation of the executable by a GPU.

Abstract: Techniques are described herein that are capable of detecting accidental algorithmic complexity of a procedure by using instrumentation. A number of times a parent procedure calls a child procedure during each of multiple executions of the parent procedure is detected by using instrumentation to provide call counts for the respective executions. A value of an attribute of the parent procedure during each of the executions is detected by using the instrumentation to provide attribute values for the respective executions. A function is generated that defines a curve that estimates a relationship between the attribute values for the respective executions and the call counts for the respective executions. Based at least on a slope of the curve, accidental algorithmic complexity of the parent procedure is determined. Based at least on the accidental algorithmic complexity satisfying a complexity criterion, a remedial action is performed with regard to the accidental algorithmic complexity.

Abstract: Methods and systems that facilitate automatic generation of Application Programming Interface (API) specification from web traffic. Methods include obtaining a plurality of API requests and responses to the plurality of API requests. Methods include processing these API requests and responses to API requests to identify one or more attributes, such as, for example, variables, query parameters, response status codes, and response schemas. Methods include identifying variables using a tree data structure to represent resource paths. Methods include identifying query parameters based on resource items in resource paths. Methods include determining that the API call does not conform to the API specification by comparing one or more attributes of the API call with the attributes of the API specification.

Abstract: A method includes receiving a set of data. The set of data is divided into a plurality of data portions. The method includes transmitting the plurality of data portions to a plurality of processing tiles, wherein each data portion of the plurality of data portions is associated with a processing tile of a plurality of tiles. Each processing tile of the plurality of tiles performs at least one local operation on its respective data portion to form a local result. The method includes exchanging local results between the plurality of processing tiles. Moreover, the method includes calculating a global value based on the local results. The method further includes performing at least one local operation by each processing tile of the plurality of tiles on its respective data portion based on the global value to form a computed result.

Abstract: A computer-implemented method, system and computer program product for reducing register pressure. Loops of a computer program with a number of live variables that exceeds a threshold number, such as the number of available registers with capacity to store data, are identified. Such identified loops may be the to be subject to high register pressure. Upon identifying such loops in the computer program, chains within each identified loop are identified, where each chain includes load and store instructions from the same induction address and where the variable offsets of the load and store instructions are loop invariants. The address expressions for the load and store instructions in the identified chains may then be modified or changed to reuse common variable offsets using an analysis and transformation process. By reusing common variable offsets, there are less variable offsets that need to be stored in the registers thereby mitigating register pressure.

Abstract: A method for managing user stories in software development via artificial intelligence is disclosed. The method includes aggregating, via an application programming interface, raw data from a software development framework according to a predetermined schedule, the raw data corresponding to user stories from a plurality of users in a natural language format; ingesting the aggregated raw data to generate structured data sets; generating a language model by using a neural network and the structured data sets, the neural network including a transformer component; training, by using the structured data sets, the language model based on predetermined criterions; tuning the trained language model for tasks by adjusting parameters; and exposing, via a communication interface, the tuned language model.

Abstract: Efficiently replacing software breakpoint instructions in processor-based devices is disclosed. In this regard, in one exemplary embodiment, a processor-based device is provided. The processor-based device comprises a system memory and a processor. The processor comprises a breakpoint slip register (BSR) configured to store an instruction of a software process that was replaced in the system memory by a software breakpoint instruction, and further comprises a breakpoint slip enable (BSE) indicator. The processor is configured to, during execution of the software process, execute the software breakpoint instruction. The processor is further configured to, responsive to executing the software breakpoint instruction, transfer program control to a debugger. The processor is also configured to, upon program control returning from the debugger, determine that the BSE indicator is set.

Abstract: A method includes displaying an application page at a client system, the application page including a context menu container object that is not visibly displayed as part of the application page. During the display of the application page, the context menu container object holds a current set of context menu options and is responsive to a prescribed input to display the context menu as having the current set of context menu options. Further, during display of the application page, the context menu container object consumes events, evaluates logic to determine context menu options to display based on the first event, updates the current set of context menu options and displays the context menu as having the current set of context menu options.

Abstract: A center, configured to communicate with an OTA master that controls software updating of a plurality of electronic control units, includes a processor. The processor is configured to receive, from the OTA master, first identification information that identifies the electronic control units, and to store compatibility information that defines a version of software that is compatible with the electronic control units. The processor is configured to identify a version of software that is compatible with a target electronic control unit based on the compatibility information. The target electronic control unit is an electronic control unit that is an object of software updating among the electronic control units identified by the first identification information. The processor is configured to control, by communicating with the OTA master, such that software of the target electronic control unit is updated to the compatible version of the software that is identified.