-5.
`
`_L__,.
`2‘ O
`3 E :1
`'33 R. m
`E i
`&—i—
`g % -
`
`__ 3
`2? 5’
`
`“
`
`‘
`
`o2«<‘>7/DCE3
`
`PROVISIONAL APPLICATION
`
`.
`
`«
`
`,al//7/w/
`
`Attorney Docket NO.
`
`19909-5US
`
`“Express Mail” Label No.
`EL394876636US
`
`February 4 2000
`Date of Deposit:
`I hereby certify that this is being deposited With the United States
`Postal Service “Express Mail Post Office to Addressee” service
`under 37 CFR 1.10 on the date indicated above, addressed to:
`
`Box Provisional Patent Applicatio
`
`Washington, D.C. 20231 :5 §
`
`$5
`gig
`:3 Eg-
`“'\§\
`
`ASSISTANT COMMISSIONER FOR PATENTS
`BOX PROVISIONAL PATENT APPLICATION
`Washington, D.C. 20231
`.
`Sir:
`
`Transmitted herewith for filing is a provisional patent application under CFR 1.53(b)(2) of:
`
`RESIDENCE Ci
`MIDDLE INITIAL
`FIRST NAME
`LASTNAME
`_ San Francisco, California
`
`/State/Coun
`
`
`Title: OPTIMIZED DELIVERY OF WEB APPLICATION CODE
`
`
` closed are:
`] 3
`
`
`pages of the specification (including description and claims).
`
`:1:_lease charge Deposit Account No. 20-1430 as follows:
`S
`I X]
`Ffling fee
`[ X ]
`Any additional fees associated With this paper or during the pendency of this application.
`extra copies of this sheet are enclosed.
`
`2
`
`
`
`
`
`Customer No. 20350
`
`TOWNSEND and TOWNSEND and CREW LLP
`
`Respectfully submitted,
`
`TOWNSEND and TOWNSEND andCREWLLP %,:\/ Z
`
`/7/]
`
`TWO Embarcadero Center, 8”‘ Floor
`San Francisco, California 94111-3834
`Telephone: (415) 576-0200
`Fax: (415) 576-0300
`SF 1065347 V1
`
`Kevin T. LeMond
`Reg. No. 35,933
`Attorneys for Applicant
`
`Page 1 of 1
`
`
`
`Apple Exhibit 1030
`
`Apple v. Core Wireless
`IPR2015-01899
`
`Page 00001
`
`Apple Exhibit 1030
`Apple v. Core Wireless
`IPR2015-01899
`Page 00001
`
`

`
`PROVISIONAL
`
`PATENT APPLICATION
`
`OPTIMIZED DELIVERY OF WEB APPLICATION CODE
`
`InVentor(s):
`
`Assignee:
`
`Robert Kieffer
`San Francisco, California
`
`-
`iAmaze, Inc.
`655 Tennesse Street, Suite 205
`San Francisco, California 94107
`
`TOWNSEND and TOWNSEND and CREW LLP
`Two Embarcadero Center, Sm Floor
`San Francisco, California 94111-3834
`(415) 576-0200
`
`Page 00002
`
`

`
`PATENT
`
`l 9909- SUS
`
`OPTIMIZED DELIVERY OF WEB APPLICATION CODE
`
`BACKGROUND OF THE INVENTION
`
`In the world of web applications, developers face severe limitations when
`
`trying to deploy client—side functionality. In general, good development practice pushes
`developers toward the 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 in the dependencies (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
`applications where memory and bandwidth are secondary constraints, deploying such a
`rich and weighty system has been moderately straight-forward.
`Web applications, on the other hand, are strictly limited in the amount of
`code which can be delivered to the client. A web application is little more than a set of
`
`web pages that support different functionality. (For example, A Web presentation
`application may have one page for each of the following functions: viewing the users
`
`presentations, editing a presentation, and viewing a presentation.)
`Thus, there is a dramatic limitation when it comes to delivering the client
`
`side functionality. A traditional desktop application may take 30Mbytes of code to run
`(and this may be a conservative estimate). On a 56K modem line, this much information
`takes ~10 minutes to transfer to the client. It is unreasonable to expect your typical web
`
`user to wait this long for a page to load.
`
`This leads to the problem addressed by this invention — that of deploying
`
`code to the client in an efficient and optimized manner.
`
`Page 00003
`
`

`
`2
`
`SUMMARY OF THE INVENTION
`
`This invention is targeted primarily at code written in a scripting language
`supported by browsers. Similar problems have been addressed for compiled languages
`such as Java, but the solutions have been optimized for a different environment.
`Due to the nature of web applications, the 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 of
`
`time a web user spends waiting for a page to finish loading.
`The system works by creating a dependency tree of the code that is
`required to implement the functionality needed on a certain web page. The “root” of this
`tree can be found by parsing the HTML that is served up to the client to discover which
`functions will be invoked by the page in response to various events. With these functions
`as a starting point, it can then be determined which fimctions they, in turn, depend on.
`This second set of functions is in turn scanned, and so on until a complete set of all the
`
`required code is obtained.
`Once the set of required code is determined, that code is delivered to the
`
`client.
`
`Parsing
`Ideally, a code—parsing engine is used to automatically scan through the
`code to generate the set ofrequired code. This has the advantage that it dynamically
`
`builds the dependency tree.
`Failing this, a variety ofnotations can be used that allow developers to
`mark which resources (functions) a particular block of code requires as they are
`
`developing the code.
`
`Caching on a per-page basis
`It’s important to note that for any given page, this process generates a
`complete set of the code needed. The process of determining and delivering the required
`code can be done on a per-page—request basis, but in most cases the code needed by a
`particular page will remain constant. If this is the case, the process can be optimized by
`caching the required code for each page at “build” time. For example, when installing a
`page that edits a presentation slide, the build process could generate a corresponding
`
`script file dedicated to that page.
`
`Page 00004
`
`

`
`3
`
`One advantage of caching the required code in this fashion is that it allows
`
`browser clients to cache the code using their built in caching mechanisms. Thus, when
`multiple requests for a page are made, the code only needs to be delivered the first time.
`
`SF 1()6A416 v1
`
`Page 00005