A method may include receiving a first definition of an object type from a first software component and a second definition of the object type from a second software component. The object type may be labeled by an ID. The method may further include storing, in a dynamic graph, a node labeled by the ID, and storing, in a type definition repository external to the dynamic graph, the first definition of the object type and the second definition of the object type. The method may further include receiving, from the first software component, a modified first definition of the object type. The method may further include replacing, in the type definition repository and using the ID, the first definition of the object type with the modified first definition, and transmitting, to the second software component, a message indicating a need to lookup, by the ID, the modified first definition.

Apparatuses, systems, and techniques to receive, by a processor of a computer system, one or more operations for a kernel; automatically generate, by the processor, one or more operators that perform the one or more operations on elements of one or more input data structures; and automatically generate, by the processor, the kernel that comprises the one or more operators.

Functionality is described for providing a compiled program that can be executed in a parallel and a distributed manner by any selected runtime environment. The functionality includes a compiler module for producing the compiled program based on a dataflow representation of a program (i.e., a dataflow-expressed program). The dataflow-expressed program, in turn, includes a plurality of tasks that are connected together in a manner specified by a graph (such as a directed acyclic graph). The compiler module also involves performing static type-checking on the dataflow-expressed program to identify the presence of any mismatch errors in the dataflow-expressed program. By virtue of this approach, the above-described functionality can identify any errors in constructing the graph prior to its instantiation and execution in a runtime environment.

To improve the technological process of programming a computer using a dynamic programming language, generate a first portion of training data which maps types in the dynamic programming language to corresponding functions and methods by performing information retrieval on documentation libraries in the dynamic programming language and/or generate a second portion of training data which maps program variables to the corresponding functions and methods by performing data flow analysis on a plurality of pre-existing programs written in the dynamic programming language. Train a neural network on the first and/or second portions of training data to infer unknown types in the dynamic programming language. Carry out inference with the trained neural network to infer the unknown types. Facilitate programming in the dynamic programming language based on the inferred unknown types. Optionally, execute a resulting program.

According to some embodiments, systems and methods are provided, comprising receiving a code fragment exhibiting a static code issue; determining, via a trained exemption neural network, whether the received code fragment is exempt or not exempt from resolution; in a case it is not exempt, inputting the code fragment to a trained classification neural network; determining whether the static code issue is a syntactical static code issue or a non-syntactical static code issue; in a case it is a syntactical static code issue, inputting the code fragment to a first trained network to generate a first resolution; and in a case the static code issue is a non-syntactical static code issue, inputting the code fragment to a second trained network to generate a second resolution of the non-syntactical static code issue. Numerous other aspects are provided.

Computer-implemented techniques for preventing garbage object accumulation on minimal runtimes. The techniques include checking whether source code written in a source programming language that does not require the programmer to explicitly program when deallocation happens can run within a runtime that provides little or no support for implicit deallocation. At the same time, the techniques ensure that objects in minimal runtimes are deallocated in a timely manner. In one aspect, the techniques encompass generating a compile-time alert (e.g., an error or warning message) to a programmer of source code or halting compilation of the source code upon detecting a data type definition in the source code with the potential for reference cycles. With the techniques, the programmer is provided with an implicit deallocation experience while producing program fragments that interoperate with minimal runtimes that provide no or only minimal support for implicit deallocation (e.g., provide only reference counting).

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.

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.

Techniques for accessing a migrated method include: identifying a request to invoke a method defined by a type, the request including one or more arguments associated with respective argument types; identifying, in the type, an older version of the method associated with (a) a method name and (b) a first set of one or more parameter types, and a current version of the method associated with (a) the method name and (b) a second set of one or more parameter types; determining that the argument type(s) match(es) the first set of one or more parameter types; responsive to determining that the argument type(s) match(es) the first set of one or more parameter types: applying one or more conversion functions to convert the argument(s) to the second set of one or more parameter types; executing the current version of the method using the converted argument(s).

A program rewrite method executed by a computer, the method includes rewriting a program to output a first output group by performing operations for a first variable among a plurality of variables with a plurality of data types; rewriting the program to output a second output group by performing operations for a second variable among the plurality of variables with a plurality of data types; identifying, from the first output group and the second output group, a third output group that satisfied a predetermined criterion as a result of executing the rewritten programs; determining a data type that corresponds to the third output group as a use data type; and outputting a program in which the use data type is set for each of the plurality of variables.