Abstract: A method for isolating access to shared software resources is disclosed. As part of deployment of an application, an aspect of an execution context for isolating access to a shared variable may be specified. During execution of the application, a current value of the aspect of the execution context may be determined. An access to the shared variable may be detected during execution of the application, and access to the shared variable may be redirected to an isolated copy of the shared variable dependent upon the current value of the aspect of the execution context and the shared variable.

Abstract: A computer readable medium including computer readable code for causing a computer system to perform a method. The method includes receiving an application, receiving application information for the application, and determining an access privilege for the application based, in part, on the application information. The method also includes generating a deployment package for the application using the application and the access privilege, and publishing the application.

Abstract: Metadata-driven dynamic specialization may include applying a type erasure operation to a set of instruction in a generic class or to a method declaration that includes typed variables using an encoded form of an instruction or an argument to an instruction. The instruction may operate on values of the reference types and the argument may be a signature that indicates the reference types. The encoded form may be annotated to include metadata indicating which type variables have been erased and which reference types are the erasures of type variables. Additionally, the metadata may indicate that the instruction operates on values of, and that the argument indicates reference types that are erasures of, the type variables of the class (or method) declaration. Moreover, the encoded form of the instruction or argument may be used directly without specialization or transformation.

Abstract: Structural identification of dynamically generated, pattern-instantiation classes may be utilized using structural descriptions. Instead of describing classes only by name, and using that name to locate that class, a class may be referred to by a generator function and arguments to the generator function. A structural description may specify the generator function and the parameters. In addition, a structural description of a class may be used as a parameter to a generator function specified by another structural description. A structural description may be used similarly to a class name for virtually any situation in which a class name may be used. Classes may be compared using their structural descriptions. For example, two structural descriptions may be considered to be the same class if they specify the same generator function and parameters.

Abstract: A method for software compilation is disclosed. A compiler may identify features of source code which are unavailable in a target environment for the compilation. The compiler may then translate the identified features into modified features in response to determining that projections for the identified features into the target environment are available. The compiler may then compile the source code dependent upon the modified features.

Abstract: The disclosed embodiments provide a system that facilitates the development and execution of a software program. During operation, the system provides a mechanism for restricting a variable to a runtime context in the software program. Next, the system identifies the runtime context during execution of the software program. Finally, the system uses the mechanism to prevent incorrect execution of the software program by ensuring that a closure capturing the variable executes within the identified runtime context.

Abstract: A system and method can support compiler testing in a programming language environment. The programming language environment can include a testing framework that can provide a program template based on a programming language that is targeted by a compiler implementation to be tested. Furthermore, the testing framework can generate a plurality of sub-tests that contains different variations in the test space based on the program template, and can use the compiler implementation to be tested to compile the generated sub-tests. Finally, the testing framework can check the output of the compiler implementation to be tested against the expected output for the generated sub-tests.

Abstract: A non-transitory computer readable storage medium including computer readable code that, when executed by a processor, is configured to receive, from a user network device, a first request to execute an application on the user network device. The first request includes a user identification, routing information, and requested application information, encrypted using a public key. The user network device is configured to display the application on a television display device. The code is further configured to decrypt the routing information and requested application information using a private key, send a second request for subscription information to a service provider, receive the subscription information from the service provider, and determine that a license corresponding to the application is associated with the user. The code is further configured to generate and send an application package configured to deploy the application using a Java Runtime Environment on the user network device.

Abstract: According to one technique, a virtual machine identifies a first instruction to create a variable handle instance, the first instruction including declaration information that identifies a type of receiver and a variable held by the receiver to which the variable handle instance is configured to provide access. If access to the variable is permissible, the virtual machine creates the variable handle instance comprising constrained functions configured to execute constrained operations on a memory location of the variable. The virtual machine identifies a second instruction that specifies a call to a particular constrained, wherein the second instruction specifies the receiver or is implicitly bound to the receiver. The virtual machine identifies a particular memory location where the instance of the variable is stored and performs the particular constrained function with respect to the particular memory location.

Abstract: The loading or operation of a specialized class may trigger the specialization of other classes. A compiler may be configured to recognize dependency relationships between generic classes and to describe the classes in terms of the type variables of the triggering types (e.g., the types and/or type parameterizations) that trigger the specialization of classes based on the specialization of a first class. A compiler may include information, such as structural references, indicating dependency relationships between classes when generating class files. Thus, the class file may include information indicating that a class extends a class resulting from applying a specialization code generator to an argument. Loading a first class may trigger the loading of a second class described by a structural description such that a specializer (and/or class loader) may apply the structural description to generate and load the second class for the particular parameterization.

Abstract: A system and method can support compatibility checking in a programming language environment. The programming language environment can check whether a target type associated with an expression in the programming language environment is functional, wherein the target type is functional when it has exactly one method meeting one or more criteria that define that method as relevant in a counting system. Then, the programming language environment can derive a function descriptor from the target type, which is context-dependent. Furthermore, the programming language environment can type-check the expression with the function descriptor associated with the target type.

Abstract: Techniques herein process type variables to transform type parameters (TPs) of generic classes. In an embodiment, a computer stores a generic class attribute associated with a definition of a generic class. The generic class attribute includes a type variable declaration (TVD) for each TP. Each TVD is associated with usage entries (VUEs) within the definition. Each VUE indicates an actual type for use, within a portion of the definition, as the TP represented by the VUE. Based on how a particular portion of the definition uses a particular TP represented by a particular TVD of a particular VUE, the computer determines whether the particular VUE is to be assigned to a particular type or erased. In response to determining that the particular VUE is to be erased, the computer configures the particular VUE to indicate erasure. Otherwise, the computer assigns the particular type to the particular VUE.

Abstract: Techniques herein processes type assignments for a generic class to generate a concrete class. In an embodiment, a computer analyzes a client class to detect a dependency on a generic class having type parameters. The client class contains a specialization context that specifies type assignments for the type parameters. Each type parameter is associated with particular type entries in the generic class that identify an erasure type to use in case the type parameter is erased. The computer generates instantiation metadata for the generic class including, for each type entry, performing the following. In response to determining that the specialization context specifies binding a particular type to the type parameter associated with the type entry, the computer generates an entry for the instantiation metadata that identifies the particular type. Otherwise, the computer generates an entry for the instantiation metadata that identifies an erasure type of the type entry.

Abstract: A non-transitory computer readable storage medium including computer readable code that, when executed by a processor, is configured to receive, from a user network device, a first request to execute an application on the user network device. The first request includes a user identification, routing information, and requested application information, encrypted using a public key. The user network device is configured to display the application on a television display device. The code is further configured to decrypt the routing information and requested application information using a private key, send a second request for subscription information to a service provider, receive the subscription information from the service provider, and determine that a license corresponding to the application is associated with the user. The code is further configured to generate and send an application package configured to deploy the application using a Java Runtime Environment on the user network device.

Abstract: Modular co-versioning may involve the creation of multi-version libraries that may include multiple versions of a class. A multi-version library may include a base version and one or more other versions each of which may correspond to a particular, respective version of a software development kit, runtime environment or software platform, according to various embodiments. At runtime, a multi-version library may be searched in order to load a version of a class that corresponds to the version of the currently executing runtime environment. If the multi-version library does not include a version of the class corresponding to the currently executing version of the environment/platform, a version of the class corresponding to a previous version of the environment may be loaded if found in the multi-version library. Alternatively, if no other version of the class is found, a base version of the class may be loaded from the multi-version library.

Abstract: Operations include a compilation process and a runtime process. A compiler compiles code to generate virtual machine instructions. The compiler further generates information referencing respective parameter types of the parameters of a target virtual machine instruction. The compiler stores the information external to and in association with the target virtual machine instruction. The information may be included in another virtual machine instruction that precedes the target virtual machine instruction. A runtime environment processes the target virtual machine instruction based on the information stored external to and in association with the target virtual machine instruction. Parameter types referenced by the external information override parameter types that are (a) referenced by the target virtual machine instruction itself, (b) deduced by the runtime environment and/or (c) stored directly in association with the parameter values.

Abstract: A system and method can support compatibility checking in a programming language environment. The programming language environment can check whether a target type associated with an expression in the programming language environment is functional, wherein the target type is functional when it has exactly one method meeting one or more criteria that define that method as relevant in a counting system. Then, the programming language environment can derive a function descriptor from the target type, which is context-dependent. Furthermore, the programming language environment can type-check the expression with the function descriptor associated with the target type.

Abstract: In accordance with various embodiments, systems and methods are provided which facilitate inferring immutability of variables. A compiler analyzes local variables within source code to determine whether they are immutable. In particular embodiments the compiler examines locations where each variable is assigned to determine whether the variable was definitely unassigned before the assignment. Because the compiler can infer whether a local variable is immutable, it is possible for the programmer to avoid using a keyword to expressly declare the local variable as immutable. Inferring immutability of variables, thus, maintains correctness of the compiled code while reducing the burden on the programmer.

Abstract: Generic classes may have more than one specializable type parameter and it may be desirable to specialize one or more of the type variables while not specializing others. The result of partial specialization may be one or more additional generic classes that are further specializable on the remaining type parameters. A runtime specializer may partially specialize a generic class to produce a partially specialized class and may subsequently further specialize the partially specialized class to generate a fully specialized class. Thus, rather than performing the specialization of a generic class all at once, such as by specializing Map<K, V> into Map<int, int> or Map<long, int>, one type parameter may be partially specialized, such as resulting in Map<K, int>, and then at some later time the remaining type parameter(s) may be specialized, such as to generate Map<int, int> or Map<long, int>.

Abstract: Methods and apparatus for target typing of overloaded method and constructor arguments are described. A method comprises determining whether source code of a program includes, as an argument to an overloaded operation invocation, an expression whose type is context-dependent. The method further comprises, if the source code includes such an argument, providing the expression as an input to an overload resolver, and determining at the overload resolver whether (a) each argument of the invocation is compatible with types of corresponding parameters in one or more declarations and (b) whether a particular declaration among such a set of declarations can be identified as the most specific. If both conditions are met, the method comprises generating executable instructions for the invocation.