Automated code splitting and pre-fetching for improving responsiveness of browser-based applications

• US 9,405,555 B2
• Filed: 05/23/2008
• Issued: 08/02/2016
• Est. Priority Date: 05/23/2008
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Inventors: Livshits, Benjamin, Kiciman, Emre, Ding, Chen
• Primary Examiner(s): BROPHY, MATTHEW J
• Application Number:
  US12/125,931
• Publication Number:
  US 20090292791A1
• Time in Patent Office: 2,993 Days
• Field of Search: 717/172, 717/177, 709/205
• US Class Current: 1/1
• CPC Class Codes: G06F 9/451 Execution arrangements for user interfaces
• CPC Class Codes: G06F 9/547 Remote procedure calls [RPC]; Web services

Abstract

A “code splitting tool” provides various techniques for automatically analyzing and rewriting existing browser-based applications to introduce dynamic code loading into those applications thereby improving perceived application responsiveness. Structural elements of application code (including functions, classes, etc.) are broken into small “stubs” with corresponding bodies. Rewritten applications then initially transfer only the portion of the code (including some combination of stubs and bodies) to the client as necessary for initial application execution. Additional stubs and/or bodies are then transferred either on-demand at runtime or in the background. Automated code rewriting proceeds without requiring any application-specific knowledge or changes to existing code prior to code rewriting. Further, the code splitting tool can tailor code rewriting to specific computing devices (computers, PDA'"'"'s, cell phones, etc.), specific network conditions, and/or specific users, through an automated training process that creates clusters that control code downloads to optimize perceived application responsiveness.

Claims

1. A method for automatically rewriting a web application to improve perceived application performance, comprising steps for:

receiving a web application that is designed to be executed within a browser-type application on a client computing device (i.e., the client);

decomposing structural code units of the web application into a set of stubs and a set of corresponding bodies;

determining a clustering of structural code units within the web application, said clustering being based, in part, on an identification of first execution times for each structural code unit, each first execution time representing a particular point in time corresponding to a first-access time that is observed at runtime for each particular structural code unit;

constructing a new application by rewriting the web application based on the clustering, wherein stubs are used to replace corresponding structural code units in the application to reduce a total size of code that that must be transferred to the client;

wherein each stub retrieves the corresponding body to the client when the stub is executed within the browser-type application on the client; and

wherein the retrieved corresponding body is then used to enable client-side execution of the corresponding body.

2. The method of claim 1 wherein determining the clustering of stubs further includes:

constructing a separate access profile for one or more unique groups of one or more clients; and

wherein each access profile is used to determine which structural code units are sufficiently related to require those structural code units to be downloaded as a single cluster from a server hosting the new application to the clients in the unique group, said sufficiently related structural code units being used to determine the clustering.

3. The method of claim 2 wherein determining which structural code units are sufficiently related further includes performing a runtime analysis to identify the first execution times for each structural code unit of the web application within the browser-type application of each client in each unique group.

4. The method of claim 2 wherein determining which structural code units are sufficiently related further includes evaluating network characteristics for communications between a server hosting the web application and the clients in each unique group.

5. The method of claim 2 further comprising periodically reconstructing one or more of the separate access profiles for use in determining the clustering.

6. The method of claim 1 wherein any structural code units needed for initial execution of the web application are not decomposed into stubs and bodies, and are instead included as a first portion of the new application along with the stubs which are included as subsequent portions of the new application.

7. The method of claim 6 further including providing the new application to the client in place of the web application, and wherein providing the new application to the client further includes:

downloading the first portion of the new application to the client;

automatically scheduling and background downloading one or more of the subsequent portions of the new program to the client, said background downloads being scheduled based on available bandwidth between the server and the client; and

automatically scheduling downloading the bodies to the client on either of being called by a corresponding stub and as a background download prior to being called by the corresponding stub, said background downloads being automatically scheduled based on one or more predetermined trigger conditions.

8. The method of claim 1 wherein the web application is maintained by a third-party server, wherein:

the web application is received by inserting a proxy between the third-party server and the client to capture and relay communications from the third-party server to the client; and

once the new application constructed, the new application is maintained by the proxy so that calls to the web application from the client are replaced by the proxy with the new application without contacting the third-party server.

9. A system for automatically decomposing and rewriting a web application for execution within a browser-type application, comprising:

a device for receiving a web application;

a device for learning a unique access profile for each of a plurality of unique groups of one or more clients, each access profile including an identification of first execution times for each structural code unit of the web application within the browser-type application of each client in each unique group;

each first execution time representing a particular point in time corresponding to a first-access time that is observed at runtime for each particular structural code unit;

a device for decomposing the web application to generate a set of stubs and a set of corresponding bodies for structural code units, wherein each stub is designed to call its corresponding body for retrieval by the client when the stub is executed by the client, and wherein the retrieved corresponding body is then used to enable client-side execution of the corresponding body;

a device for generating a corresponding clustering of stubs from each unique access profile; and

a device for constructing a separate new application for each unique access profile by rewriting the web application based on the corresponding clustering of stubs associated with each access profile to reduce a total size of code that that must be transferred to the client prior to initial execution of the new application.

10. The system of claim 9 wherein rewriting the web application based on the corresponding clustering of stubs associated with each access profile further includes using the clusters of stubs to replace corresponding structural code units in the web application.

11. The system of claim 9 wherein learning a unique access profile for each of the plurality of unique groups of one or more clients further includes automatically injecting an application instrumentation utility into the web application to perform a runtime analysis of user interaction with the web application to identify the first execution times for each structural code unit.

12. The system of claim 9 further including providing one of the new applications to the client in place of the web application when the client directs the browser application to a website hosting the web application.

13. The system of claim 9 wherein any structural code units needed for initial execution of the web application are not decomposed into stubs and bodies, and are instead included as a first portion of each separate new application along with the clusters of stubs which are included as subsequent portions of each separate new application.

14. The system of claim 13 further comprising providing one of the new applications to the client by:

downloading the first portion of the new application to the client as soon as the client directs the browser application to a website hosting the web application;

automatically scheduling and background downloading one or more of the subsequent portions of the new program to the client, said background downloading being scheduled based on available bandwidth between a server hosting the website and the client; and

automatically scheduling downloading of the bodies to the client on either of being called by a corresponding stub and as a background download prior to being called by the corresponding stub.

15. A computer-implemented process, comprising:

applying a computer to perform process actions for;

receiving a web application, said web application designed to be delivered from a server to a client for execution within a browser application running on the client when the client directs the browser application to a website hosted by the server, said website including the web application;

performing an automated training phase to construct a unique access profile for each of a plurality of unique groups of one or more clients, each access profile including an identification of first execution times for each structural code unit of the web application within the browser-type application of one or more of the clients in each unique group;

each first execution time representing a particular point in time corresponding to a first-access time that is observed at runtime for each particular structural code unit;

generating a set of stubs and a set of corresponding bodies for each structural code unit comprising the web application;

processing each unique access profile to identify clustering parameters for generating a corresponding clustering of stubs from each unique access profile;

constructing a separate new application for each unique access profile by rewriting the web application based on the corresponding clustering of stubs associated with each unique access profile; and

wherein each stub is designed to retrieve its corresponding body from the server when the stub is executed by the client, and wherein the retrieved corresponding body is then used to enable client-side execution of the retrieved corresponding body.

16. The computer-implemented process of claim 15 wherein stub descriptions are generated by the server and then used by the client to locally generate the stubs.

17. The computer-implemented process of claim 15 wherein the web application is maintained by a third-party server, wherein:

receiving a web application further includes inserting a proxy between the third-party server and at least one client to capture and relay communications from the third-party server to the at least one client; and

providing at least one of the new applications to the proxy so that when calls to the web application are made by one or more of the clients, the proxy provides one of the new applications to the client without contacting the third-party server for the web application.

18. The computer-implemented process of claim 15 wherein any structural code units needed for initial execution of the web application are not decomposed into stubs and bodies, and are instead included as a first portion of each separate new application along with the clusters of stubs which are included as subsequent portions of each separate new application.

19. The computer-implemented process of claim 18 further comprising providing one of the new applications to the client by:

downloading the first portion of the new application to the client as soon as the client directs the browser application to the website hosting the web application;

automatically scheduling and background downloading one or more of the subsequent portions of the new program to the client, said background downloading being scheduled based on available bandwidth between the server hosting the website and the client or other similar trigger condition; and

automatically scheduling downloading of the bodies to the client on either of being called by a corresponding stub and as a background download prior to being called by the corresponding stub, said background downloading being scheduled based on available bandwidth between the server and the client.

20. The computer-implemented process of claim 15 wherein performing the automated training phase for identification of first execution times for each structural code unit further includes automatically injecting an application instrumentation utility into the web application to perform a runtime analysis of user interaction with the web application to identify the first execution times for each structural code unit.