Patent Application
20120143866
Web application complexity is generally proportional to an amount of script that is needed to be downloaded and executed in a client application for a particular web page. This can introduce performance issues, as script files typically need to be downloaded and fully parsed at application boot time. Such undesired latency can affect user quality of experience manifested by a decrease in perceived performance of the web application.
In one aspect, a method for partitioning files of a web application is disclosed. The method includes receiving a plurality of files associated with the web application at a computing device, wherein each of the plurality of files include a plurality of constituent content; parsing each of the plurality of files into respective constituent content at the computing device; implementing an analysis of one or more relationships between the parsed constituent content at the computing device; organizing the parsed constituent content into a plurality of partitions based on the analysis of the one or more relationships; and generating a plurality of output files each corresponding to one of the plurality of partitions.
In another aspect, a computing device is disclosed including a processing unit and a system memory connected to the processing unit, the system memory including instructions that, when executed by the processing unit, cause the processing unit to implement a partitioning module configured for partitioning files of a web application. The partitioning module includes an input module configured to receive a plurality of input files. Each of the plurality of input files is associated with the web application and includes at least one logical unit of executable instructions. The partitioning module also includes a parse module configured to parse each of the plurality of input files into a plurality of nodes each corresponding to a respective logical unit of executable instructions and an analysis module configured to perform an analysis of relationships between the plurality of nodes and assign a weight to each of the plurality of nodes based on the relationships. The relationships comprise an inbound call frequency and an inbound call dependency. The partitioning module also includes a partition module configured to cluster the plurality of nodes into a plurality of partitions based on weight assigned to each of the plurality of nodes, content of the plurality of partitions including respective logical unit of executable instructions associated with corresponding nodes and an output module configured to generate an output file corresponding to each of the plurality of partitions.
In yet another aspect, a computer readable storage medium having computer-executable instructions is disclosed. The computer-executable instructions, when executed by a computing device, cause the computing device to perform steps including receiving a plurality of files associated with the web application. Each of the plurality of files include a plurality of constituent content, and one or more of the plurality of files comprise a source language different from other files of the plurality of files. The steps also include parsing each of the plurality of files into respective constituent content and associating an instance of parsed constituent content with a node of a dependency graph. Each node of the dependency graph represents a set of logical instructions of parsed constituent content selected from a function and a method. The steps also include implementing an analysis of a plurality of relationships between the parsed constituent content. The plurality of relationships include a call dependency including a number of nodes of the dependency graph including a reference to each respective node of the plurality of nodes, and a call frequency including a number of incoming references to a node of the dependency graph from other nodes of the dependency graph. The steps also include organizing the parsed constituent content into a plurality of partitions based on the analysis of the plurality of relationships. The plurality of partitions are selectively organized to include constituent content most related to other constituent content and to minimize a number of references from constituent content of one of the plurality of partitions to another of the plurality of partitions; generating a plurality of output files each corresponding to one of the plurality of partitions. The steps also include transferring the plurality of output files to at least one other computing device configured to host the web application.
This Summary is provided to introduce a selection of concepts, in a simplified form, that are further described below in the Detailed Description. This Summary is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used in any way to limit the scope of the claimed subject matter.
Aspects of the present disclosure may be more completely understood in consideration of the following detailed description of various embodiments in connection with the accompanying drawings.
The present disclosure is directed to systems and methods for minimizing start-up and implementation latency of a web application hosted in a computing system environment. In general, latency mitigation is accomplished via a programmatic approach to reduce the number of files or script needed for an initial boot of the web application. Remaining files are loaded either as needed or in a background process. Although not so limited, an appreciation of the various aspects of the present disclosure will be gained through a discussion of the examples provided below.
Referring now to
The method 100 begins at an input operation 105. The example input operation 105 is configured to receive an integer number N input files. Each of the respective N input files can correspond to a script file. In example embodiments, a script file is a client-side program that may accompany an HTML document or be embedded directly therein. An example script file includes a JavaScript script file. Others types of script files are possible.
The N input files may generally be similar or dissimilar, being generated by different tools and/or written in different source languages. The example method 100 is therefore generally applicable to any code or software such as code being hand-written, pre-processed, generated by compilers (e.g., Script#), tool generated (e.g., Visual Studio), and others. Additionally, the example input operation 105 is configured to handle and receive libraries (e.g., JQuery). This also provides validation across all project files.
Operational flow proceeds to a parse operation 110. The example parse operation 110 is configured to logically parse each of the respective N input files into constituent content. Example constituent content includes individual functions, methods, or any other logical unit of code or instructions. In one embodiment, the N input files are parsed into an integer number M nodes, in which each of the respective M nodes is associated with a block of code or instructions. Other embodiments are possible.
Operational flow then proceeds to an analysis operation 115. The example analysis operation 115 is configured to perform a static analysis of one or more relationships between the parsed constituent content as generated by the parse operation 110. Example relationships include call dependency, call frequency, and others. In example embodiments, call dependency includes a count of how many of the M nodes reference a given node within the M nodes.
Call frequency includes a count of how many times a given node of the M nodes is referenced by other nodes of the M nodes. Examples of a reference include a function call, a method call, and others. Such relationships can be represented by a directed graph, such as a dependency graph. In the example embodiment, an inbound edge to a given node of the M nodes, as embodied in a dependency graph, represents a single reference made to the given node by another node of the M nodes. Other embodiments are possible.
Operational flow proceeds to a partition operation 120. The example partition operation 120 is configured to logically cluster and organize the M nodes into a configurable integer number K partitions, based on the one or more relationships as evaluated by the analysis operation 115. In general, nodes of the M nodes that call or refer to each most frequently are grouped together in a respective partition. The resulting K partitions therefore group those nodes of the M nodes that are most related. In example embodiments, the partition operation 120 optimally generates the K partitions to minimize number of dependency graph edges that traverse a respective partition. Other embodiments are possible.
Operational flow then proceeds to an output operation 125. The example output operation 125 is configured to receive the K partitions and generate a corresponding integer number K output files. Each of the K output files contain respective constituent content represented by those nodes M that are contained within a given corresponding partition K.
In example embodiments, each of the respective K output files can correspond to a JavaScript script file. In this manner, the example method 100 is configured as a JavaScript-to-JavaScript compiler. However, as described in more detail below, the example method 100 can be extended to any technology involving a client downloading and executing files from a server.
Following generation of the K output files by the output operation 125, process flow proceeds to an end module 130 which corresponds to termination of the example method 100. In some embodiments, the end module 130 further corresponds to transferring the K output files to a server computing device that hosts a web application, such as described below in connection with
Referring now to
The client device 205 and the server device 210 are general purpose computing devices, such as described below in connection with
In some embodiments, the server device 210 includes a plurality of interconnected server devices operating together in a “Farm” configuration to implement business processes Still other embodiments are possible.
The storage device 215 is a data storage device such as a relational database or any other type of persistent data storage device. The storage device 215 stores data in a predefined format such that the server device 210 can query, modify, and manage data stored thereon. Examples of such a data storage device include mailbox stores and address services such as ACTIVE DIRECTORY® directory service from Microsoft Corporation. Other embodiments of the storage device 215 are possible.
The network 220 is a bi-directional data communication path for data transfer between one or more devices. In the example shown, the network 220 establishes a communication path for data transfer between the client device 205 and the server device 210. In general, the network 220 can be of any of a number of wireless or hardwired WAN, LAN, Internet, or other packet-based communication networks such that data can be transferred among the elements of the example networked computing environment 200. Other embodiments of the network 220 are possible as well.
Referring now to
The server device 210 includes at least one processing unit 305 and a system memory 310. The system memory 310 can store an operating system 315 for controlling the operation of the server device 210 or another computing device. One example operating system 315 is the WINDOWS® operating system from Microsoft Corporation.
The system memory 310 may also include one or more software applications 320 and may include program data. Software applications 320 may include many different types of single and multiple-functionality programs, such as a server program, an electronic mail program, a calendaring program, an Internet browsing program, a spreadsheet program, a program to track and report information, a word processing program, and many others. One example multi-functionality program is the Office suite of business applications from Microsoft Corporation.
The system memory 310 can include physical computer readable storage media such as, for example, magnetic disks, optical disks, or tape. Such additional storage is illustrated in
Communication media is distinguished from computer readable storage media. Communication media may typically be embodied by computer readable instructions, data structures, program modules, or other data in a modulated data signal, such as a carrier wave or other transport mechanism, and includes any information delivery media. The term “modulated data signal” means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media.
The server device 210 can also have any number and type of an input device 335 and output device 340. An example input device 335 includes a keyboard, mouse, pen, voice input device, touch input device, and others. An example output device 340 includes a display, speakers, printer, and others. The server device 210 can also contain a communication connection 345 configured to enable communications with other computing devices over a network (e.g., network 220 of
In example embodiments, the client device 205 of
Referring now to
The client device 205 includes a browser 415 and a local cache 420. The browser 415 includes logical modules of software of a client application executing on the client device 205 and configured for retrieving, presenting, and traversing information resources over a network (e.g., network 220). The local cache 420 includes physical computer readable storage media that stores data so that future requests for that data can quickly and efficiently be served to the browser 415.
The server device 210 includes a web application 425 and a partition store 430. The web application 425 includes logical modules of software of a server application executing on the server device 210, functionality of the web application being accessed over a network (e.g., network 220). The partition store 430 includes logical modules of software stored on the server device 210 that implements various functionality of the web application 425, as described in further detail below.
Communications within the example diagram 400 generally include a synchronous communication channel 435 and an asynchronous communication channel 440.
In example embodiments, a page request message 445 corresponding to a user interacting with the browser 415 to access a web page (e.g., http://www.microsoft.com) for a first time is transferred from the client device 205 to the server device 210 via the synchronous communication channel 435. The web application 425 is configured to receive and interpret the page request message 445 and return a page source message 450 that includes instructions for rendering the requested web page.
In example embodiments, the page source message 450 includes a reference to a partition P1 that the browser 415 is attempting to load and execute such that the user can fully experience the requested web page. Partitions P1-PK, where K>1, are contained within the partition store 430 on the server device 210. In general, the partitions P1-PK are formed in a manner similar to that described above in connection with
The browser 415 is configured to receive and interpret the page source message 450, and send a partition request message 455 to the web application 425 including a request to download the partition P1. In general, the partition P1 is a priority partition of the partitions P1-PK and includes a minimal amount of script and other data needed to render the requested web page within the browser 415, as described in further detail below in connection with
The web application 425 is configured to receive and interpret the partition request message 455 and return a priority partition message 460 that includes the partition P1. In some embodiments, the browser 415 is configured to store the partition P1 in the local cache 420 and execute the partition P1 from the local cache 420 as needed by browser 415. Other embodiments are possible.
As mentioned above, communications within the example diagram 400 additionally includes an asynchronous communication channel 440. In example embodiments, the browser 415 is additionally configured to receive and interpret a background partition message 465 to download and store the partitions P2-PK in the local cache 420.
In general, the download of the partitions P2-PK is a background process that can provide the browser 415 fast access to script and other information contained within the partitions P2-PK as the user navigates functionality and other web pages of the web application 425. Such an implementation is possible because the partitions P1-PK are static, as opposed to a per-page or per-request partition approach. In this manner, the local cache 420 may be taken advantage of to avoid unnecessary roundtrips to the server device 210, making execution of functionality of the web application 425 within the browser 415 faster and reducing the load on the server device 210.
Referring now to
As depicted in
In general, the example input module 515 is configured to receive an integer number N input files. In the example shown N=2, where the input module 515 receives a first input file 540 and a second input file 545. The first input file 540 is populated with a function F1, a function F2, and a function F3. The second input file 545 is populated with a function F4 and a function FN. In one embodiment, the first input file 540 and second input file 545 correspond to a JavaScript script file. Other embodiments are possible.
The input module 515 is additionally configured to transfer the first input file 540 and the second input file 545 to the parse module 520. The parse module 520 is configured to logically parse the first input file 540 and the second input file 545, and transfer a parsed file 550 to the analysis module 525. Other embodiments are possible. For example, in some embodiments the parsed file 550 is directly retrieved from computer readable storage media.
As depicted in
The analysis module 525 is configured to perform an analysis of relationships between the nodes M1-MN of the parsed file 550 to determine a corresponding call dependency CD and a call frequency CF, and transfer results of the analysis to the partition module 530. Call dependency CD evaluation includes determining which of the nodes M1-MN references another of the nodes M1-MN. For example, node M1 corresponding to function F1 includes a reference to node M2 corresponding to function F2 (e.g., F1[F2, 1]). Call frequency CF evaluation includes determining how many times a given node of the nodes M1-MN references another of the nodes M1-MN. Continuing with the above example, node M1 is shown including a single reference to node M2 (e.g., F1[F2, 1]). Other embodiments are possible. For example, any given node of the nodes M1-MN can reference one or more of the other nodes M1-MN and number of times.
Results of the analysis of the relationships between the nodes M1-MN corresponds to a weighting of the nodes M1-MN, represented by weights W1-WN. For example, as depicted in
Each of the weights W1-WN can be quantified by an algorithm. For example, in one embodiment, the weights W1-WN may be evaluated as a function of an inbound call dependency ICD and an inbound call frequency ICF. In the above example, in which the node M1 includes a reference to node M2, the weighting factor is assigned to the node M2. In another embodiment, each of the respective weights W1-WN may be evaluated as a function of inbound call dependency ICD, inbound call frequency ICF, and an additional term corresponding to a manual weighting MW. In the example embodiment, the manual weighting MW is provided from a user such as a programmer or developer at application build-time. Still other embodiments are possible.
As mentioned above, the analysis module 525 is generally configured to transfer results of the analysis to the partition module 530. The partition module 530 is configured to logically organize and cluster the nodes M1-MN into an integer number K partitions based on the weights W1-WN as evaluated by the analysis module 525, generate a partition file 555 including the K partitions, and transfer the partition file 555 to the output module 535.
As depicted in
The partitions P1-P3 are generally formed in order of importance. In the example embodiment, the partition P1 corresponds to a priority importance partition, partition P2 corresponds to a secondary importance partition, and partition P3 corresponds to a tertiary partition. In example embodiments, the partitions P1-P3 are formed programmatically. However, other embodiments are possible. For example, clustering of the nodes M1-MN, and therefore generation of the partitions P1-P3 may be manually adjusted. For example, the partition P3 may be manually adjusted to include node M2, shown in
In general, the output module 535 is configured to receive the partition file 555 and generate a first output file 565, a second output file 570, and a third output file 575 corresponding to and containing the partitions P1-P3. Subsequently, the first output file 565, second output file 570, and third output file 575 may be transferred to a server computing device that hosts a web application, such as described above in connection with
Referring now to
The method 800 begins at an operation 802. At operation 802, a priority importance partition comprising script and other data necessary to render a requested web page within the browser is executing on the client computing device. Operational flow then proceeds to an operation 805. At operation 805, the browser encounters invocation of a secondary importance partition within the priority importance partition.
Operational flow then proceeds to an operation 810. At operation 810, the browser queries the local cache to determine whether the secondary importance partition is stored in the local cache.
When the browser determines that the secondary importance partition is stored in the local cache, operational flow proceeds to an operation 820 in which the secondary importance partition is loaded and executed in the browser application from the local cache.
When the browser determines that the secondary importance partition is not stored in the local cache, operational flow proceeds to an operation 815 in which the secondary importance partition is downloaded from the web application to the local cache, the secondary importance partition being retrieved from the partition store. Following download of the secondary importance partition, operational flow proceeds to the operation 820 in which the secondary importance partition is loaded and executed in the browser application from the local cache. Other embodiments are possible.
The example embodiments described herein can be implemented as logical operations in a computing device in a networked computing system environment. The logical operations can be implemented as: (i) a sequence of computer implemented instructions, steps, or program modules running on a computing device; and (ii) interconnected logic or hardware modules running within a computing device.
For example, the logical operations can be implemented as algorithms in software, firmware, analog/digital circuitry, and/or any combination thereof, without deviating from the scope of the present disclosure. The software, firmware, or similar sequence of computer instructions can be encoded and stored upon a computer readable storage medium and can also be encoded within a carrier-wave signal for transmission between computing devices.
Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.
