O
`
`(12) Ulllted States Patent
`Kieffer
`
`(10) Patent N0.:
`(45) Date of Patent:
`
`US 7,966,626 B2
`*Jun. 21, 2011
`
`US007966626B2
`
`11/1999 Malcolm ..................... .. 7_07/103
`13233 i;::,::::::::;:1
`10/2000 13
`t
`t
`1.
`11/2000 513-Zilereetaaj,
`4/2001 Bodin ........ ..
`5/2001 1VIlllCOl]1’1 et (11.
`8/2001 Burneret al.
`/
`ah-
`31,
`gfiinglifn H
`1/2002 Lee ct 31,
`,
`1/2002 L1Ii et al
`.
`3/2002 King et al.
`3/2002 Bogle et al.
`3/2002 Khan et al.
`(Continued)
`OTI IER PUBLICATIONS
`
`,,,,,,,, _, 707/9
`709/236
`.. 707/100
`707/104
`_,
`/
`70;P270§
`,, 709/219
`.. 715/709
`707/513
`., 717/4
`707/526
`
`
`
`.
`
`5,995,975 A
`2;3::;2s: :2
`6,141,793 A
`5,151,599 A
`6,223,224 B1
`6,230,157 B1
`6,282,548 B1
`,2" ,"'
`
`5,336,137 B1
`6,340,977 B1 *
`6,353,839 B1
`6,353,923 B1
`6,360,236 B1
`
`International Preliminary Examination Report for PCT Application
`set’ N0‘ PCT/L S01/02962’
`(C°n‘m“ed)
`Primarv Examiner — Van I-1 Nguyen
`~
`(74) Attorney, Agent, or Firm — Finnegan, Henderson,
`Farabow, Garrett & T)u1merI,I_P
`
`(57)
`
`ABSTRACT
`
`Systems and methods are provided for optimizing application
`code for deployment to a client over a data link to minimize
`download time by supplying only the application code with a
`particular object that is required by the object. In a web
`application that includes multiple pages,
`the HTML and
`JAVASCRIPT may be scanned to identify code resources
`,0a11e<,1bYaPart10u1ar Web page Whenallcalled resourses are
`identified, they may be extracted and concatenated into a
`single resource tile. When the page is downloaded to the
`client, the import file may be included with the page. The
`import file may be cached so that it need only be downloaded
`once, rather than being downloaded every time the page is
`requested. The disclosed systems and methods are suitable
`for use with other interpreted scripting languages.
`
`27 Claims, 3 Drawing Sheets
`
`(54) QPTIMIZED DELIVERY OF WEB
`
`(75)
`
`_
`Inventor: Robert Kieffer, San Francisco, CA (US)
`Assigneej
`Inc_, Dulles,
`.
`.
`.
`.
`.
`( * ) Notice:
`S11b]ect to any disclaimer, the term ofthis
`patent is extended or adjusted under 35
`U.S.C. 154(1)) by 978 days.
`,
`,
`,
`,
`,
`This patent is subject to a terminal d1s—
`clajnler,
`
`(21) Appl. No: 11/761,287
`
`(22)
`(65)
`
`(63
`
`(50
`
`Flledi
`
`Jun‘ 1L‘ 2007
`Prior Publication Data
`US 2007/0300244 A1
`Dec. 27, 2007
`.
`.
`RltdU.S.A l
`t Dt
`Pp lea Ion
`e a e
`a a
`Continuation of application No. 10/203,043, tiled as
`application No. PCT/US01/02962 on .l£l11. 30, 2001,
`now Pat. No. 7,231,644.
`
`Provisional appfieatjon No, 50/180,378, filed on Feb,
`4, 2000,
`
`(51
`
`Int. Cl.
`(2006.01)
`G061" 9/44
`(52 US, Cl.
`,,,,,,,,,,,,,,,,,,,,,,, ,. 719/331; 709/203; 709/219
`(53
`Field of Classification Search ................ .. 719/331,
`719/332, 709/203, 219
`See apphcatjon fi]e for complete Search history,
`
`(56
`
`References Cited
`U.S. PATENT DOCUMENTS
`.... 1. 395/793
`5,572,643 A
`11/ 996 Judson .
`707/206
`5,835,914 A
`11/ 998 Brim .
`1/1
`5,956.709 A *
`9/ 999 Xue ..
`
`
`
`
`EXTRACT ALL RESOURCES HAVING
`’is-used‘ FIELD SET AND WRITE
`TO NEW IMPORT FILE
`
`UPDATE APPLICATION
`
`CODE TO REFER TO
`NEW IMPORT FILE
`
`
`
`
`
`
`DOWNLOAD NEW
`IMPORT FILE
`WITH HTML FILE
`
`Apple Exhibit 1029
`
`Apple v. Core Wireless
`IPR2015-01898
`
`Page 00001
`
`Apple Exhibit 1029
`Apple v. Core Wireless
`IPR2015-01898
`Page 00001
`
`

`
`US 7,966,626 B2
`Page 2
`
`U.S. PATENT DOCUMENTS
`6,362,836 B1
`3/2002 Shaw et al.
`................. .. 345/744
`6,370,573 B1
`4/2002 Bowman-Amuah .
`.. 709/223
`6,393,472 B1*
`5/2002 Anerousis et al.
`.. 709/223
`6,427,149 B1
`7/2002 Rodriguez et al.
`. 707/10
`6,615.253 B1
`9/2003 Bowinan-Amuah .
`.. 709/219
`6,687,737 B2
`2/2004 Landsman et al.
`.......... .. 709/203
`6,744,447 B2
`6/2004 Estrada et al.
`............. .. 709/204
`6,748,418 B1 *
`6/2004 Yoshida et al.
`6,880,123 B1
`4/2005 Landsman et al.
`....... .. 715/500.1
`6,952,279 B1* 10/2005 Iida .......... ..
`. 358/1.15
`6,961,750 B1* 11/2005 Burdetal.
`.
`709/203
`6,961,905 B1
`11/2005 Cover et al.
`717/108
`......... ..
`6,990,653 B1*
`1/2006 Burdetal.
`.. 709/206
`7,130,885 132* 10/2006 Chandraetal.
`.. 719/331
`7,231,644 B2*
`6/2007 Kieffer ..... ..
`7,493.554 B2*
`2/2009 Pailaet al.
`.
`OTHER PUBLICATIONS
`
`International Search Report for PCT Application Ser. No. PCT/
`US0l/02962.
`Logic Web." Enhancing the Web with Logic Programming; Andrew
`Davison. and Seng \Vai Loke; Dec. 23. 1996.
`Survey Vliz and Factor Wiz: JavaScript web pages that make HTAIL
`forms for research on the Internet; M.H. Birnbaum; Behavior
`research Methods, Instruments, & Computers; May 2000.
`Decrypting Ja vaScript; K. Chambers; Application Development
`Advisor; Jul.-Aug. 2000.
`Creating a multiple—choice self—marlcetingengine on the internet;
`T.W. Ng; International Journal of Engineering Education; 2000.
`A dynamic select componentfor JavaScript; S. Johnson; Dr. Dobb’s
`Journal; Jan. 2000.
`Generalized event handling in JavaScript; A. Hildyard; WEB Tech-
`niques; Feb. 1999.
`Building object—oriented web pages with SilverStreaIn; M. Pfeifer;
`WEB Techniques; Feb. 1999.
`Adding style and behaviour to Web pages with a dash ofSpice; D.
`Raggett; Computer Networks and ISDN Systems; Apr. 1998.
`
`Architecture, design, and development ofan HTA/II./IavaScript We —
`based group support system; N.C. Romano. Jr.; J.F. Nunamaker. J11;
`R.O. Briggs; and D.R.Vogel; Journal of the American Society for
`Information Science; May 15, 1998.
`Orthogonal extensions to the WWW user interface using client—side
`technologies; A. Fox. S.D. Gribble. Y. Chawathe, A.S. Polite. A.
`Huang, B. I,ing and EA. Brewer; Proceedings of the ACM Sympo-
`sium on User Interface Software and Technology. 10”“ Armual Sym-
`posium; Oct. 14-17, 1997.
`Responsive interaction for a large Web application." the Meteor
`Shower architecture in the WebWriter II editor; A.Crespo, Bay-Wei
`Chang, and E.A. Bier; Computer Networks and ISDN Systems; Sep.
`1997.
`Animation with layers in DHTML. Innovative examples from noted
`designers; J.S. Hamlin; WEB Techniques; Dec. 1997.
`Jump startingyour site with Dynamic HTML. Active content without
`page updates; R. Dobson; WEB Techniques; Dec. 1997.
`Lking JavaScript to write JavaScript; N.R. Radovanovic, VVEB
`Techniques; Sep. 1997.
`Lking JavaScript to create interactive Web pages; T. Tcssicr; Dr.
`Dobb’s Journal; Mar. 1996.
`Optimization of Printer Font Download Using Font Character
`Download on Demand, IBM 1989.
`Kong et al; Mitigating Server-Side Congestion in the Internet
`Through Pseudoserving; 1999 IEEE; pp. 530-544.
`Accessing Multiple Mirror Sites in Parallel. Using Tornado Codes to
`Speed Up Downloads; 1999 IEEE, pp. 275-283.
`LISP—a Languagefor Internet Scripting and Programming: Timo-
`thy J. I-Iickey, Peter Norvig, and Kenneth R. Anderson, (1998).
`the
`Responsive
`interaction for
`a
`large Web
`application:
`,Meteoi;Shower architecture in the WebWriter II editor; A.Crespo,
`Bay-Wei Chang, and E.A. Bier; Computer Networks and ISDN Sys-
`tems; Sep. 1997.
`Snow Net.‘ An Agent-Based Internet Tourist Information Service; A.
`Erni, and MC. Norrie; Institute for Information Systems Swiss Fed-
`eral Institute of Technology (ETH), (1997).
`The.Iava Language Specyication, Chapter I2, lst Ed., (1996).
`
`"‘ cited by examiner
`
`Page 00002
`
`

`
`U.S. Patent
`
`Jun. 21, 2011
`
`Sheet 1 of3
`
`US 7,966,626 B2
`
`<HEAD>
`
`<3QRIpT SR0:
`</SCRIpT>
`
`_
`
`FORM.JS
`
`FUNCTIONS
`
`16
`
`VoHdcIteDOteO
`.
`.
`VahdoteTIme0 /”
`VoHdoteColorO
`Vo|idateAddressO
`VaHduteEmoHAddressO
`
`</FORM>
`</BODY>
`
`TEXT AREA
`
`EZZZZZZZZIJ
`
`STRING.JS//r77
`porseo
`truncoteO
`todoteO
`
`Page 00003
`
`

`
`U.S. Patent
`
`Jun. 21, 2011
`
`Sheet 2 of 3
`
`US 7,966,626 B2
`
`SCAN CODE
`
`IDENTIFY REQUIRED
`
`RESOURCES
`
`22
`
`CONCATENATE REQUIRED
`
`RESOURCES INTO
`
`NEW INPORT FILE
`
`IDENTIFY CODE
`
`ENTRY POINTS
`
`IDENTIFY EMBEDDED
`
`CODE BLOCKS
`
`IDENTIFY
`
`IMPORT FILES
`
`Page 00004
`
`

`
`U.S. Patent
`
`Jun. 21, 2011
`
`Sheet 3 of 3
`
`US 7,966,626 B2
`
`IDENTIFY ALL
`
`AVAILABLE RESOURCES
`
`CREATE RESOURCE
`
`INFORMATION OBJECT
`
`FOR EACH RESOURCE
`
`CREATE
`
`RESOURCE LIST
`
`STEP THROUGH CALL
`
`PATH TO LOCATE EACH
`
`RESOURCE CALLED
`
`SET ’is—-used’ FIELD
`
`FOR EACH CALLED
`
`RESOURCE
`
`EXTRACT ALL RESOURCES HAVING
`
`’is-used’ FIELD SET AND WRITE
`
`TO NEW IMPORT FILE
`
`UPDATE APPLICATION
`
`CODE TO REFER TO
`
`NEW IMPORT FILE
`
`DOWNLOAD NEW
`
`IMPORT FILE
`
`WITH HTML FILE
`
`Page 00005
`
`

`
`US 7,966,626 B2
`
`1
`OPTIIVIIZED DELIVERY OF WEB
`APPLICATION CODE
`
`CROSS REF ‘R ‘NCE TO RELATED
`APPLICATIONS
`
`This application is a continuation of U.S. patcnt applica-
`tion Ser. No. 10/203,043 (issued as U.S. Pat. No. 7,231,644),
`filed Aug. 2, 2002, which is incorporated herein in its entirety
`by this reference thereto and which is the U.S. National Phase
`under 35 U.S.C. §371 of International Application No. PCT/
`US01/02962 (published as WO 01/57663), filed Jan. 30,
`2001, which claims priority to U.S. Patent Application No.
`60/180,378, filed Feb. 04, 2000.
`
`BACKGROUND OF THE INVENTION
`
`,
`
`1. Field of the Invention
`The invention relates to the field of data processing. More
`particularly, the invention relates to a method of optimizing
`application code for delivery to a client over a data connec-
`tion, in which only those parts of tl1e application code needed
`by a particular object within the application are delivered to
`the client with the object, thus minimizing download time.
`2. Description of Related Art
`In thc world of wcb applications, dcvclopcrs facc scvcrc
`limitations whe11 trying to deploy client-side functionality. In
`general, good development practice pushes developers
`toward tl1e creation of a rich base of generalized code to draw
`from. This code base frequently becomes very diverse in the
`functionality it supports and very complicated i11tl1e depen-
`dencies, as more and more code is written that depends on the
`code that existed prior to it. This generalized code base is
`extremely powerful as it allows the rapid development of
`applications. And, in the traditional world of desktop appli-
`cations, where memory and bandwidth are secondary con-
`straints, deploying such a rich and weighty system has been
`moderately straightforward.
`Web applications, on the other hand, are strictly limited in
`tlie amount of code that can be delivered to the client. A web
`application is little more than a set of web pages that support
`different functionalitics. For example, a web presentation
`application may l1avc onc page for cach of thc following
`functions:
`viewing the users’ presentations;
`editing a presentation; and
`viewing a presentation.
`Thus, there is a dramatic limitation wl1e11 it comes to deliv-
`ering the client side functionality. A traditional desktop appli-
`cation may take 30 Mbytes of code to run—a conservative _
`estimate. On a 56K modem line, this much infonnation takes
`at least ten minutes to transfer to the clie11t. It is unreasonable
`to expect the typical web user to wait this long for a page to
`load.
`This leads to the problem addressed by this invention—that
`ofdeploying code to the client in an ellicient and optimized
`manner.
`
`The prior art provides various strategies and systems for
`optimizing application code in tlie web environment. For
`cxamplc, B. Muschctt, W. Traccy, S. Woodward, Mcthod and
`system in a computer network for bundling and launching
`hypertext files and associated subroutines within archive
`files, U.S. Pat. No. 6,026,437 (Feb. 15, 2000) describe a
`method and system in a computer network in which a HTML
`file having tags that point to particular applets is bundled i11to
`an archive file with the applets and the data associated with
`tl1e applets. In response to a client request to download the
`
`2
`hypertext file; the file, the applets, and associated data are
`downloaded as a single archive file. VVhile tl1e described
`invention reduces download time by increasing data packag-
`ing efiiciency and eliminating the need for multiple data
`requests to the server for multiple objects; the single object
`created,
`incorporating the hypertext page,
`the applet or
`applcts and thc associated data, rcsults in a large data object,
`which itself, requires substantial download time. Further-
`more, the described system makes no attempt to reduce the
`amount ofdata downloaded; it merely packages and transmits
`it more efficiently. Moreover, since the hypertext file and the
`applet are packaged together i11 tl1e san1e archive file, botl1
`applet and hypertext file must be downloaded every time the
`client requests the hypertext file.
`C. Bryant, T. Goin, T. Moos, D. Steele, Apparatus and
`method for increasing the performance of interpreted pro-
`grams running on a server, US. Pat. No. 6,141,793 (Oct. 1,
`2000) describe an apparatus and method in which interpreted
`scripts, such as CGI scripts are consolidated into a single
`process, similar to a library of interpreted code routines.
`Whcn the process is to bc cxccutcd, thc intcrprctcd proccss
`forks its self and has the resulting child process run the
`already compiled interpreted code. In this way, the inter-
`prctcd codc nccd only bc compilcd oncc, rather than compil-
`ing over a11d over again. While the described invention
`improves tl1e perfomiance of tlie i11terpreted program by
`eliminating redundant processing steps, it is not concerned
`with optimizing the interpreted code, or providing only those
`code sections that are necessary for the task at hand. Further-
`more, the described invention is concerned only with server
`side programs, it has nothing to do with interpreted programs
`and scripts run on the client side, and it is unconcerned with
`minimizing download time by reducing the amount ofcode to
`be downloaded to and interpreted on the client.
`There exists, therefore a need iii the art for a method of
`deploying application code to a client in mi efficient and
`optimized manner. It would be highly desirable to reduce the
`amount of data to bc downloaded by optimizing code in such
`a way that only that code needed by a particular object, for
`example a web page, is supplied to tl1e client with tl1e object,
`so that download timc is minimized. Furthermore, it would bc
`desirable to cache the application code on the clie11t, so that
`the optimized code 11eed only be downloaded once, instead of
`every tin1e the object is requested from the server.
`
`SUMMARY OF THE INVENTION
`
`The invention provides a procedure for optimizing appli-
`cation code for deployment to a client over a data link,
`wherein only the code needed by a given object within said
`application is supplied to the clie11t with said object, so that
`download time is greatly minimized.
`In a preferred embodiment, the invention is directed to web
`applications, in which the application includes one or more
`web pages, based on HTML files. The HTML code may
`contain embedded blocks of code written in an interpreted
`scripting language such as JAVASCRIPT. Additionally. the
`HTML code may refer to separate import files of code, also
`written in a language such as JAVASCRIPT. The web pages
`may include onc or more functionalitics that depend on thc
`JAVASCRIPT code.
`Prior to deployment, tl1e application code, both tl1e HTML
`and tl1e JAVASCRIPT are scanned, using a suitable parsing
`tool. During parsing, code entry points, points in the code that
`call resources such as methods and functions, are identified.
`All available resources, in the HTML, and the JAVASCRIPT
`are identified, a11d a resource list, that includes a description
`
`Page 00006
`
`

`
`US 7,966,626 B2
`
`3
`of every resource available, is created. The call path at each
`entry point is followed and all resources required by the web
`page are identified. The required resources are extracted and
`concatenated into a new import file, after wl1icl1 the HTML
`code is updated to refer to the newly created file.
`During use, the newly created import file is downloaded to
`the client with the accompanying web page. The import file is
`cached on the client, eliminating the necessity of download-
`ing the import file more than once.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`FIG. 1 provides a diagram illustrating code dependencies
`iii a typical web application;
`FIG. 2 provides a top-level block diagram of a procedure
`for optimizing web application code for download to a client,
`according to the invention;
`FIG. 3 provides a block diagram of a sub-procedure for
`scanning application code from the procedure of FIG. 2,
`according to the invention;
`FIG. 4 provides a block diagram of a sub-proccdurc for
`identifying all resources called by a particular page from a
`web application, from the procedure ofFIG. 2, according to
`tl1c invcntion; and
`FIG. 5 provides a block diagram of a sub-procedure for
`providing a new import file containing only the application
`code needed by the web page of FIG. 4, according to the
`invention.
`
`DETAILED DESCRIPTION
`
`FIG. 1 provides a diagram illustrating code dependencies
`iii a page from a typical web application 10. In response to a
`client request, a file of HTML code 11 is transmitted to the
`client. Upon processing the HTML code, the client displays
`to the user a web page 12. As previously indicated, web pages
`may include various functionalities. They are given these
`functionalities by calling various resources, the resources
`consisting of code blocks that perform specific tasks. Gener-
`ally, resources may be functions, methods, procedures or
`sub-routines. Resources may be written either in a compiled
`language sucl1 as JAVA or C”, or they may be written in an
`intcrprctod scripting language such as JAVASCRIPT or
`VBSCRIPT. In its preferred embodiment, the invention is
`directed primarily to code written in these scripting lan-
`guages, which are supported by most web browsers. Code for
`the resources may exist as code blocks embedded in the
`HTML code (not shown) or the HTML may contain tags that
`refer 13 to an import file of code 14. As indicated inFIG. 1, the
`import file may be a file of JAVASCRIPT code. The example _
`page shown in FIG. 1 is a registration page i11 which the user
`enters information such as name, address, and e—mail address
`i11 text fields or text areas. The underlying HTML contains
`code for a text area 15a. Upon processing the code, the client,
`or web browser, displays a corresponding text area 15b,
`according to the specifications ofthe HTML code 1511. As in
`this example, HTML forms generally include some form of
`validation script to ensure that the user is entering the correct
`type of information in the form field in the correct format. In
`this case, the tcxt arca 15b is an address ficld and thc undcr-
`lying code 15a calls a function, ValidateAddress( ) 16 to
`validate data entered into tl1e field by tl1e user. The function
`ValidateAddress( ) is found iii the JAVASCRIPT import file
`FORM.]S referenced by the ITML file. The ValidateAdress(
`) function further calls a method, parse() 17, found in another
`JAVASCRIPT import file, STRINGJS, along with a number
`of other methods that are not needed by the web page.
`
`4
`Depending on the application, in order to obtain a few lines of
`code needed for a single web page, a client may need to
`download hundreds or even thousands of lines of code
`
`Due to tl1e nature ofweb applications, tl1e optimal solution
`is to deliver only that code which is explicitly needed by any
`given web page. This dramatically reduces the amount of
`code that needs to be deployed and, consequently, the amount
`oftii11e a web user spends waiting for a page to finish loading.
`The invention works by creating a dependency tree of the
`code that is required to implement the functionality needed on
`a certain web page. As FIG. 2 shows, the “root” oftl1is tree can
`be found by parsing the HTML 20 that is served 11p to the
`client to discover wl1icl1 resources are called by the page in
`response to various cvcnts. With these functions as cntry
`points, it is then determined which f11I1CtlO11S they, i11tum,
`call. This second set ofresources is i11 turn scanned, and so on
`until a complete set of all the required code is obtained 21.
`Once the set of required code is determined, that code is
`delivered to the client by concatenating all of the required
`resources into a new import file 22, which is served up to the
`client with the web page. The invented code optimization is
`typically implemented as a final development step prior to
`deployment of thc wcb application.
`— Code Scarming (20)
`Preferably, a code-parsing tool is used to automatically
`scan through tl1e application code to generate the set of
`required code. This has the advantage that it dynamically
`creates a dependency tree, or a list ofresources that is ordered
`according to code dependencies. Various parsing tools are
`suitable for the invention: for example, the RHINO JAVAS-
`CRIPT engine, provided by AOL-Netscape of Mountain
`View Calif., or scripts written in a language such as PERL.
`Any parsing tool that supports IO, collections, arrays and
`hash maps and that is capable of manipulating files would be
`suitable. Additionally, various notation systems can be used
`that allow developers to mark which resources (functions) a
`particular block of code requires as they are developing the
`code.
`
`As FIG. 3 shows, scarming the code first involves identi-
`fying entry points in the code 31. As described above, these
`cntry points consist of initial rcsourcc calls, primarily in thc
`HTML code. Entry points may include:
`HTML tags that incorporate JAVASCRIPT statements;
`Actions associated with various web page elements, such
`as forms; and
`DOM events (document object model) eve11ts. Typically,
`DOM events are found in JAVASCRIPT import files.
`Resource calls may be for functions, methods, procedures
`or sub-routines or any code block that performs a specific
`task. While the invention is described in relation to JAVAS—
`CRIPT, such description is exemplary only. In fact, the inven-
`tion is equally applicable to other interpreted scripting lan-
`guages such as VBSCRIPT.
`In addition to identifying entry points, the parsing tool also
`identifies blocks of JAVASCRIPT code embedded in the
`HTML 32 and identifies all import files 33 required by the
`web page.
`Idcntifying Rcquircd Rcsourccs (21)
`Having identified code entry points, embedded script
`blocks and import files, the parsing tool is used to identify all
`available resources 41 found in the HTML code, the en1bed—
`ded script code and the import files. As each resource is
`located, a resource information object is created for tl1e
`resource 42. The information object is a data object contain-
`ing a description of the resource, and may also include the
`
`Page 00007
`
`

`
`US 7,966,626 B2
`
`5
`code with which the resource is implemented. In the preferred
`embodiment of the invention the resource information object
`includes:
`resource name;
`methods called by the resource;
`optionally, the code implementing the resource;
`optionally, the source file for the resource;
`an ‘is-used’ field; and
`an ‘is-rcal’ ficld.
`Various data structures well known to those skilled in the
`art are suitable for the implementation of the resource in for-
`mation objcct. As indicated above, thc rcsourcc information
`object may include the actual code implementing the
`resource, or it may merely reference the source file wl1ere tl1e
`resource is to be found. Both the ‘is—used’ and the ‘is—real’
`fields are Boolean. The function of these two fields is
`explained in detail below. A resource list is created 43 by
`creating an array of all the resource information objects. The
`array is ordered according to the sequence in which the
`resource is encountered in the application code. While the
`array may be used as tl1e final resource list, in the preferred
`embodiment of the invention, a hash map of the array is
`provided as a lookup to optimize the resource list. In this hash
`map, keys consist of the resource names and values consist of
`ll1e corresponding resource information objects for the named
`rcsourccs. In addition to the actual rcsourccs, virtual func-
`tions may be created. Certain of the entry points may call
`r11ore than one resource, or they may have more than one
`associated action. At a later step of the procedure, the HTML
`code is updated to refer to the import file containing all ofthe
`required resources. For those entry points that call more than
`one function, or that l1ave more than one associated action, it
`is necessary to create a placeholder in the code. Thus, virtual
`functions are created that incorporate the actions or resource
`calls associated with that entry point. As previously indicated,
`the resource information object includes a Boolean ‘is-real’
`field. In information objects describing a virtual function, the
`‘is-real’ field is left unset. Thus, the ‘is-real’ field is used to
`distinguish between actual resources and virtual. First iden-
`tifying all available resources in this mamier provides an
`important optimization to the subsequent step of locating and
`extracting resources required by the web page.
`Following crcation of thc rcsourcc list, thc parsing tool
`steps through the call path at each previously identified entry
`point to identify those resources that are actually used by tl1e
`web page 44. It should be noted that the previously created
`resource list included all available resources, plus any virtual
`resources created. The current step identifies tho se resources
`from all resources that are actually used. As the resources are
`identified, the ‘is-used’ field ofthe corresponding information _
`object
`is set 45,
`thus indicating that the corresponding
`resource is one that is required by the web page. Each call path
`is followed until one of:
`a resource is encountered that doesn’t call any further
`resources;
`a resource is encountered that calls a system function;
`a resource is encountered that already has the ‘is-used’ field
`set.
`
`Write To New File (22)
`Once the rcquircd rcsourccs have been located and marked,
`they are written to a new import file. Those resources having
`the ‘is-used’ field set are extracted and concatenated i11to a
`new file 51. The resources must be ordered in the new file in
`a manner that preserves the original dependencies. In one
`embodiment of the invention, a dependency tree is created.
`However, since the information object for each resource
`refers to the resources called by that resource, this informa-
`
`6
`tion may be utilized to order the resources in a manner equiva-
`le11t to that of a dependency tree.
`Subsequently, the original HTML code is updated to refer
`to the new import file 52. Thus, a single, compact import file,
`incorporating only the application code required by the web
`page is downloaded with the page when it is requested 53. It
`is important to note that for any given page, this process
`generates a complete set of the code needed. The process of
`determining and dclivcring tl1c rcquircd codc can bc donc on
`a per-page-request basis, but in n1ost cases the code needed by
`a particular page remains constant. If this is the case, the
`process can bc optimized by caching thc rcquircd codc for
`each page at “build” time. For example, when installing a
`page that edits a presentation slide, tl1e build process could
`generate a corresponding script file dedicated to that page. An
`important advantage of caching the required code in this
`fashion is that it allows browser clients to cache the code
`using their built i11 caching mechanisms. Thus, when multiple
`requests for a page are made, the code only needs to be
`delivered the first time.
`The invention is embodied both as a procedure and as a
`computer program product embodied on a computer-usable
`medium that includes computer readable coda means for
`performing the procedure. The computer-usable medium
`may be a removable medium such as a diskette or a CD, or it
`may also bc a fixcd medium, such as a mass storage device or
`a memory.
`Although the invention has been described herein with
`reference to certain preferred embodiments, one skilled in the
`art will readily appreciate that other applications may be
`substituted without departing fro111tl1e spirit and scope of tlie
`present invention. Accordingly, the invention should only be
`limited by the Claims included below.
`
`The invention claimed is:
`1. A computer implemented method for execution on a
`server computer for preparing application code for deploy-
`ment to a client over a data link, wherein external code to be
`used by a web page is supplied to the client, the method
`40 comprising:
`automatically scamiing the web page to identify code
`external to the web page and referenced by the web page;
`extracting the idcntificd cxtcrnal codc rcfcrcnccd by the
`web page from at least one import file associated with
`tl1e web page, wherein tl1e at least one import file further
`includes code which is not referenced by the web page;
`concatenating the extracted external code into a new
`i111port file;
`modifying the web page to reference the concatenated
`external code contained in the new import file;
`receiving a request from the clie11t to access the web page;
`and
`transmitting the new import file and the modified web page
`to the client in response to the request from the client to
`access the web page.
`2. The method ofclaim 1, wherein:
`the application code comprises a web application that
`includes at least one functionality, and
`the web page comprises a file of hypertext markup lan-
`guagc (HTML) codc and at least one cmbcddcd codc
`block written in a scripting language.
`3. The method of claim 2, wherein the scripting language
`comprises any of JAVASCRIPT and VBSCRIPT.
`4. The method of claim 3, further comprising:
`scarming the HTML code of the web page;
`scarming the at least one embedded code block;
`scarming the at least one import file; and
`
`Page 00008
`
`

`
`US 7,966,626 B2
`
`7
`identifying one or more entry points included in at least one
`of the HTML code, the at least one embedded code
`block; and the at least one import file.
`5. The method of claim 4, wherein the identified one or
`more entry points comprise any of:
`HTML tags that incorporate JAVASCRIPT statements;
`actions associated with web page elements; and
`DOM (document object model) events.
`6. The method of claim 5, wherein the actions associated
`with web page elements include HTML form actions.
`7. The method of claim 2, wherein the external code is
`located in at least one of:
`
`the at least one embedded code block oftlie web page; and
`the at lcast onc import file.
`8. The method of claim 4, wherein automatically identify-
`ing the extemal code referenced by the web page comprises:
`identifying the at least one embedded code block and the at
`least one import file; identifying one or more resources
`referenced by the web page;
`creating a resource information object for at least one ofthe
`identified one or n1ore resources; and
`creating at
`least one list of the resource information
`objects.
`9. The method of claim 8; wherein the identified one or
`more rcsourccs comprise any of: functions; a virtual frmction;
`methods; sub-routines; and any code block that performs a
`specific task.
`10. The method of claim 9, wherein:
`the virtual frmction comprises a placeholder in the HTML
`code, wherein the virtual function comprises at least one
`of instructions and resources included in the at least one
`embedded code block; and
`a web page element invokes a plurality of the functions.
`11. The method of claim 1, comprising using an analysis
`tool incorporating one of:
`IO support; and
`support for collections, arrays, and hash maps.
`12. The method of claim 11; wherein the analysis tool
`comprises one of:
`a PERL script; and
`a JAVASCRIPT engine.
`13. A non-transitory computcr rcadablc storage medium
`storing a computer program product which, when executed
`by at least o11e processor, causes the processor to perform a
`method for preparing application code for deployment to a
`client over a data link; wherein external code to be used by a
`web page is supplied to the client, the method co111prisi11g:
`automatically scanning the web page to identify code
`external to the web page and referenced by the web page;
`extracting the identified external code referenced by the
`web page from at least one import file associated with
`the web page; wherein the at least one import file further
`includes code which is not referenced by the web page;
`co11cate11ating the extracted external code into a new
`import file;
`modifying the web page to reference the concatenated
`external code contained in the new import file;
`receiving a request fror11 the client to access the web page;
`and
`transmitting the new import file and the modified web page
`to the client in response to the request from the client to
`access the web page.
`14. The non-transitory computer readable storage medium
`of claim 13, wherein:
`the application code comprises a web application that
`includes at least one functionality; and
`
`8
`the web page comprises a file of hypertext markup lan-
`guage (HTML) code and at least one embedded code
`block written in a scripting la11guage.
`15. The non-transitory computer readable storage medium
`5 of claim 14; wherein the scripting language comprises any of
`JAVASCRIPT and VBSCRIPT.
`16. The non-transitory computer readable storage medium
`of claim 15;