Abstract: A parametric constant resolves to different values in different contexts, but a single value within a particular context. An anchor constant is a parametric constant that allows for a degree of parametricity for an API point. The context for the anchor constant is provided by a caller to the API point. The anchor constant resolves to an anchor value that records specialization decisions for the API point within the provided context. Specialization decisions may include type restrictions, memory layout, and/or memory size. The anchor value together with an unspecialized type of the API point result in a specialized type of the API point. A class object representing the specialized type is created. The class object may be accessible to the caller, but the full value of the anchor value is not accessible to the caller. The API point is executed based on the specialization decisions embodied in the anchor value.

Abstract: In some examples, continuous learning-based application related trade-off resolution and implementation may include generating, based on a plurality of historical tradeoff instances, an application feature matrix. Further, association rules for historical tradeoff instances for which decisions are not known, and a decision tree for historical tradeoff instances for which decisions are known may be generated. Decision rules may be induced, and default rules may be applied to a cold start scenario. The decision rules and the default rules may be refined to generate refined rules, and a confidence level may be determined for the refined rules. The refined rules may be prioritized based on the confidence level and applied to a new tradeoff instance to generate a resolution associated with the new tradeoff instance. The resolution may be implemented with respect to the new tradeoff instance.

Abstract: A code completion tool uses a neural transformer model with attention to generate candidate sequences to complete a method body of a method signature. The neural transformer model is trained with source code programs and natural language text. The neural transformer model learns the meaning of a method name, its corresponding method parameters and types from a large corpus of unsupervised dataset of source code methods and a supervised dataset of tasks including source code constructs in combination with natural language docstrings to infer a candidate sequence of subtokens that represent a method body for a particular method signature.

Abstract: A workflow engine processes a work problem to generate solutions for the work problem comprising a plurality of related optimization problems. The work problem may comprise a second optimization problem that is dependent on a first optimization problem, such that at least one solution for the first optimization problem is to be utilized as an initial solution for the second optimization problem. The workflow engine generates and stores a branch object for each optimization problem, each branch object specifying a solver engine assigned for processing the optimization problem and dependency information indicating a dependency relationship between the optimization problem and another optimization problem. The workflow engine processes the work problem based on the branch objects by initiating each solver engine to perform optimization operations on the assigned optimization problem based on the corresponding branch object to generate one or more solutions for the assigned optimization problem.

Abstract: Methods, apparatus, systems, and articles of manufacture are disclosed that perform machine learning-guided compiler optimizations for register-based hardware architectures. Examples disclosed herein include a non-transitory computer readable medium comprising instructions that, when executed, cause a machine to at least select a register-based compiler transformation to apply to source code at a current position in a search tree, determine whether the search tree is in need of pruning based on an output of a query to a machine learning (ML) model, in response to determining the search tree is in need of pruning, prune the search tree at the current position, in response to applying the selected register-based compiler transformation to the source code, generate a code variant, calculate a score associated with the source code at the current position in the search tree, and update parameters of the machine learning (ML) model to include the calculated score.

Abstract: Custom source code generation models are generated by tuning a pre-trained deep learning model by freezing the model parameters and optimizing a prefix. The tuning process is distributed across a user space and a model space where the embedding and output layers are performed in the user space and the execution of the model is performed in a model space that is isolated from the user space. The tuning process updates the embeddings of the prefix across the separate execution spaces in a manner that preserves the privacy of the data used in the tuning process.

Abstract: Some embodiments track internal actions of a development tool, and actions of a user of the tool. When the user faces a problem, information about the problem state is matched to a mitigation graph that was built from other user's sessions with the tool. Then documentation contextualized to the problem is synthesized, e.g., using machine learning models, and presented to the user. In addition to text and images, the documentation may include interaction points such as hyperlinks or buttons associated with code that mitigates the problem. For example, a mitigation sequence may proactively instruct the tool to perform certain actions such as an install or build or undo, or may automatically operate the tool user interface proactively in place of the user. Mitigation sequences may be sorted, and subjected to cost or outcome desirability prioritization. An administration tool provides mitigation graph management functionality. Personally identifiable information presence is constrained.

Abstract: An offload server includes: an application code analysis section configured to analyze a source code of an application and detect external library calls included in the source code as replacement sources; a replacement function detection section configured to retrieve libraries and IP cores from a code pattern database by using the detected external library calls as keys, as replacement-destination libraries/IP cores; and a replacement processing section configured to replace processing descriptions of the replacement sources with processing descriptions of the replacement-destination libraries/IP cores retrieved by the replacement function detection section and to generate interfaces of a CPU to the replacement-destination libraries/IP cores.

Abstract: A model lifecycle management method includes: executing a model initial development phase based on at least a first criteria, a second criteria, and a third criteria to obtain a set of production ready models; executing, using the set of production ready models, a model production phase based on at least a fourth criteria, a fifth criteria, and a sixth criteria to obtain; and executing, after executing the model production phase, using the set of models to be updated, a model update phase based on at least a seventh criteria on at least one model in the model production phase.

Abstract: A unit test generation system employs a neural transformer model with attention to generate candidate unit test sequences given a focal method of a programming language. The neural transformer model is pre-trained with source code programs and natural language text and fine-tuned with mapped test case pairs. A mapped test case pair includes a focal method and a unit test case for the focal method. In this manner, the neural transformer model is trained to learn the semantics and statistical properties of a natural language, the syntax of a programming language and the relationships between the code elements of the programming language and the syntax of a unit test case.

Abstract: Systems, computer instructions and computer-implemented methods are disclosed for implementing space- and time-efficient enumerations. An instance of an enumeration class may be created with a constant, plurality of enumerations. A plurality of objects corresponding to the respective enumerations may be stored in memory along with a lookup table indexed by respective ordinal values of the plurality of enumerations, the lookup table including respective references to the stored objects of the instantiated enumeration class. A reference to an enumeration may be stored in a memory location by storing an ordinal value of the enumeration. A determination may then be made to convert a stored ordinal value to a reference to an object, and responsive to the determination, the ordinal value may be loaded and used as an index into the lookup table to obtain the reference to the object corresponding to the enumeration.

Abstract: A system and method for automatic coding out biases in applications, systems, and processes are disclosed. A processor operatively connected to a memory via a communication interface applies an intake process based on received inventory data to applications, systems, and processes and implements a machine learning model in response to applying the intake process. The processor also identifies areas of the potential bias data within the applications, systems, and processes by utilizing the machine learning model based on analyzing response data received during the intake process; generates output data that includes bias data and exceptions data identified for the applications, systems, and processes; and mitigates the bias data and exceptions data in response to the output data by implementing a mitigation process.

Abstract: A computer-implemented method includes receiving a portion of code, inputting the received portion of code to a probabilistic data structure to determine whether the portion of code is similar to one or more other portions of code, and based on determining that the one or more other portions are similar to the received portion of code, identifying a number of similar portions of code. The method also includes storing relationship data that associates the similar portions of code with the received portion of code, determining one or more subject matter experts (SMEs) associated with the similar portions of code and the received portion of code and determining correlations between SME data and the relationship data, and storing the SME data and the correlations, the SME data including an indication of the determined SMEs, the relationship data correlating the one or more SMEs to the received portion of code.

Abstract: Adaptive automated testing methods and systems are disclosed. In an embodiment, an automatic test controller of an automated test system may collect a log of a plurality of actions executed by a plurality of devices of the automated test system and apply a heuristic to the log as the automated test system operates to determine whether to execute a next action by a device of the automated test system. When the next action is to be executed, the automatic test controller automatically directs the device to execute the next action. Otherwise, the automatic test controller indicates the next action was intentionally skipped by recording such omission in the log and automatically skipping the next action.

Abstract: An interrelated set of tools and methods is disclosed for: (1) measuring the relationship between software source code attributes (such as code quality, design quality, test quality, and complexity metrics) and software economics outcome metrics (such as maintainability, agility, and cost) experienced by development and maintenance organizations, (2) using this information to project or estimate the level of technical debt in a software codebase, (3) using this information to estimate the financial value of efforts focused on improving the codebase (such as rewriting or refactoring), and (4) using this information to help manage a software development effort over its lifetime so as to improve software economics, business outcomes, and technical debt while doing so.

Abstract: A type restriction contextually modifies an existing type descriptor. The type restriction is imposed on a data structure to restrict the values that are assumable by the data structure. The type restriction does not cancel or otherwise override the effect of the existing type descriptor on the data structure. Rather the type restriction may declare that a value of the data structure's type is forbidden for the data structure. Additionally or alternatively, the type restriction may declare that an element count allowable for a data structure's type is forbidden for the data structure. Type restriction allows optionality (where only a singleton value for a data structure is allowed), empty sets (where no value for a data structure is allowed), and multiplicity (where only a limited element count for a data structure) to be injected into a code set independent of data type. Type restriction allows certain optimizations to be performed.

Abstract: A method includes creating one or more first policy shims to be applied to a ML/AI module, applying the one or more first policy shims to an input or an output of the ML/AI module and executing the ML/AI module on a data set in response to the applying step. The one or more first policy shims includes an input policy shim and an output policy shim and the applying step includes applying the input policy shim to the data set prior to the executing step and applying the output policy shim to an output of the executing step.

Abstract: Methods and computing devices for allocating test pods to a distributed computing system for executing a test plan on a device-under-test (DUT). Each test pod may include a test microservice including one or more test steps and an event microservice specifying function relations between the test microservice and other test microservices. The test pods are allocated to different servers to perform a distributed execution of the test plan on the DUT through one or more test interfaces.

Abstract: Embodiments described herein a code generation and understanding model that builds on a Transformer-based encoder-decoder framework. The code generation and understanding model is configured to derive generic representations for programming language (PL) and natural language (NL) in code domain via pre-training on unlabeled code corpus, and then to benefit many code-related downstream tasks with fine-tuning. Apart from the denoising sequence-to-sequence objectives widely adopted for pre-training on natural language, identifier tagging and prediction pre-training objective is adopted to enable the model to better leverage the crucial token type information from PL, which specifically are the identifiers assigned by developers.

Abstract: This disclosure relates generally to configuring/building of applications. Typically, a deep learning (DL) application having multiple models composed and interspersed with corresponding transformation functions has no mechanism of efficient deployment on underlying system resources. The disclosed system accelerates the development of application to compose multiple models where each model could be a primitive model or a composite model itself. In an embodiment, the disclosed system optimally deploys a composable model application and transformation functions on underlying resources using performance prediction models, thereby accelerating the development and deployment of the application.