Dynamic adaptive programming

• US 8,572,591 B2
• Filed: 06/15/2010
• Issued: 10/29/2013
• Est. Priority Date: 06/15/2010
• Status: Active Grant

• Current Assignee: Zhigu Holdings Limited
• Original Assignee: Microsoft Corporation
• Inventors: Cwalina, Krzysztof Janusz, Haggard, Westley
• Primary Examiner(s): Vu, Tuan A
• Application Number:
  US12/816,249
• Publication Number:
  US 20110307869A1
• Time in Patent Office: 1,232 Days
• Field of Search: 717/136, 717/162, 717/100, 717/104, 717/108, 717/115, 717/140, 717/164, 717/147, 709217-223, 709/200, 709/225, 709/202, 709/230, 725/81, 707/1
• US Class Current: 717/147
• CPC Class Codes: G06F 8/447 Target code generation
• CPC Class Codes: G06F 8/54 Link editing before load time
• CPC Class Codes: G06F 9/44521 Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading

Abstract

Creating and executing platform portable code. A method includes declaring an object as being a dynamic object in a program. The program is a program compiled using a static language, except that the dynamic object is excluded from static analysis on the object when the program is compiled. The dynamic object includes a dependent call to a platform specific API. The platform specific API is available on one or more platforms to which a compiled version of the program will be deployed, but not available on one or more other platforms to which the compiled version of the program will be deployed.

Claims

1. In a computing environment comprising a static language program written using a statically compiled language wherein the statically compiled language makes provisions for dynamically compiled elements, including dependent calls to platform specific programming interfaces enabling platform-specific code translation, using a dynamic binding mechanism at a target platform, into a deployable platform executable to carry out an intended application functionality on a target platform among a plurality of target platforms, the target platform being the platform to which the compiled executable program is to be deployed but does not exist on one or more other platforms to which the compiled executable program is to be deployed and in which the statically compiled program is translated into its finalized form by invoking the dependent calls pertinent to the native resources of the target platform, a method of creating platform portable code, the method comprising:

declaring a portion of code defined in a static language program, prior to the static language program being compiled, as being a dynamic object, the portion of code being targeted for a target platform configured to execute the portion of code as defined in the static language program prior to compiling the static language program, the static language program being a program compiled using a static language, wherein declaring the portion of code as being a dynamic object prevents exceptions from being thrown due to the dynamic object based on static analysis when the static language program is compiled, wherein the dynamic object comprises a dependent call to a platform specific programming interface implemented in the target platform, the platform specific programming interface being available on the target platform, but not available on one or more other platforms to which the compiled version of the static language program will be deployed; and

statically compiling the static language program to platform portable code that is then deployed to and successfully executed on different platforms and where when the portable code is deployed to the target platform, the target platform is able to execute the portion of code declared as being a dynamic object, wherein statically compiling the static language program to platform portable code comprises leaving the portion of code declared as a dynamic object as dynamic code to be interpreted by the target platform to call the platform specific programming interface of the target platform.

2. The method of claim 1, wherein the dependent call to a platform specific programming interface is dependent on a method of the dynamic object included in the compiled program determining that the platform specific programming interface is supported.

3. The method of claim 1, wherein the dependent call to a platform specific programming interface is dependent on method of the dynamic object included in the compiled program determining the platform on which the compiled program is executing.

4. The method of claim 1, wherein the method creates platform portable code that is platform portable binary code, such that a single binary is created from a single source code program comprising one or more source code files, where the single binary is distributable to a plurality of different platforms.

5. The method of claim 1, wherein the dependent call to a platform specific programming interface facilitates light-up functionality enabling functionality on one or more platform to which the compiled program is deployed that does not exist on one or more other platforms to which the compiled program is deployed.

6. The method of claim 1, wherein the dependent call to a platform specific programming interface facilitates using alternative mechanisms to implement similar functionality on different platforms to which the compiled program is deployed, where each platform has similar functionality, but uses different programming interfaces to implement the functionality.

7. The method of claim 1, wherein the different platforms comprise platforms with different operating systems.

8. The method of claim 1, wherein the different platforms comprise platforms with different versions of operating systems.

9. The method of claim 1, wherein the different platforms comprise platforms with at least one of different hardware or software configurations.

10. The method of claim 1, wherein the different platforms comprise platforms having a different virtual machine.

11. In a computing environment comprising a statically compiled language wherein the statically compiled language makes provisions for dynamically compiled elements, including dependent calls to platform specific programming interfaces enabling platform-specific code translation, using a dynamic binding mechanism at a target platform, into a deployable platform executable to carry out an intended application functionality on a target platform among a plurality of target platforms, the target platform being the platform to which the compiled executable program is to be deployed but does not exist on one or more other platforms to which the compiled executable program is to be deployed and in which the statically compiled program is translated into its finalized form by invoking the dependent calls pertinent to the native resources of the target platform, a method of executing platform portable code, the method comprising:

accessing a portion of code, configured to be executed on a target platform, declared as a dynamic object included in a compiled program compiled from a static language program, wherein the portion of code was included in the compiled program before the static language program was compiled, but wherein the portion of code was excluded from static analysis during compiling of the compiled program, preventing exceptions from being thrown due to the dynamic object based on static analysis when the static language program is compiled, as a result of the portion of code being declared as a dynamic object in the static language program such that the portion of code remains as declared prior to the static language program being compiled such that the portion of code remains interpretable by the target platform before and after the static language program is compiled, leaving the portion of code declared as a dynamic object as dynamic code to be interpreted by the target platform to call the platform specific programming interface of the target platform, such that when the portable code is deployed to the target platform, the target platform is able to execute the portion of code declared as being a dynamic object, and wherein the portion of code comprises functionality to act as a proxy object that is configured to load a platform specific object at runtime if the platform specific object is accessible on a platform executing the compiled program at runtime;

testing the proxy object to determine if the platform specific object loaded successfully; and

determining that the platform specific object loaded successfully, and as a result making a call to the platform specific object programming interface.

12. The method of claim 11, wherein testing the proxy object to determine if the platform specific object loaded successfully comprises a method of the dynamic object included in the compiled program determining that the platform specific object is supported.

13. The method of claim 11, wherein testing the proxy object to determine if the platform specific object loaded successfully comprises a method of the dynamic object included in the compiled program determining the platform on which the compiled program is executing.

14. The method of claim 11, wherein compiled program is platform portable binary code and is a single binary created from a single source code program, where the single binary is distributable to a plurality of different platforms.

15. The method of claim 11, wherein making a call to the platform specific object API facilitates light-up functionality enabling functionality on one or more platform to which the compiled program is deployed that does not exist on one or more other platforms to which the compiled program is deployed.

16. The method of claim 11, wherein making a call to the platform specific object programming interface facilitates using alternative mechanisms to implement similar functionality on different platforms to which the compiled program is deployed, where each platform has similar functionality, but uses different programming interfaces to implement the functionality.

17. In a computing environment comprising a statically compiled language wherein the statically compiled language makes provisions for dynamically compiled elements, including dependent calls to platform specific programming interfaces enabling platform-specific code translation, using a dynamic binding mechanism at a target platform, into a deployable platform executable to carry out an intended application functionality on a target platform among a plurality of target platforms, the target platform being the platform to which the compiled executable program is to be deployed but does not exist on one or more other platforms to which the compiled executable program is to be deployed and in which the statically compiled program is translated into its finalized form by invoking the dependent calls pertinent to the native resources of the target platform, a method of executing platform portable code, the method comprising:

accessing a portion of code, configured to be executed on a target platform, declared as a dynamic object included in a compiled program compiled from a static language program, wherein the portion of code was included in the compiled program before the static language program was compiled, but wherein the portion of code was excluded from static analysis during compiling of the compiled program, preventing exceptions from being thrown due to the dynamic object based on static analysis when the static language program is compiled, as a result of the dynamic object being declared as a dynamic object in the static language program such that the portion of code remains as declared prior to the static language program being compiled such that the portion of code remains interpretable by the target platform before and after the static language program is compiled, leaving the portion of code declared as a dynamic object as dynamic code to be interpreted by the target platform to call the platform specific programming interface of the target platform such that when the portable code is deployed to the target platform, the target platform is able to execute the portion of code declared as being a dynamic object, and wherein the portion of code comprises a dependent call to a platform specific programming interface, the platform specific programming interface being available on one or more platforms to which the compiled program will be deployed, including the target platform, but not available on one or more other platforms to which the compiled program will be deployed, and wherein the dependent call to a platform specific programming interface will fail at runtime on some platforms to which the compiled program will be deployed;

testing the dynamic object to determine if the platform specific programming interface is supported on a platform presently executing the compiled program; and

determining that the platform specific programming interface is supported on the platform presently executing the compiled program, and as a result making a call to the platform specific programming interface.

18. The method of claim 17, wherein testing the dynamic object to determine if the platform specific programming interface is supported on a platform presently executing the compiled program comprises a method of the dynamic object included in the compiled program determining that the platform specific API is supported.

19. The method of claim 17, wherein testing the dynamic object to determine if the platform specific programming interface is supported on a platform presently executing the compiled program comprises a method of the dynamic object included in the compiled program determining the platform on which the compiled program is executing.

20. The method of claim 17, wherein compiled program is platform portable binary code and is a single binary created from a single source code program, where the single binary is distributable to a plurality of different platforms.