U.S. patent application number 10/859766 was filed with the patent office on 2004-12-23 for system and method for reducing bandwidth requirements for remote applications by utilizing client processing power.
Invention is credited to Derechin, Jacob, Derechin, Luis.
Application Number | 20040258089 10/859766 |
Document ID | / |
Family ID | 32324374 |
Filed Date | 2004-12-23 |
United States Patent
Application |
20040258089 |
Kind Code |
A1 |
Derechin, Jacob ; et
al. |
December 23, 2004 |
System and method for reducing bandwidth requirements for remote
applications by utilizing client processing power
Abstract
A method, system and medium for reducing transmitted code for
remote application forms. In one embodiment, a client system
receives encoded information and performs pattern matching
substitutions to expand the encoded information into decoded
information for further processing. In one example these operations
are performed in a web browser. In one example, a pattern for the
pattern matching substitution is specified in a regular expression;
a script containing instructions executable in the web browser is
evaluated to generate the decode information. In one example, the
decoded information includes a script (e.g., a JavaScript) which
contains instructions for performing regular expression based
substitution or instructions for creating one or more objects in
the web browser. In one example, the pattern matching substitution
generates tags of a markup language so that the web browser can
render the decoded information for display. In one embodiment, a
server generates the encoded information in response to the request
from the web browser. In one embodiment, the first decoded
information is used to decode any further encoded information.
Inventors: |
Derechin, Jacob; (Potomac.,
MD) ; Derechin, Luis; (Potomac, MD) |
Correspondence
Address: |
BLAKELY SOKOLOFF TAYLOR & ZAFMAN
12400 WILSHIRE BOULEVARD
SEVENTH FLOOR
LOS ANGELES
CA
90025-1030
US
|
Family ID: |
32324374 |
Appl. No.: |
10/859766 |
Filed: |
June 2, 2004 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
10859766 |
Jun 2, 2004 |
|
|
|
10299260 |
Nov 18, 2002 |
|
|
|
Current U.S.
Class: |
370/465 ;
709/203; 709/246 |
Current CPC
Class: |
G06F 9/54 20130101 |
Class at
Publication: |
370/465 ;
709/246; 709/203 |
International
Class: |
G06F 015/16; H04J
003/22 |
Claims
What is claimed is:
1. A method for remote access, comprising: receiving encoded
information in a client Digital Processing System (DPS) from a
server DPS through a network connection; performing a pattern
matching substitution according to one or more specified patterns
of character strings to expand the encoded information into decoded
information; and processing the decoded information in the client
DPS.
2. The method of claim 1, wherein encoded information is received
in a web browser running on the client DPS and the decoded
information is processed in the web browser.
3. The method of claim 1, wherein a pattern for the pattern
matching substitution is specified using a regular expression.
4. The method of claim 3, wherein the regular expression matches
different strings of characters.
5. The method of claim 2, wherein the decoded information comprises
information in a markup language.
6. The method of claim 5, wherein the markup language is one of: a
HyperText Markup Language (HTML); and an Extensible Markup Language
(XML).
7. The method of claim 5, wherein the pattern matching substitution
generates one or more tags in the markup language.
8. The method of claim 7, wherein the pattern matching substitution
is according to a script evaluated in the web browser.
9. The method of claim 2, wherein the decoded information comprises
a script executable by the web browser.
10. The method of claim 9, wherein said processing the decoded
information comprises: executing the script to generate information
for processing in the web browser.
11. The method of claim 10, wherein when executed the script causes
the web browser to perform a pattern matching substitution to
expand information for processing in the web browser.
12. The method of claim 2, wherein the web browser receives from
the network a web page including the encoded information; the web
page causes the web browser to perform the pattern matching
substitution and to process the decoded information.
13. The method of claim 12, wherein the web page is in a markup
language.
14. The method of claim 12, wherein the web page rendered in the
web browser comprises a user interface for accessing a remote
application through the network.
15. The method of claim 12, wherein the web page is received in a
protocol of the Transmission Control Protocol/Internet Protocol
(TCP/IP) protocol family.
16. The method of claim 12, further comprising: retrieving a script
from the network, the script comprising instructions to perform the
pattern matching substitution.
17. The method of claim 16, wherein the web page causes the browser
to retrieve the script.
18. The method of claim 17, wherein the script is embedded in the
web page.
19. The method of claim 17, wherein the script is retrieved from a
different server DPS.
20. The method of claim 16, further comprising: retrieving
information specifying a set of substitutions to be performed on
the encoded information.
21. The method of claim 12, wherein at least one of said performing
and said processing comprises: calling a function with at least one
parameter, the function creating a set of objects for a user
interface, a value for the at least one parameter specifying a set
of features of the objects.
22. The method of claim 21, wherein instructions of the function
comprise a file separate from the web page; and the web page
specifies the value for the at least one parameter.
23. The method of claim 21, wherein at least one of said performing
and said processing calls the function a plurality of times.
24. The method of claim 23, wherein the function is called
recursively.
25. A method for providing remote access, comprising: transmitting
encoded information to a client Digital Processing System (DPS)
over a network, the encoded information being expandable in the
client DPS through a pattern matching substitution according to one
or more specified patterns of character strings into decoded
information for rendering in the client DPS.
26. The method of claim 25, wherein the decoded information is for
rendering in a web browser of the client DPS.
27. The method of claim 25, wherein the pattern matching
substitution is specified using a regular expression.
28. The method of claim 26, wherein the encoded information is
embedded in a web page.
29. The method of claim 28, wherein the web page is in a markup
language.
30. The method of claim 28, wherein the decoded information is in a
markup language.
31. The method of claim 28, wherein the decoded information
comprises a script including instructions executable in the web
browser to perform a pattern matching substitution to expand
information for processing in the web browser.
32. The method of claim 31, wherein the script comprises regular
expressions.
33. The method of claim 28, wherein the pattern matching
substitution generates one or more tags in a markup language.
34. The method of claim 26, further comprising: transmitting a
script file to the web browser, the script file containing
instructions to perform the pattern matching substitution.
35. The method of claim 34, further comprising: transmitting
information to the web browser to specify a set of regular
expression based substitutions.
36. The method of claim 26, further comprising: generating the
encoded information in response to a request from the web
browser.
37. The method of claim 36, wherein said generating the encoded
information comprises: retrieving information requested by the web
browser; converting at least a portion of the information requested
by the web browser into the encoded information; and combining a
script with the encoded information as a response to the web
browser.
38. The method of claim 37, wherein the response in a HyperText
Markup Language (HTML) is transmitted to the web browser in a
Hypertext Transfer Protocol (HTTP).
39. The method of claim 37, wherein said converting comprises:
performing a pattern matching substitution.
40. The method of claim 39, wherein said pattern matching
substitution is based on a regular expression.
41. The method of claim 37, further comprising: determining a set
of substitutions required to decode the encoded information;
wherein the response further includes information specifying the
set of substitutions.
42. The method of claim 28, wherein the encoded information is
expandable through calling a function with at least one parameter,
the function creating a set of objects for a user interface, a
value for the at least one parameter specifying a set of features
of the objects.
43. The method of claim 42, wherein instructions of the function
comprise a file separate from the web page; and the web page
specifies the value for the at least one parameter.
44. The method of claim 42, wherein the encoded information is
expandable through calling the function a plurality of times.
45. The method of claim 44, wherein the function is called
recursively.
46. A machine readable medium containing executable computer
program instructions which when executed by a data processing
system cause said system to perform a method for remote access, the
method comprising: performing a pattern matching substitution
according to one or more specified patterns of character strings to
expand encoded information into decoded information for rendering
in a client Digital Processing System (DPS).
47. The medium of claim 46, wherein the decoded information is for
rendering in a web browser running on the client DPS.
48. The medium of claim 46, wherein a pattern for the pattern
matching substitution is specified using a regular expression that
matches a plurality of different strings of characters.
49. The medium of claim 47, wherein the decoded information
comprises at least one of: information in a markup language; and a
script executable by the web browser.
50. The medium of claim 49, wherein the pattern matching
substitution generates at least one of: tags in the markup
language; and syntax in a scripting language.
51. The medium of claim 46, wherein the encoded information is
specified in a web page; and a location of a script file which
contains at least a portion of the computer program instructions is
specified in the web page.
52. The medium of claim 46, wherein the encoded information is
specified in a web page; and at least a portion of the computer
program instructions are embedded in the web page.
53. The medium of claim 52, wherein the web page further specifies
a set of substitutions to be performed on the encoded
information.
54. The medium of claim 51, wherein said performing comprises:
calling a function with at least one parameter, the function
creating a set of objects for a user interface, a value for the at
least one parameter specifying a set of features of the
objects.
55. The medium of claim 54, wherein instructions of the function
comprise a file separate from the web page; and the web page
specifies the value for the at least one parameter.
56. The medium of claim 54, wherein said performing calls the
function a plurality of times.
57. The medium of claim 56, wherein the function is called
recursively.
58. A machine readable medium containing executable computer
program instructions which when executed by a data processing
system cause said system to perform a method for providing remote
access, the method comprising: generating encoded information for
transmission to a client Digital Processing System (DPS) over a
network, the encoded information being expandable in the client DPS
through a pattern matching substitution based on specified patterns
of character strings into decoded information for rendering in the
client DPS.
59. The medium of claim 58, wherein the decoded information is for
rendering in a web browser in the client DPS.
60. The medium of claim 58, wherein the pattern matching
substitution is specified using a regular expression; and the
encoded information is to be embedded in a web page that is in a
markup language.
61. The medium of claim 60, wherein the decoded information is in
one of: a markup language; and a scripting language.
62. The medium of claim 60, wherein the pattern matching
substitution generates one or more tags in a markup language.
63. The medium of claim 60, wherein the method further comprises:
specifying a script file in the web page, the script file
containing instructions to perform the pattern matching
substitution.
64. The medium of claim 63, wherein the method further comprises:
specifying a set of regular expression based substitutions in the
web page.
65. The medium of claim 59, wherein the encoded information is
generated in response to a request from the web browser.
66. The medium of claim 65, wherein said generating the encoded
information comprises: retrieving information requested by the web
browser; converting at least a portion of the information requested
by the web browser into the encoded information; and combining a
script with the encoded information as a response to the web
browser.
67. The medium of claim 66, wherein said converting comprises:
performing regular expression based substitution.
68. The medium of claim 66, wherein the method further comprises:
determining a set of substitutions required to decode the encoded
information; wherein the response further includes information
specifying the set of substitutions.
69. The medium of claim 60, wherein the encoded information is
expandable through calling a function with at least one parameter,
the function creating a set of objects for a user interface, a
value for the at least one parameter specifying a set of features
of the objects.
70. The medium of claim 69, wherein instructions of the function
comprise a file separate from the web page; and the web page
specifies the value for the at least one parameter.
71. The medium of claim 69, wherein the encoded information is
expandable through calling the function a plurality of times.
72. The medium of claim 71, wherein the function is called
recursively.
73. A data processing system for remote access, the data processing
system comprising: a volatile memory; a persistent memory; a
communications interface; a processor coupled with the memory and
the communications interface, the communications interface to
receive encoded information from a network, the memory to store the
encoded information, the processor to expand the encoded
information into decoded information through pattern matching
substitution according to specified patterns of character strings,
and the processor to render the decoded information.
74. The data processing system of claim 73, wherein the processor
renders the decoded in a web browser.
75. The data processing system of claim 73, wherein a pattern for
the pattern matching substitution is specified using a regular
expression that matches different strings of characters.
76. The data processing system of claim 75, wherein the pattern
matching substitution generates one of: one or more tags in the
markup language; and syntax of a scripting language.
77. The data processing system of claim 73, wherein the
communications interface receives from the network a web page
including the encoded information; the web page causes the
processor to perform the pattern matching substitution and to
render the decoded information.
78. The data processing system of claim 77, wherein the processor
causes the communications interface to retrieve a script from the
network according to a location specified in the web page only if
the script file is not already in on the data processing system,
the script comprising instructions to perform the pattern matching
substitution.
79. The data processing system of claim 77, wherein the processor
performs a set of substitutions specified in the web page.
80. The data processing system of claim 77, wherein the processor
expands the encoded information through calling a function with at
least one parameter, the function creating a set of objects for a
user interface, a value for the at least one parameter specifying a
set of features of the objects.
81. The data processing system of claim 80, wherein instructions of
the function comprise a file separate from the web page; and the
web page specifies the value for the at least one parameter.
82. The data processing system of claim 80, wherein the processor
expands the encoded information through calling the function a
plurality of times.
83. The data processing system of claim 82, wherein the function is
called recursively.
84. A data processing system to provide remote access, the data
processing system comprising: a memory, the memory to store encoded
information, the encoded information being expandable in a web
browser according to specified patterns of character strings
through a pattern matching substitution into decoded information
for rendering in the web browser; a communications interface; a
processor coupled with the memory and the communications interface,
the processor to control the communications interface to transmit
encoded information to the web browser over a network.
85. The data processing system of claim 84, wherein the pattern
matching substitution is specified using a regular expression.
86. The data processing system of claim 84, wherein the processor
is further to generate the encoded information in response to a
request from the web browser.
87. The data processing system of claim 86, wherein to generate the
encoded information: the communications interface is to retrieve
information requested by the web browser; the processor is to
convert at least a portion of the information requested by the web
browser into the encoded information; and the processor is to
combine a script with the encoded information as a response to the
web browser.
88. The data processing system of claim 87, wherein the processor
is to further determine a set of substitutions required to decode
the encoded information; wherein the response further includes
information specifying the set of substitutions.
89. The data processing system of claim 84, wherein the encoded
information is expandable through calling a function with at least
one parameter, the function creating a set of objects for a user
interface, a value for the at least one parameter specifying a set
of features of the objects.
90. The data processing system of claim 89, wherein a web page
includes the encoded information; instructions of the function
comprise a file separate from the web page; and the web page
specifies the value for the at least one parameter.
91. The data processing system of claim 89, wherein the encoded
information is expandable through calling the function a plurality
of times.
92. The data processing system of claim 91, wherein the function is
called recursively.
93. A machine readable medium containing executable computer
program instructions which when executed by a data processing
system cause said system to perform a method, the method
comprising: performing a substitution based on a regular expression
to expand the first encoded information into first decoded
information; processing the first decoded information.
94. The medium of claim 93, wherein the method is performed in a
web browser running on said system.
95. The medium of claim 93, wherein the computer program
instructions comprise a script retrievable from a file at a
location specified in the web page.
96. The medium of claim 93, wherein the computer program
instructions comprise a script embedded in the web page.
97. The medium of claim 94, wherein the first decoded information
comprises a script; and said rendering the first decoded
information comprises: evaluating the script to generate a user
interface object in the web browser.
98. The medium of claim 93, wherein the first decoded information
comprises a script; the web page further contains second encoded
information; and said processing the first decoded information
comprises: evaluating the script to perform a substitution based on
a regular expression to expand the second encoded information into
second decoded information; and processing the second decoded
information.
99. The medium of claim 93, wherein the substitution converts the
first encoded information of the web page into the first decoded
information in a standard language.
100. The medium of claim 93, wherein at least one of said
performing and said processing comprises: calling a function with
at least one parameter, the function creating a set of objects for
a user interface, a value for the at least one parameter specifying
a set of features of the objects.
101. The medium of claim 100, wherein a web page comprises the
first encoded information; instructions of the function comprise a
file separate from the web page; and the web page specifies the
value for the at least one parameter.
102. The medium of claim 100, wherein at least one of said
performing and said processing calls the function a plurality of
times.
103. The medium of claim 102, wherein the function is called
recursively.
Description
[0001] This application is a Continuation-In-Part (CIP) of U.S.
patent application Ser. No. 10/299,260, entitled "A System and
Method for Reducing Bandwidth Requirements for Remote Applications
by Utilizing Client Processing Power", filed Nov. 18, 2002 by Jacob
Derechin and Luis Derechin.
FIELD
[0002] Embodiments of the invention relate generally to the field
of remote applications, and more specifically to a system and
method to reduce the transmitted data for such applications.
BACKGROUND
[0003] The Internet has become a backbone of communication with a
vast repository of information available in various formats. Many
companies are developing various applications for use on the
Internet to facilitate real-time decision-making processes (e.g.,
transactional applications). In general these remote applications
encompass any bi-directional or unidirectional access of remote
data.
[0004] The full potential of the Internet for such purposes remains
unfulfilled due to problems with its performance and reliability.
One of the Internet's performance limitations in particular is the
bandwidth problem. Modern remote applications require the
transmission of a great deal of information at a high rate. When
such applications are used over low-bandwidth data transmission
media, such as typical telephone lines, the applications may not
function properly and/or may result in lengthy wait times. This
problem is also evident in high-bandwidth environments supporting
many users (i.e., having a low bandwidth-to-user ratio). For
purposes of this disclosure, the term "low bandwidth will refer to
actual low bandwidth or a low bandwidth/user ratio. Bottlenecks may
be caused by a low bandwidth/user connection, the infrastructure of
the Internet Service Provider (ISP), the gateway to the Internet
backbone, or the content provider's Web server and/or application
server. Eliminating these problems may be prohibitively expensive
or impractical. For example, not only is increasing bandwidth
expensive, but it may not be practically possible in some areas
that lack the infrastructure to do so.
[0005] The increasing bandwidth requirements are due to the
increasing complexity of the data transmitted and to how the
Internet exchanges information. The Internet may typically use
hypertext mark-up language (HTML) and its related formats such as
extensible mark-up language (XML), dynamic HTML (DHTML). The
Internet also may use Hyper Text Transfer Protocol (HTTP), File
Transfer Protocol (FTP), and other associated Transmission Control
Protocol/Internet Protocol (TCP/IP) based communications
protocols.
[0006] HTML defines the syntax and placement of special, embedded,
directions that instruct a web browser on how to display the
contents of a document which is made up of one or more HTML text
files or associated media files, or other embedded files of any
number of formats including text, images, and other support media.
HTML instructs a web browser client application on how to make a
document interactive through special hypertext links or through
embedded programs like Java applets, which connect a document with
other documents, as well as with other Internet resources. In
addition, embedded programs can and often do contain their own
interactive logic in the form of executable code and the associated
resources.
[0007] A server digital processing system (server DPS) typically
runs a web server and/or application server program to make
documents, typically hypertext documents in the HTML language,
available. Web servers and/or application servers typically have a
standard interface for running external programs, such as Common
Gateway Interface (CGI), Java servlets, Java server pages (JSPs)
and Active server pages (ASPs) or other server-side solutions. Such
programs handle incoming information requests and return the
appropriate document or generate a document dynamically. For
example, a gateway might receive queries, determine a response, and
translate the response into a page of HTML so that the server DPS
can send the result to a client digital processing system (client
DPS). The client DPS typically runs a web browser (a program to
allow retrieval and display of information from the server DPS).
Server-side technologies such as JSP and ASP employ scripting
engines or Java that process commands written in a scripting
language or Java.
[0008] The web server and/or application server and the web browser
communicate using HTTP. In HTTP, the web browser establishes a
connection to a web server and/or application server and sends an
HTTP request message to the server DPS. In response, the web server
and/or application server checks for authorization, performs any
requested action and returns an HTTP response message containing an
HTML document resulting from the requested action, or an error
message. The web server and/or application server then retrieves
the document and returns it in an HTTP response message to the Web
browser.
[0009] The client DPS may petition the server DPS for access to an
application document, for example a transactional application form.
The client DPS's petition causes the entire form to be constructed
on the server DPS. The form is then packaged and transmitted to the
client DPS. Typically the client DPS receives the HTML code and
parses and renders the form at the client DPS.
[0010] FIG. 1 illustrates a process in which a client DPS requests
and receives a remote application form from a server DPS in
accordance with the prior art. Process 100, shown in FIG. 1, begins
at operation 105 in which the client DPS requests access to a
remote application form. The request (petition) may be made, from
the client DPS to the server DPS, in a variety of ways including
via Internet, Intranet, Extranet, local area networks (LANs), wide
area networks (WANs), as well as others, and combinations thereof.
For convenience the data transmission path between the client DPS
and sever DPS is referred to as the "cloud". The transmission of
the petition through the cloud is limited by available bandwidth.
Because the petition is typically only a small amount of data, this
bottleneck may not cause significant delay.
[0011] At operation 110 the server DPS receives the petition. The
petition is received by the web server/application server of the
server DPS.
[0012] At operation 115 the server DPS determines whether the
petition is for a standard interface file (for purposes of this
illustration a JSP file). If the petition is a JSP file, at
operation 116, the server performs a JSP processing operation. The
JSP file is retrieved and passed to the servlet engine. If the JSP
has not been previously instantiated, the servlet engine parses the
JSP file and generates servlet source code. The servlet engine then
compiles the source code and instantiates the servlet. At operation
117 the servlet then outputs standard HTML code.
[0013] If at operation 115 the petition is not a JSP file, the
server DPS obtains the HTML code from the virtual directory at
operation 118.
[0014] At operation 120 the HTML code (from the JSP servlet or from
the virtual directory) is transmitted from the server DPS, through
the cloud, to the client DPS. This HTML code is fairly heavy and
may cause lengthy delay in the transmission especially for low
bandwidth/user environments.
[0015] At operation 125 the client DPS receives the HTML code. The
HTML code is received at the client DPS browser and may be buffered
prior to being parsed and rendered. This buffering adds to the
delay in presenting the remote application form.
[0016] At operation 130, after all of the transmitted code has been
parsed and rendered, the remote application form presentation is
complete on the client DPS.
[0017] Due to how HTML is structured, much of the code transmitted
in such a scheme is related to the formatting structure of the
document. This amounts to a tremendous amount of transmitted data
that does not provide user-specific benefit. This situation has
been addressed in several ways with varying degrees of success. For
example, to avoid transmitting a document to the client DPS each
time, terminal servers emulate a screen at the client DPS. This
opens a client session on the server DPS where the application is
actually running on the server DPS and only screen emulations are
transmitted to the client DPS. That is, none of the presentation
code or logic of a typical web-page transmission is included. The
client DPS has an application emulator and is transmitting only
interaction with the form (i.e., typed input and/or mouse
movement). With terminal servers, various algorithms are used to
reduce the required data transmission. Terminal servers allow for
reduced processing power on the client DPS, but processing
requirements are dramatically increased on the server DPS. Such
schemes do not provide significant relief for very low
bandwidth/user media such as typical (analog) telephone lines and
have numerous other drawbacks. One such drawback is that the
initial setup may require data transmission on the order of several
megabytes (MB) which is installed at the client DPS as a plug-in,
an object, or directly to the client DPS hard disk (i.e., not to
the browser cache). This installation is, therefore, across a
secure barrier. Such installation requires explicit user
permission, alters the configuration of the client DPS, and
produces a possibility of conflict and the perception of
vulnerability to corruption. Additionally, terminal servers are
system specific. That is, because an installation on the client DPS
is required, terminal servers are not system independent. Moreover,
where a user lacks administrative rights to be able to install the
initial components or the terminal server cannot pass through
firewalls or proxies, the terminal server may be rendered
unusable.
[0018] Another attempt to reduce the amount of required data
transmission in transactional application forms are installation
schemes that create an environment on the client DPS to alter
interaction with the server DPS. An example of such is the Java
Virtual Machine (JVM), which is a self-contained operating
environment to run Java applets. The idea behind the JVM is to
install an environment on the client DPS that is operating system
and browser independent. This has the potential of being able to
reduce data transmission, because it may reduce the need to
continually transmit document-structuring code.
[0019] However, JVM also has the drawbacks of the terminal server
in that an initial installation is required. For JVM this may be as
large as 14.52 MB because JVM requires objects and extra classes.
JVM not only installs its overall environment, but each application
requires its own specific environment (i.e., requests additional
classes from the server). Because more data has to be accessed, the
applications are sluggish. Moreover, JVM requires substantially
more client DPS processing power. JVM may work well for small,
specifically focused, applications but, in general, JVM still
requires so much code that it does not significantly reduce the
amount of required data transmission for transactional application
forms.
[0020] Another example of the excessive amount of data transmitted
via the cloud for remote application forms is the submission and
data validation process. Many remote applications require that user
input data be validated by the server DPS. Typically the user must
submit the completed form and the server DPS must receive the
completed form prior to attempting to validate specific inputs. If
there was an error in completing the form, the entire page creation
process must be employed to recreate the page adding values to
fields and error messages where appropriate. If no error is
detected in the user input data, the server DPS creates a page
containing the validated information. This page is then transmitted
to the client DPS via the cloud, for user verification. If the user
submits the form with verification, the corresponding database
process and other tasks may proceed. If the user is unable to
verify the data, the page creation process must be employed as
described above. This process not only requires a substantial
amount of data transmission via the cloud, but also results in
significant wait-time as pages are transmitted and/or recreated due
to erroneous input.
[0021] Another disadvantage of typical remote applications is that
they are typically poorly presented. This "look and feel" or user
friendliness aspect is related to the fact that typical remote
applications operate in batch mode and cannot interact with the
server in real time. Typically the forms are quite long, causing
the user to have to scroll, and provide no feedback from the server
until the form is complete. Typical remote applications cannot
operate in "chatty" mode as the continual process of closing,
transmitting, and reopening the page would cause a delayed and
disconcerted presentation.
[0022] What is needed is an effective system and method for
reducing data transmissions between the client DPS and the server
DPS via the cloud. Such data transmissions may include the
transmission of data files or a collection of data files, including
the transmission of text, audio, media, embedded programs,
executable code, or other data that is published at a host server
DPS. Such a system should reduce data transmission during accessing
and presentation of remote application forms as well as for
submission and data validation.
[0023] Preferably such a system should not require installation on
the client DPS (i.e., would employ zero-install technology) and
should not modify the secure side of the client DPS. Such a system
should also pass through proxies and firewalls. Moreover, such a
system should provide a user-friendly interaction (e.g., graphical
user interface and "chatty mode") for remote applications.
[0024] The need for such a system is most apparent where client DPS
is accessing moderate to high-bandwidth data applications via low
bandwidth/user media, though such a system should augment any
bandwidth capacity.
SUMMARY
[0025] Embodiments of the present invention provide methods and
systems for reducing transmitted code for remote application forms.
Some of the embodiments of the present invention are summarized in
this section.
[0026] In one embodiment of the present invention, first code to
link one or more functions to a remote application is received at a
client digital processing system (DPS). Each function contains
instruction code to generate object construction code and a set of
object parameters. The object construction code is used to create a
corresponding object. The one or more functions are linked to the
remote application form. Second code is received to call one or
more of the functions. One or more of the functions is called to
construct one or more objects at the client DPS. The constructed
one or more objects is presented as part of the remote application
form based upon the object parameters.
[0027] In one embodiment of the present invention, a client data
processing system receives encoded information and performs a
pattern matching substitution according to one or more specified
patterns of character strings to expand the encoded information
into decoded information for rendering, interpreting or executing
in a web browser. In one example of an embodiment, a pattern for
the pattern matching substitution is specified using a regular
expression; a script containing instructions executable in the web
browser is evaluated to generate the decode information. In one
example of an embodiment, the decoded information includes a script
(e.g., JavaScript) which contains instructions for performing
regular expression based substitution or instructions for creating
one or more objects in the web browser. In one example of an
embodiment, the pattern matching substitution generates one or more
tags of a markup language so that the web browser can render the
decoded information for display. In one example of an embodiment,
the encoded information is embedded in a web page in a markup
language, such as a HyperText Markup Language (HTML) or an
Extensible Markup Language (XML); the web page causes the web
browser to download a script to perform the pattern matching
substitution if the script is not already downloaded
(alternatively, the script is embedded in the web page). In one
example of an embodiment, the script can perform a number of
regular expression based substitutions; and the web page includes
information specifying a portion of the substitutions for decoding
the encoded information. In one example of an embodiment, the web
page rendered in the web browser includes a user interface for
accessing a remote application on a server data processing system.
In one embodiment of the present invention, a server generates the
encoded information in response to the request from the web
browser. For example, the server retrieves the information
requested by the web browser, converts the information into encoded
information (e.g., through regular expression based substitution)
and combines the encoded information with a script as a response to
the web browser. In one example, the server determines a set of
substitutions required to decode the encoded information and
transmits information specifying the set of substitutions to the
web browser.
[0028] Other features and advantages of embodiments of the present
invention will be apparent from the accompanying drawings, and from
the detailed description, that follows below.
BRIEF DESCRIPTION OF THE DRAWINGS
[0029] The invention may be best understood by referring to the
following description and accompanying drawings that are used to
illustrate embodiments of the invention. In the drawings:
[0030] FIG. 1 illustrates a process in which a client DPS requests
and receives a remote application form from a server DPS in
accordance with the prior art;
[0031] FIG. 2 illustrates a network of digital processing systems
(DPS) in which reduced data transmission enabled applications may
be transmitted, received, and processed in accordance with one
embodiment of the invention;
[0032] FIG. 3 is an architectural overview diagram for a system in
accordance with one embodiment of the invention;
[0033] FIG. 4 is a process flow diagram illustrating a process in
which a client DPS accesses and presents a reduced data
transmission enabled remote application in accordance with an
embodiment of the invention;
[0034] FIG. 5 is a process flow diagram illustrating a process in
which user input data is validated against a server DPS database in
accordance with one embodiment of the invention;
[0035] FIG. 6 is a process flow diagram illustrating a process in
which a remote application form is refreshed in accordance with one
embodiment of the invention;
[0036] FIG. 7 is a process flow diagram illustrating a process in
which user data input type validation and field completion
validation are accomplished on the client DPS in accordance with
one embodiment of the invention;
[0037] FIG. 8 illustrates an embodiment of a digital processing
system that may be used for the server DPS or client DPSs, in
accordance with an embodiment of the invention;
[0038] FIG. 9 illustrates an example of using regular expression
based substitution to expand information in a web browser according
to one embodiment of the present invention;
[0039] FIG. 10 illustrates a system to provide remote access
according to one embodiment of the present invention;
[0040] FIG. 11 illustrates a system to reduce bandwidth
requirements according to one embodiment of the present
invention;
[0041] FIG. 12 is a process flow diagram illustrating a process of
encoding web information to reduce communication bandwidth
requirements according to one embodiment of the present
invention;
[0042] FIG. 13 is a detailed process flow diagram illustrating a
process of dynamically encoding web information to reduce the size
of transmitted data according to one embodiment of the present
invention;
[0043] FIG. 14 is a process flow diagram illustrating a process of
decoding web information that is encoded to reduce communication
bandwidth requirements according to one embodiment of the present
invention;
[0044] FIG. 15 is a detailed process flow diagram illustrating a
process of decoding web information that is encoded to reduce the
size of transmitted data according to one embodiment of the present
invention;
[0045] FIG. 16 is a process flow diagram illustrating a detailed
process in which a client DPS accesses and presents a reduced data
transmission enabled remote application in accordance with an
embodiment of the invention.
DETAILED DESCRIPTION
[0046] Overview
[0047] An embodiment of the present invention significantly reduces
the amount of required code transmitted between the server DPS and
the client DPS for a remote transactional application form while
maintaining complete and additional functionality. Though specific
examples are described, for the purposes of delimiting the breadth
of the invention, the term form refers generally to any combination
of objects created for use on a remote application. For one
embodiment this is accomplished with reduced data transmission to
the client. For one embodiment, after a client DPS accesses a
remote application form, the server DPS transmits a core library,
consisting of a number of functions, to the client DPS. The core
library is stored on the browser cache of the client DPS. The core
library includes a set of functions referred to as a generic
mini-assembler (GMA). The GMA is used to construct generic (e.g.,
commonly used) objects on the client DPS. That is, code within the
initial transmission calls the functions of the GMA to produce the
HTML code to construct the generic objects. This production of the
HTML code and the construction of the objects takes place on the
client instead of the server DPS. The objects are portions of the
transactional application form and may be various fields of
information to be exchanged including text, text area, check boxes,
etc. For one embodiment, when the document is created, the program
logic of the standard interface program requests additional objects
required by the particular application, and requests the functions
necessary to construct these objects from the server DPS. The
function required to construct such objects are referred to as
specific mini-assemblers (SMAs).
[0048] One embodiment of the present invention decodes or
decompresses information through regular expression based
substitution. Many browser programs (e.g., Netscape Navigator or
Internet Explorer) provide a secure scripting capability (e.g.,
JavaScript). Regular expression based substitutions can be
performed using the scripting compatibility of the web browsers.
One embodiment of the invention uses pattern matching substitutions
to expand encoded web page information, which is encoded to reduce
the size of the web page for fast transmission over a network
connection (e.g., a dialup connection to Internet). Through pattern
matching substitution, the encoded web page can be converted into a
format in a markup language, such as a HyperText Markup Language
(HTML) or an Extensible Markup Language (XML) so that the web
browser can render the decoded information for display. Since
regular expression based scripts for substitution can be evaluated
very efficiently in a web browser, the processing power of the
client computer is efficiently used. Since the encoding reduces the
size of data transmission, the transmission time is greatly
reduced. Alternative embodiments are also discussed.
[0049] It is an intended advantage of one embodiment of the
invention to reduce the amount of transmitted data for remote
applications. It is another intended advantage of one embodiment of
the invention to provide fully functional transactional
applications over relatively low bandwidth/user media. It is
another intended advantage of one embodiment of the invention to
accomplish a majority of the remote application form processing at
the client DPS thereby liberating server DPS processing resources.
It is another intended advantage of one embodiment of the invention
to provide transactional application forms with greatly reduced
initial download and no installation on the client (i.e., to employ
zero-install technology). It is another intended advantage of one
embodiment of the invention to provide access to remote
applications without modifying the secure side of the client DPS.
It is another intended advantage of one embodiment of the invention
to provide a user-friendly interaction for remote applications. It
is another intended advantage of one embodiment of the invention to
provide functions to the client DPS for the construction of
application objects on the client DPS. It is further intended
advantage of one embodiment of the invention to initially provide
only those functions necessary to construct generic objects,
provide validation and provide a user-friendly interaction for
remote applications.
[0050] In the following description, numerous specific details are
set forth. However, it is understood that embodiments of the
invention may be practiced without these specific details. In other
instances, well-known circuits, structures and techniques have not
been shown in detail in order not to obscure the understanding of
this description.
[0051] Reference throughout the specification to "one embodiment"
or "an embodiment" means that a particular feature, structure, or
characteristic described in connection with the embodiment is
included in at least one embodiment of the present invention. Thus,
the appearance of the phrases "in one embodiment" or "in an
embodiment" in various places throughout the specification are not
necessarily all referring to the same embodiment. Furthermore, the
particular features, structures, or characteristics may be combined
in any suitable manner in one or more embodiments.
[0052] System
[0053] FIG. 2 illustrates a network of digital processing systems
(DPS) in which reduced data transmission enabled (RDTE)
applications may be transmitted, received, and processed in
accordance with one embodiment of the invention. The network of
DPSs 200 includes a plurality of client DPSs, shown as client DPSs
205a-205d, coupled to one or more server DPSs, shown as server DPS
220. The server DPS 220 and client DPSs 205a-205d are configured to
communicate a plurality of various data files. For example, server
DPS 220 has stored upon it a reduced data transmission application
221 for access by a client DPS in accordance with an embodiment of
the invention. The data files may pertain to transactional
application forms or may be any combination of a number of
different types of files including, for example, video, audio,
graphics, text, multi-media or the like. For example, the data
files may be audio/video files, such as programs with moving images
and sound. Data may be communicated between the server DPS and the
client DPSs through any type of communications network through
which a plurality of different devices may communicate such as, for
example, but not limited to, the Internet, a wide area network
(WAN) not shown, or a local area network (LAN), an intranet, or the
like. For example, as shown in FIG. 2, client DPSs 205a and 205d
are coupled to the server 220 through LAN 211, while client DPSs
205b and 205c are coupled to the server 220 through Internet 210
which is a network of networks having a method of communicating
data as described above and well known to those skilled in the art.
The communication links coupling the server DPS to client DPSs need
not be a direct link, but may be indirect links including but not
limited to broadcasted wireless signals, network communications or
the like.
[0054] An embodiment of a digital processing system that may be
used for the server DPS 220, or client DPSs 205a-205d, in
accordance with an embodiment of the invention is described below
in reference to FIG. 8.
[0055] FIG. 3 is an architectural overview diagram for a system in
accordance with one embodiment of the invention. The exemplary
system 300, shown in FIG. 3, is shown as a Java-centric environment
(e.g., Java 2 Plafform Enterprise Edition (J2EE)), this is for
illustrative purposes only and the invention should not be
construed as limited to such.
[0056] System 300 includes exemplary embodiments of a server tier
301, a back end 302, and a client tier 303, as further described
below.
[0057] Server tier 301 includes an application development
environment, for example, J2EE web container 310. Web container 310
includes HTML code 311 and RDTE remote application HTML code 311a;
servlets 312 and RDTE servlets 312a; JSPs 313 and RDTE JSPs 313a;
and CGIs 314 and RDTE CGIs 314a. Web container 310 also includes
RDTE remote application core library 315 and other functions 316,
discussed below.
[0058] Server tier 301 also includes an application program 320 for
running various components 321, setup through the component
architecture (e.g., Enterprise Java Beans) that stores platform
logic. These components may provide, among others, memory
management and security functions. The application program 320 may
include an inter-computer messaging API 322 that allows the
creation, management, and communication of various data files, as
well as a database access API 323 (e.g., Java DataBase
Connectivity) to provide the application with database access.
[0059] Server tier 301 also includes a web/application server 330
that provides the RDTE remote application pages to the client tier
302 and handles the application operations between the server tier
301 and the backend 302.
[0060] Backend 302, which provides database management functions,
among others, includes various database environments 340a-340d for
responding to user queries.
[0061] Client tier 303 includes a client DPS web browser 350 that
includes HTML parsing and rendering software 351, scripting
functions 352, and browser cache 353. Stored on the browser cache
353 is core library 360, which is a library of functions used to
create the most common objects of an application page. This library
is transmitted from the server DPS to the client DPS upon initial
access of a remote application in accordance with one embodiment of
the invention. The core library 360 includes a GMA 361, validation
functions 362, pacemaker functions 363, deltalyzers functions 364,
user interface functions 365, and other functions and objects 366
(e.g., date functions, array functions, etc.). For one embodiment,
the core library is approximately 15 kilobytes and is capable of
constructing many of the most commonly used HTML objects. Appendix
A, attached hereto, includes exemplary functions for constructing
an input text object or an input password object in accordance with
one embodiment of the invention. For one embodiment such functions
are contained in the GMA.
[0062] Other functions, that are not part of the core library, may
be initially transmitted by the server DPS to the client DPS and
stored on the browser cache. For example, as shown in FIG. 3, SMAs
370a-370c are stored on the browser cache 360. Browser cache 360
also includes an alpha mini-assembler (AMA) 375, which is a
form-specific function that may include calls to the GMA or SMAs.
Because SMAs and AMAs are not part of the core library, they are
only transmitted if the programming language includes a call to
them.
[0063] Because all of the functions of the RDTE remote application
are stored on the client DPS cache browser, the invention avoids
the disadvantages of client-side installation.
[0064] The various functions of the core library as well as SMAs
and AMAs are discussed in greater detail below.
[0065] Generic Mini-Assembler
[0066] The generic mini-assemblers (GMAs), which are part of the
core library, are code libraries that provide small functions,
which in conjunction with parameters, that allow the client DPS to
assemble the HTML code for commonly used objects (e.g., text, text
area, check boxes, etc.). For one embodiment, the GMA parameters
generate the necessary HTML code for most of the necessary objects
for the particular page. This reduces the amount of transmitted
data because the server no longer has to transmit all of the HTML
code for each object. The GMA also adds validation attributes
(e.g., data types, required fields, etc.) that are used for a
validation process discussed further below. This process takes
place within the same environment that runs on the client, thus
eliminating the need for installing a new environment on the
client. Additionally, or alternatively, the GMA may contain
instructions for communicating directly with the document object
module (DOM) to create objects on the client without generating the
HTML code. In such a case the server calls a function, which is
defined in the GMA, to create a particular object.
[0067] In one embodiment of the present invention, the generation
of HTML code is done through pattern matching substitution within
the GMA functions in the client DPS. The patterns to be substituted
could be defined inside GMA functions or they can be provided
especially for a specific web page or pages. In one embodiment, the
HTML codes that do not match with the patterns are unmodified, so
it brings a total flexibility to the solution. In one embodiment of
the present invention, the pattern matching substitution is made
through Regular Expressions.
[0068] Specific Mini-Assemblers
[0069] The GMA is designed to contain only the functions needed to
create the most commonly used objects, and therefore, the GMA may
not contain parameters to generate the HTML code to produce some
objects that are required for a particular form. This may be
because the object is simply not used frequently enough to be
included in the GMA. That is, in order to transmit as little data
as possible, the GMA must only encompass the most elemental
objects. For such less commonly used generic objects, a call to a
specific mini-assembler (SMA) may be included in the RDTE remote
application code by the programmer and transmitted from the server
DPS to the client DPS upon access of the form by the user. The SMAs
are specific to a generic object, but one that is not used
frequently enough to be included in the GMA. For example, the
parameters for generating a calendar may be designated an SMA
(i.e., not included in the GMA) because a calendar is not always
needed. In one embodiment the SMA for creating a calendar is
approximately four kilobytes.
[0070] The client DPS will request an SMA only if the programmer
has included a call to the particular SMA in the programming logic
(e.g., in the JSP), that is, if the programmer has determined that
the SMA is required for the particular form. After receiving the
GMA, the client DPS determines what objects are required when the
form is created and then petitions the server for the required
SMAs. This helps to keep the size of the core library to a minimum
and reduces the amount of transmitted data.
[0071] Alpha Mini-Assemblers
[0072] Alpha mini-assemblers (AMA) have the static portion of a
specific form. The function in an AMA may include a calling to a
function in the GMA (generic object) or a calling to a function in
an SMA (specific object). For example, the function of an AMA may
include a calling to a text element or to a calendar, if this was
required for a specific form. The system of the invention is
capable of working on many different environments (e.g., JSP, ASP,
etc.). Therefore, there would have to be an environment-specific
document such as a JSP or an ASP document on the server DPS that
contains programming logic to use a specific AMA for a particular
form. The AMAs may be created manually or through use of an
integrated programming environment (i.e., integrated development
environment (IDE)). Deltalyzer functions, discussed below, allow
for the insertion of values into the static objects of the AMA.
[0073] The function in an AMA can have parameters. They could allow
the insertion of values into the objects of the AMA, but also could
allow to change the set of objects or the objects' attributes (and
even both) the AMA is going to force the client DPS to process. For
instance, an AMA could decide from the value of a set of parameters
to make the browser render some HTML objects instead of other set
of HTML objects and vice versa.
[0074] At least some of the AMAs are reusable within other AMAs.
The function in an AMA may include calls to a number of AMA
functions. It could also call them once or a variable number of
times and with a variable set of parameters. There is no
restriction regarding the time when these calls can be made; in
this sense, the function is idempotent (acting as if used only
once, even if used multiple times). The call could be made before
or after processing the code, page or program where the AMA is
going to be used and the result is the same in both cases. For
instance, the call from an AMA or any other piece of code to an AMA
function could be made before or after a web page has loaded and it
forces the browser to render always the same objects, given the
same parameters, independently of the load status of the web
page.
[0075] Deltalyzers
[0076] An additional mechanism may be employed to further reduce
required data transmission known as deltalyzing the form. An AMA
for a form, containing all of the static portions of the form, is
created. Once such an AMA for a particular form has been called and
is resident on the client DPS, the static portions of the form may
be accessed from the client DPS browser cache so that there is no
need for the server DPS to retransmit this data. Upon subsequent
use of the particular form, the server DPS transmits only the
dynamic data that interacts with the particular AMA. This
combination of the AMA containing the static portion of a form and
the dynamic information that interacts with the AMA is called a
deltalyzer. The deltalyzers may likewise be created manually or
through use of an IDE.
[0077] The concept of the deltalyzers is to reduce data
transmission by sending only the dynamic portion of an interactive
form where the static portion has already been transmitted and is
available on the client DPS. The dynamic structure may include, for
example, specific names, telephone numbers, dates, and other
instance-specific information, while the static structure includes
the objects and fields where this information is placed within the
form. For example, the first time a user accesses a particular
transactional form, the server may transmit an AMA for that form
that is cached on the client DPS. The server then transmits the
dynamic information that interacts with the particular AMA. The
next time the user calls the same form, the client DPS obtains the
static portion from the browser cache and petitions the server DPS
for only the dynamic portion of the particular form. Therefore,
there would have to be an environment-specific document on the
server DPS that contains the logic to build a specific AMA for a
particular form.
[0078] Process
[0079] FIG. 4 is a process flow diagram illustrating a process in
which a client DPS accesses and presents a RDTE remote application
in accordance with an embodiment of the invention. In an
alternative embodiment, an initial operation of receiving the core
library at the client DPS may be included. Process 400, shown in
FIG. 4, begins at operation 405 in which a client DPS requests a
RDTE remote application form from the server DPS. For example, the
client may request a particular transactional application form.
[0080] At operation 410, the server DPS transmits the RDTE code for
the requested form via the cloud to the client DPS. Because this
code will call upon the functions of the core library and
applicable SMAs and AMAs, the amount of code transmitted is
significantly smaller than typical prior art schemes. The code is
transmitted via the cloud through the available bandwidth, but, due
to its reduced size, it is transmitted faster and with less
restriction. As the initially transmitted code is received, it is
buffered at the client DPS web browser.
[0081] At operation 415, the client DPS web browser begins parsing
and rendering the code from the buffer. The initial code contains a
request to link the core library to the form. At this point, if the
core library had not already been stored in the browser cache of
the client DPS, the browser would request it from the server DPS.
The core library is included as part of the buffer at the point
where the call to the core library was made. If the form contains
SMAs, the initial code contains a request to link the particular
SMAs to the form, and the process described above in reference to
linking the core library is repeated. Likewise, if the form is
deltalyzed, the initial code contains a request to link the
applicable AMA to the form and the linking process is repeated.
[0082] At operation 420, the browser continues parsing and
rendering the code and determines if the instruction being parsed
contains a call to a mini-assembler function (e.g., an alpha
mini-assembler). If so, the function is called and depending on the
parameters it has received, the function creates the corresponding
object construction code (e.g., HTML code) on the client DPS.
(Instructions which do not call a mini-assembler function are
processed by the browser in typical fashion at operation 421.)
[0083] At operation 425, the code created by the mini-assembler
(e.g., the alpha mini-assembler) is registered as part of the form.
That is, HTML code corresponding to the called functions is now
included as part of the requested remote application form. In one
embodiment, an alpha mini-assembler calls other alpha
mini-assembler; thus, the alpha mini-assembler that is called is
executed to generate code. The generated code is then again
included as part of the remote application form. Such a process of
calling mini-assemblers can be performed recursively or iteratively
for a number of iterations, as illustrated in operations 1607,
1611, 1613 and 1615 of FIG. 16.
[0084] At operation 430, if there is more code in the buffer, it is
parsed and rendered as described above until all of the transmitted
code has been received and processed.
[0085] At operation 435, the requested form is presented on the
client DPS and the user can access and use the requested form
within the browser environment of the client DPS.
[0086] As a result of the process described above in reference to
FIG. 4 a majority of the remote application form processing is
accomplished at the client DPS thereby liberating server DPS
processing resources.
[0087] Additional Processes
[0088] Through the use of mini-assemblers and client side
validation processes (CSVPs) discussed below, the data transmission
requirements are substantially reduced. For some transactional
forms, the reduction may be as high as 80-90% compared with prior
art schemes. The amount of transmitted data may be reduced even
further for some applications by providing a mechanism through
which the client DPS may communicate with the server DPS during the
transaction (e.g., while completing a transactional application
form). Basically, this ability allows a user to transfer an
application from batch mode to "chatty" mode. For one embodiment,
this functionality is effected through the use of "pacemakers"
(PMs).
[0089] Pacemakers
[0090] HTML frames allow programmers to present documents in
multiple views (e.g., independent windows or subwindows). The
inline frame element (Iframe) allows a programmer to insert an HTML
document within another. For one embodiment, the system of the
invention uses PMs to implement hidden Iframes that provide
alternative communication paths that allow a remote application to
operate in "chatty" mode rather than batch mode. The PM petitions
the GMA to create a new Iframe which can then be used to petition
the server DPS and receive a response, after which the new Iframe
may be erased from the DOM. These interactions may be
time-triggered (triggered at a specific time or duration),
user-triggered, or specific action-triggered. In one embodiment, to
accommodate synchronous interactions, a petition queue is created
so that petitions that have not been responded to by the server DPS
will not be discarded upon receipt of a subsequent petition. This
allows the client DPS to interact with stored data through the
server DPS more efficiently.
[0091] For one embodiment of the invention, the mini-assemblers may
insert one or more PMs within the code of an RDTE remote
application form. The PMs are embedded in various ways depending on
the form and the purpose for the data exchange. For example, PMs
may be embedded variously to effect a real-time database validation
process, a reduced data transmission refresh process, and emulate a
normal client DPS saving process, among others. The use of PMs
allows seamless intervention with the server DPS providing improved
user-interaction. That is, because PMs allow only the data to be
refreshed, the disconcerting effect of prior art data validation
schemes caused by the form closing and reopening, is
eliminated.
[0092] Database Validation Process
[0093] As noted above, PMs may be used to validate that user input
data is contained within a back end database. Upon user input of
data to a particular field of, for example, a transactional form,
the PM causes the entered data to be sent to the server with a
request to the application server to query the database and make
sure the data entered is correct. Only the data contained in the
specified field is transmitted from the client DPS to the server
DPS (i.e., not the entire page as in typical prior art schemes).
The data is sent to the server upon entry (i.e., during the
transaction).
[0094] FIG. 5 is a process flow diagram illustrating a process in
which user input data is validated via the server DPS through a
backend database in accordance with one embodiment of the
invention. Process 500, shown in FIG. 5, begins with operation 505
in which a user at a client DPS enters user-input data requiring
database validation to a data input field of a RDTE remote
application form that has already been accessed by the user and
presented on a client DPS. For example, this data could be customer
identification data (CID) associated with a particular customer
name. The database validation confirms, for the user, that the CID
entered corresponds to the desired customer.
[0095] At operation 510, when the user leaves the data input field,
an "onchange" trigger is activated. For one embodiment, the
onchange trigger is inserted into the code by the mini-assembler
that created the field. The onchange trigger activates a
corresponding database validation PM that transmits the user input
data (e.g., CID) through the cloud to the server DPS.
[0096] At operation 515, the server DPS receives the petition. The
petition is received by the web server/application server of the
server DPS. If the petition is for a standard interface file, for
example, a JSP file, the server DPS retrieves the JSP file from the
virtual directory. The JSP file is retrieved and passed to the
servlet engine. If the JSP has not been previously instantiated,
the servlet engine parses the JSP file and generates servlet source
code. The servlet engine then compiles the source code and
instantiates the servlet.
[0097] At operation 520, the database (e.g., a customer name
database) is queried using the data input by the user (e.g.,
CID).
[0098] If, at operation 520, the query does not return valid
corresponding data (e.g., a customer name) based upon the user
input data, then, at operation 525, the server DPS transmits a
small amount of code to the client DPS in reply, via a PM,
indicating this. For example, the code may indicate that the CID
input by the user does not correspond to a customer name. For one
embodiment the code may activate a pop-up window displaying the
non-corresponding information.
[0099] At operation 526, the focus is reset to the data input field
and the data is selected.
[0100] If, at operation 520, the query does return a valid data
(e.g., customer name), then, at operation 530, the server DPS
transmits a small amount of code to the client DPS in reply, via a
PM, containing the valid data (e.g., customer name).
[0101] At operation 535, the client DPS web browser receives the
reply and provides the queried database data to the user for
validation. For one embodiment the code may activate a pop-up
window displaying the corresponding information. For example, the
customer name corresponding to the entered CID is entered into a
corresponding consult field so that the user can validate that it
is the desired customer.
[0102] Refresh Process
[0103] For one embodiment, the system of the invention provides the
ability for implementing a remote application form refresh process
that reduces the amount of transmitted data. A PM is used to
transmit a timestamp and session identification to the server DPS
that indicates the last time the form was refreshed. The server DPS
then transmits only the code necessary to call on the
mini-assembler to construct the objects subsequent to the
transmitted timestamp. If there are no new objects (i.e.,
subsequent to the time stamp), the server transmits a message to
this effect. In this way, the client DPS does not repetition the
entire form upon a refresh, thus substantially reducing the amount
of data transmission versus prior art refresh processes.
[0104] FIG. 6 is a process flow diagram illustrating a process in
which a RDTE remote application form is refreshed in accordance
with one embodiment of the invention. Process 600, shown in FIG. 6,
begins with operation 605 in which a user initiates a refresh
process for a RDTE remote application form that has already been
accessed by the user and presented on a client DPS. For example,
the user may be accessing an electronic mail form and may be
initiating a refresh process to determine if there is new e-mail.
The refresh process initiation uses a pacemaker to transmit the
refresh request to the server DPS. The refresh request includes a
session identification and a time stamp indicating the time of a
last refresh process (i.e., since the last time the data was
validated as current).
[0105] At operation 610, the database is queried using the user
identification and time stamp to determine if there is refresh data
for the particular user as of the transmitted time stamp.
[0106] At operation 615, if there is no refresh data (e.g., no new
e-mail), the server DPS transmits code to provide a message to the
client DPS to this effect. For one embodiment, the code transmitted
by the server DPS activates a pop-up window on the client DPS
informing the user that there is no new e-mail.
[0107] At operation 620, if there is refresh data, the server DPS
transmits only a small amount of code, which includes the refresh
data (e.g., new e-mail messages). The code activates a
mini-assembler causing the refresh data to be added to the existing
form (e.g., new e-mail messages are added to the in-box).
[0108] The use of PMs to validate data significantly reduces the
amount of transmitted data and reduces the wait time upon form
submittal over the prior art because the user input data has
already been validated by the time the form is submitted. PMs
provide another avenue for reducing the processing performed by the
server DPS.
[0109] Data Type and Field Completion Validation Process
[0110] The various mini-assemblers may effect data transmission
reduction processes, via object attributes (e.g., data type or
required field attributes), by incorporating triggers into the
objects. Such triggers may be used to effect client-side user input
data type and required field completion validation and to provide a
reduced data transmission refresh process as described below. For
one embodiment, the system of the invention provides the ability
for implementing a reduced data transmission validation process by
including attributes to the objects as opposed to including the
entire validation script as in prior art schemes. The validation
process allows a user to verify that user-input data is valid and
required fields are complete prior to transmission of the form to
the server DPS. For one embodiment, the validation process
validates user data input during form completion and validates
required field completion on form submittal. Implementing such a
validation process avoids the excessive data transmission of prior
art schemes, which can amount to 2-3 times the amount of data
transmissions for remote applications without data validation.
[0111] FIG. 7 is a process flow diagram illustrating a process in
which user data input type validation and field completion
validation are accomplished on the client DPS in accordance with
one embodiment of the invention. Process 700, shown in FIG. 7,
begins with operation 705 in which a user at a client DPS enters
user-input data to a data input field of a RDTE remote application
form that has already been accessed by the user and presented on a
client DPS.
[0112] At operation 710, when the user leaves the data input field,
an "onchange" trigger is activated. For one embodiment, the
onchange trigger is inserted into the code by the mini-assembler
that created the field. The onchange trigger activates a data type
validation function contained in the RDTE core library.
[0113] At operation 715, the validation functions compare the type
of the user-input data entered into the data input field with a
valid data type as defined by a RDTE data-type attribute. For one
embodiment, the data-type attribute is inserted into the code by
the mini-assembler that created the field.
[0114] At operation 716, if the data type of the user-input data
does not match the data type defined by the data type attribute,
the code provides an indicator that the user-input data type is
incorrect. The focus is then returned to the data input field and
the data selected. For one embodiment, the invalid data indicator
is implemented as pop-up window on the client DPS.
[0115] At operation 717, if the data type of the user-input data
matches the data type defined by the data type attribute, the focus
is sent to the next data input field, if any, and the process of
data type validation is repeated iteratively, as necessary, for all
data input fields.
[0116] At operation 720, after the last data input field has been
validated, the user submits the form. The submittal activates an on
Submit trigger that activates a required field completion
validation process contained in the RDTE core library. For one
embodiment, the on Submit trigger is inserted into the code by the
mini-assembler that created the RDTE remote application form.
[0117] At operation 725, the required field validation process
begins with the first data input field of the RDTE remote
application form and determines if the field requires data input.
For one embodiment, this determination is made by reference to a
required field attribute inserted into the HTML object when the
object was created by the mini-assembler.
[0118] At operation 726, if the field is not required, the process
continues with the next data input field.
[0119] At operation 730, if the field is required, the required
field validation process determines if the field has been filled
in. The required field completion validation process is contained
in the core library. If the required field has not been filled in,
the submit process is cancelled and the code provides an indicator
that a required field has not been filled in. For one embodiment,
an incomplete required field indicator is implemented as pop-up
window on the client DPS.
[0120] At operation 731, the focus is then set to the required
field that was not filled in. This process of determining required
fields and whether or not they have been filled in is repeated
until all required fields are completed.
[0121] At operation 732, if the required data input field is
complete, a determination is made if there are other fields to
validate.
[0122] At operation 735, the RDTE remote application form is
submitted from the client DPS to the server DPS via the cloud.
Because the data has been validated for user-input data type and
required field completion, the submittal process will not have to
be repeated as is typical in prior art systems.
[0123] General Matters
[0124] Embodiments of the invention may be applied to reduce the
amount of required data transmitted between the server DPS and the
client DPS for a remote application while maintaining complete
functionality. For one embodiment, when a client DPS accesses a
remote application, the server DPS transmits a core library of
functions, a set of which, known as GMAs, are then used to
construct generic objects on the client DPS instead of the server
DPS. The functions contain information on the physical
characteristics of the objects as well as metadata regarding the
data type of object to be constructed. For one embodiment, the core
library and various other mini-assemblers are stored on the cache
browser of the client DPS. Because there is no installation, the
method of such an embodiment avoids breaching client DPS security
and is not system specific.
[0125] Moreover, as shown in FIG. 3, the core library also includes
user interface functions. These functions allow remote application
forms to be presented in a much more user-friendly format than
typical prior art schemes. For example, prior art schemes may
require up to 40 lines of code to open a presentation object (e.g.,
a window). This restricts a programmer's ability to provide a user
friendly look and feel for remote applications. The system and
method of the invention provides greater flexibility in this area.
The user interface functions contain a small amount of code that is
used to call various HTML presentation objects. This allows a
programmer to include a user-friendly "look and feel" without
adding significantly to the amount of transmitted data.
[0126] The system and method in accordance with various embodiments
of the invention provides dramatic bandwidth reduction for
user-interactive remote applications, but is not limited to such
and may be generally applied to any remote data access.
[0127] FIG. 8 illustrates an embodiment of a digital processing
system that may be used for the server DPS 220, or client DPSs
205a-205d, in accordance with an embodiment of the invention. For
alternative embodiments of the present invention, processing system
801 may be a computer or a set top box that includes a processor
803 coupled to a bus 807. In one embodiment, memory 805, storage
811, display controller 809, communications interface 813, and
input/output controller 815 are also coupled to bus 807.
[0128] Processing system 801 interfaces to external systems through
communications interface 813. Communications interface 813 may
include an analog modem, Integrated Services Digital Network (ISDN)
modem, cable modem, Digital Subscriber Line (DSL) modem, a T-1 line
interface, a T-3 line interface, an optical carrier interface (e.g.
OC-3), token ring interface, satellite transmission interface, a
wireless interface or other interfaces for coupling a device to
other devices. Communications interface 813 may also include a
radio transceiver or wireless telephone signals, or the like.
[0129] For one embodiment of the present invention, communication
signal 825 is received/transmitted between communications interface
813 and the cloud 830. In one embodiment of the present invention,
a communication signal 825 may be used to interface processing
system 801 with another computer system, a network hub, router or
the like. In one embodiment of the present invention, communication
signal 825 is considered to be machine readable media, which may be
transmitted through wires, cables, optical fibers or through the
atmosphere, or the like.
[0130] In one embodiment of the present invention, processor 803
may be a conventional microprocessor, such as, for example, but not
limited to, an Intel x86 or Pentium family microprocessor, a
Motorola family microprocessor, or the like. Memory 805 may be a
machine-readable medium such as dynamic random access memory (DRAM)
and may include static random access memory (SRAM). Display
controller 809 controls in a conventional manner a display 819,
which in one embodiment of the invention may be a cathode ray tube
(CRT), a liquid crystal display (LCD), an active matrix display, a
television monitor or the like. The input/output device 817 coupled
to input/output controller 815 may be a keyboard, disk drive,
printer, scanner and other input and output devices, including a
mouse, trackball, trackpad, or the like.
[0131] Storage 811 may include machine-readable media such as, for
example, but not limited to, a magnetic hard disk, a floppy disk,
an optical disk, a smart card or another form of storage for data.
In one embodiment of the present invention, storage 811 may include
removable media, read-only media, readable/writable media or the
like. Some of the data may be written by a direct memory access
process into memory 805 during execution of software in computer
system 801. It is appreciated that software may reside in storage
811, memory 805 or may be transmitted or received via modem or
communications interface 813. For the purposes of the
specification, the term "machine readable medium" shall be taken to
include any medium that is capable of storing data, information or
encoding a sequence of instructions for execution by processor 803
to cause processor 803 to perform the methodologies of the present
invention. The term "machine readable medium" shall be taken to
include, but is not limited to solid-state memories, optical and
magnetic disks, carrier wave signals, and the like.
[0132] The invention includes various operations. The operations of
the invention may be performed by hardware components or may be
embodied in machine-executable instructions as described above.
Alternatively, the steps may be performed by a combination of
hardware and software. The invention may be provided as a computer
program product that may include a machine-readable medium having
stored thereon instructions, which may be used to program a
computer (or other electronic devices) to perform a process
according to the invention as described above.
[0133] Pattern Matching Based Substitution
[0134] FIG. 9 illustrates an example of using regular expression
based substitution to expand information in a client DPS (e.g. in a
web browser) according to one embodiment of the present invention.
In one embodiment of the present invention, a program (e.g., a
script) uses pattern matching substitutions to convert an encoded
information (e.g., a portion of encoded web page) into a code or
document (e.g., a portion of a decoded web page, such as a segment
of an HTML document, a portion of a JavaScript code) in a standard
language (e.g., HTML or XML). A regular expression can be used to
describe a pattern of characters (e.g., alphanumerical characters
or special symbols). A regular expression can be used to specify
how a computer program should look for a specified pattern of
character strings in text or code and then how to process the
matched strings (or substrings of matched strings). For example, in
FIG. 9, the following regular expression matches the pattern of a
character "s" followed by at least one digit.
s(.backslash.d+)
[0135] In the above example of a regular expression, the pair of
parentheses marks a substring of characters so that the substring
can be referred to as $1. For example, in FIG. 9, a command (e.g.,
901) can be used to replace the string that matches the regular
expression s(.backslash.d+) with the following expression:
size="$1"
[0136] When the command 901 is applied to the encoded web page A
(903), the string 907 (s2) matches the regular expression; and the
string 907 (s2) is replaced with the string 917 (size="2") to
generate the decoded web page A (913). The encoded web page B (905)
has a different string 909 (s12) that matches the regular
expression; and the string 909 (s12) is replaced with the string
919 (size="12") to generate decoded web page B (915). Thus, the
regular expression can match a number of different character
strings; and different strings of the same pattern specified in the
regular expression can be processed using the same string
replacement scheme (e.g., 901).
[0137] Regular expression and string replacement based on regular
expressions are supported in many scripting languages, such as PERL
(Practical Extraction and Report Language), TCL (Tool Command
Language), and JavaScript. In a scripting language (e.g., PERL, TCL
or JavaScript), the computer program for performing the regular
expression matching based on a given regular expression is
typically highly optimized and implemented natively on the target
computer platform. Thus, the execution of a regular expression
command using a scripting language is very efficient. Further, the
ability of a regular expression to match a pattern of different
strings allows one to program a string replacement scheme using a
very compact script. Thus, one embodiment of the present invention
encodes information for the display of a web page in a format
suitable for regular expression based string replacement and uses
scripts to perform regular expression based string replacement to
expand encoded information for execution and rendering in a web
browser. An encoded portion can be a portion of the HTML document,
a portion of the scripts for the generation of a portion of the
HTML document, a portion of the scripts for the processing of user
interaction, or a portion of the scripts that perform other regular
expression based substitutions.
[0138] JavaScript can be safely executed in a web browser (e.g.,
Netscape Navigator or Internet Explorer) without security concerns.
A script written in JavaScript can be directly embedded in an HTML
document (e.g., within the tags <SCRIPT> and </SCRIPT>)
or loaded according to a location specified in the HTML document
(e.g., specified as the value of the SRC attribute of the
<SCRIPT> tag). When the source location of the script is
specified, the web browser can download and cache the script file
to avoid repeated downloading. Thus, a same script file can be
using with different web pages without repeated downloading.
[0139] A regular expression can be used to match one and only one
string of characters. When such simple regular expressions are
used, a set of predefined character strings can be mapped into
another set of character strings. Such a lookup table approach can
be used to encode and decode information for a web browser to
reduce the bandwidth requirements for remote access. A substring
match and replacement scheme can also be used to provide such a
lookup table approach. For example, a portion of an HTML document
typically uses only a subset of the eight-bit symbols (characters).
Many symbols are typically not used in an HTML documents. Some of
the symbols can be used to represent the tags of the markup
language. For example, a symbol with a hexadecimal code x9A (=154)
may be used to represent the following character string.
[0140] <TABLE
[0141] Thus, when the above character string is replaced with the
symbol x9A, the size of the encoded information is much smaller
than the non-encoded information. After the symbol x9A is replaced
with the above character string, the tags in the HTML document are
generated for the web browser.
[0142] Similarly, another symbol, such as x9B (=155) can be used to
represent the following character string.
[0143] </TABLE
[0144] When such a lookup table approach is used, different script
commands are required to convert symbols x9A and x9B back to
corresponding tags for the HTML document. Alternatively, to further
improve encoding efficiency and reduce the length of the script
code for decoding the information, one embodiment of the present
invention uses a regular expression that can match different
strings of characters. For example, "<TABLE" can be encoded as
x9A and "</TABLE" as /x9A; a regular expression (e.g.,
(/)*.backslash.x9A) can be used to convert x9A and /x9A back to
"<TABLE" and "</TABLE" respectively.
[0145] Similarly, a regular expression (e.g., <(/)*TABLE) can be
used to map both "<TABLE" and "</TABLE" to x9A and /x9A
respectively.
[0146] In one implementation of an embodiment, a piece of
JavaScript code is specified in an HTML document (e.g., directly
embedded in the HTML document between tags <SCRIPT> and
</SCRIPT>, or stored in a separate file stored at a source
location that is specified as the value of the attribute SRC of a
<SCRIPT> tag). A portion of the web page is encoded and
provided as one or more parameters of the script command (or as the
arguments of a function call) so that, when the script command is
evaluated, regular expression based substitution is performed on
the encoded information to generate the portion of the web page so
that the web browser can render it for display. In one embodiment
of the present invention, the encoded information further includes
scripts (e.g., JavaScript or scripts in other languages), which is
then further evaluated by the web browser after being decoded. In
one embodiment of the present invention, the decoded information
contains further scripts for performing regular expression based
substitution.
[0147] In one embodiment of the present invention, a generic
JavaScript file can perform a set of regular expression based
substitutions. An HTML document includes information (e.g.,
specified as the value of a parameter of a piece of JavaScript
code) to indicate a subset of substitutions to be performed on the
encoded information so that the JavaScript performs only the subset
of substitutions. Thus, the script engine does not have to try to
perform the substitutions for the string patterns that do not exist
in the encoded information (or do not represent encoded patterns).
This allows a generic script program to be used for a number of
different encoded information with great efficiency and
flexibility. The web browser avoids downloading scripts
individually for individual encoded information to reduce the
communication bandwidth requirements; and, the client computer does
not evaluate the regular expression based substitutions that are
not required.
[0148] For example, in one embodiment of the present invention, the
patterns in the encoded information include at least one special
character; and a set of special characters can be used to specify a
subset of substitutions to be performed on the given encoded
information. Alternatively, a set of regular expression based
replacement rules may be directly specified. For example, when a
special pattern of character strings is used repeatedly in a web
page, a custom regular expression based substitution rule can be
specified for the web page.
[0149] In one embodiment of the present invention, a portion of a
JavaScript program is encoded and specified as parameters of
another JavaScript program, which when executed causes the portion
of the encoded JavaScript program to be decoded (e.g., using
regular expression based substitution) and loaded into the memory
of the web browser. Thus, at least a portion of the JavaScript code
in a JavaScript file can be encoded to reduce communication
bandwidth requirements.
[0150] FIG. 10 illustrates a system to provide remote access
according to one embodiment of the present invention. In one
embodiment of the present invention, a server data processing
system (1001) includes a web server (1009) which is capable of
communication with a browser (1005) of a remote client data
processing system (1003) in a Hyper Text Transfer Protocol (HTTP)
over a communication link (1041), such as the Internet, an
intranet, a wireless network, a local area network, etc. Other
communication protocols, such as a File Transfer Protocol (FTP),
may be used alternatively or in combination. A browser program
(1005) maintains a browser file cache 1007, which is typically on
the non-volatile memory system (e.g., a file system on a hard
drive, storage 811 in FIG. 8) on the client (1003). The browser
1005 (e.g., Netscape Navigator or Internet Explorer), when
executed, uses the client DPS RAM (1031) to operate with the files
previously cached. Typically, the information in the RAM (1031) is
lost when the browser program is stopped. When the browser (1005)
decodes information to generate a script program (e.g., based on
regular expression substitution), the script program may be cached
in the volatile RAM (e.g., memory 805 in FIG. 8). When a script
file is downloaded from the server, the script file is at least
cached in the non-volatile cache. In one embodiment of the present
invention, script commands that are not specific to a particular
web page are organized into one or more script files so that the
script files are downloaded and cached in the non-volatile cache.
For example, the HTML template for generating a portion of a user
interface (e.g., an input form) may be encoded as a parameter.
Thus, the template is downloaded as the script file only once. When
the function is evaluated with other parameters specific to a
particular web page, these parameters are placed into the HTML
template (e.g., through regular expression based substitution). The
script files may include encoded information, which can be decoded
into script commands (e.g., through regular expression based
substitution). Script commands that are specific to a particular
web page are embedded in the web page with corresponding parameters
(e.g., information specifying the subset of substitutions to be
performed). Alternatively, these commands can also be organized in
files (e.g., in temporary files). The evaluation of the scripts
generates web information, which may include decoded scripts and
displayable information (e.g., a data input form in HTML or a
result presentation page in HTML). The script interpreter (1035)
executes the scripts; and the rendering engine (1033) generates
display in one or more browser windows to present the decoded web
information.
[0151] In one embodiment of the present invention, a web page
displayed in the browser (1005) includes a user interface for
remote access the server (1001). For example, a web page represents
a Graphical User Interface (GUI) to remote application programs
(e.g., 1019) running on the server 1001. Note that the application
programs may run on the same data processing system as the web
server (1009) or on a different data processing system. The web
server and the application programs are configured to cooperate
with each other (e.g., within the same computer, or among a set of
computers over a network) to provide web pages to the browser
(e.g., 1005). The server (1001) maintains mini-assemblers (1011)
(e.g., in JavaScript) for the creation and manipulation of objects
(e.g., a spread sheet, a data input form, a result report form) in
the web browser of the client, as described in detail above. The
locations of the files for the mini-assemblers used in a specific
web page can be specified (e.g., as the value of the SRC attribute
of the <SCRIPT> tag) so that the files are downloaded if
there are not already cached in the browser file cache.
[0152] In one embodiment of the present invention, a number of
mini-assemblers are encoded as encoded assemblers (1013). The
encoded assemblers are decoded in a web browser when a pattern
substitution script (e.g., 1015) is executed. After the encoded
assemblers are decoded and evaluated in the web browser, these
encoded assemblers are loaded into the script interpreter (e.g.,
1035) so that these assemblers can be used to construct the
corresponding objects. Similarly, encoded substitution scripts can
be decoded and loaded into the script interpreter through the
execution of a pattern substitution script. Further, the server can
maintain web pages with encoded contents (e.g., 1021). An encoded
portion can be specified as the value of a parameter accessible to
a script or an argument to a call to a function defined in a script
for pattern substitution. When evaluated, the pattern substitution
script decodes the encoded information through regular expression
based substitution to generate the web information in a standard
markup language (e.g., HTML). Note that different scripts can be
used to decode encoded mini-assemblers, substitution scripts and
web page contents.
[0153] In one embodiment of the present invention, the encoded
information is further compressed through a traditional compression
scheme (e.g., using the compression program 1023), which can be
decompressed using a corresponding traditional decompressing scheme
before it is decoded through regular expression based substitution
(e.g., using a JavaScript code).
[0154] In one embodiment of the present invention, at least a
portion of the encoded assemblers (1013), encoded substitution
scripts (1017) and the web page with encoded contents (1021) is
manually coded to achieve more savings in the data transmition for
use with smaller and efficient regular expression based decoding
scripts. Alternatively, in one embodiment of the present invention,
some of the encoded information (e.g., a script, a static web page,
or a web page template) is automatically encoded (e.g., through
regular expression based substitution). The encoding operation may
be performed in real time (dynamically, on-the-fly, in response to
the request from a client computer) according to the preferences of
the remote client. For example, a client may prefer to trade
processing power to reduce communication bandwidth requirements, in
which case the server will transmit the encoded information with
scripts for decoding to the browser of the client so that the
amount of the data being transmitted (e.g., over a dialup
connection) is reduced; alternatively, the client may not wish to
trade processing power to reduce communication bandwidth
requirements, in which the server will transmit the no-encoded
information so that the client system does not have to perform the
decoding operation.
[0155] FIG. 11 illustrates a system to reduce bandwidth
requirements according to one embodiment of the present invention.
In one embodiment of the present invention, a proxy server (1101)
is used to encode information for the client computers (e.g.,
1121-1129) so that the communication bandwidth requirements for the
client computers to access server computers (e.g., 1111-1119) can
be significantly reduced. For example, in FIG. 11, clients
1121-1129 may access servers 1111-1119 directly through the network
1103 (e.g., Internet, intranet, local area network, wireless
network). The servers provide contents using a traditional approach
(e.g., without encoding). To reduce the bandwidth requirement for
the client computers (e.g., 1121-1129) and thus the time users have
to wait before a communication transaction is completed; one
embodiment of the present invention uses a proxy server (1101) to
encode the information provided by the servers to the clients. For
example, when client a (1121) requests for a web page (e.g., a home
page of a web site, a user interface page of an remote application,
etc.), the proxy server (1101) retrieves the page from the
corresponding server on behalf of the client. The proxy server
(1101) then encodes the web page using the pattern encoding program
(1105) so that the encoded page can be decoded using the pattern
substitution script (1103). The client downloads the pattern
substitution script if it is not already downloaded. The client
downloads the encoded page, which contains calls to the pattern
substitution script to decode the encoded content. When decoded,
the web page can be rendered in the browser of the client computer
as if it is directly downloaded from the web server.
[0156] FIG. 11 illustrates a specific network configuration for
using a proxy server according to one embodiment of the present
invention. Different network configurations can also be used. For
example, one or more servers (e.g., 1117-1119) may be behind a
firewall and an encoding server so that the clients can access
these servers only through the encoding server. Alternatively, an
encoding server may be used as an access point to provide access to
services (e.g., remote applications) on other server computers. The
encoding server (e.g., by the proxy server) encodes the web
information automatically in real time so that there is no need to
modify other servers to reduce the bandwidth requirement of the
client computers. For example, client computers (e.g., 1121-1129)
may be connected to the Internet with dialup connections (e.g.,
1131-1139); since the encoding server encodes the web page to
reduce the size of the data to be downloaded, the downloading time
can be reduced significantly for the client computers. Further, the
encoding program may also be implemented in a web server (e.g., as
a servlet or a CGI program).
[0157] FIG. 12 is a process flow diagram illustrating a process of
encoding web information to reduce communication bandwidth
requirements according to one embodiment of the present invention.
After operation 1201 receives first web information (e.g., a
portion of a web page, a data input form to be rendered in a web
browser, a home page of a web site), operation 1203 automatically
encodes the first web information to generate second web
information which is expandable in a web browser through pattern
matching substitutions (e.g., based on a regular expression) into
decoded information for rendering in the web browser. Operation
1205 transmits the second web page information over a network
connection to a web browser for rendering.
[0158] In one embodiment of the present invention, the encoding
operation (e.g., 1203) is performed in real time in response to the
web browser requesting the web information. For example, the
encoding operation may be in a proxy server (e.g., proxy server
1101 illustrated in FIG. 11). Alternatively, the encoding operation
can be performed during an installation or initialization phase of
the web site, in which the web pages are converted to the encoded
form so that no real time encoding operation is necessary. Encoding
a portion of the web information during an installation or
initialization phase of the web site can be combined with encoding
a portion of web information at real time. For example, a template
portion can be pre-encoded and a dynamically generated portion of a
web page can be encoded in real time. In one embodiment of the
present invention, a software program is used to perform
pre-designed pattern matching substitutions to encode the web page,
which is performed automatically. Alternatively, a programmer may
inspect the web page to discover patterns in the web pages, which
can be used to effectively reduce the web page data to be
transmitted. Further, the web page can be specially designed to
contain patterns that can be used for the efficient and effective
compression and decompression through regular expression based
substitutions.
[0159] FIG. 13 is a detailed process flow diagram illustrating a
process of dynamically encoding web information to reduce the size
of transmitted data according to one embodiment of the present
invention. After operation 1301 receives web information (e.g.,
from a web site, from a CGI program, from a servlet, from an
application program), the web information is encoded through
regular expression based substitution to reduce the size of data
transmission. In the first web information, operation 1303 replaces
strings of a target pattern with strings of a replacement pattern
that can be replaced with the strings of the target pattern through
regular expression based substitution. Thus, the existing strings
of the target pattern will not be mistakenly replaced with other
strings during the decoding process. Then, in the first web
information, operation 1305 replaces strings of a source pattern
(e.g., tags for HTML, syntax for JavaScript) with strings of the
target pattern that can be replaced with strings of the source
pattern through regular expression based substitution. Optionally,
operation 1307 compresses the encoded web information (e.g., using
a traditional compression scheme). Operation 1309 generates one or
more scripts to decode the encoded web information (e.g., a script
to perform regular expression substitution, a script to call
functions in a script file for regular expression substitution, a
script to specify a subset of substitutions to be performed on the
encoded web information). The scripts provide the decoded
information as part of the web information to the web browser for
rendering. Operation 1311 embeds the one or more scripts in a web
page with the encoded web page. Alternatively, the scripts may be
stored in a file at a location which is specified in the web page.
Note that some of the scripts can also be treated as the web
information, which can also be encoded through regular expression
based substitution. Operation 1313 then transmits the web page over
a network to a remote browser program.
[0160] FIG. 14 is a process flow diagram illustrating a process of
decoding web information that is encoded to reduce communication
bandwidth requirements according to one embodiment of the present
invention. After operation 1401 receives encoded web information
from a network (e.g., Internet, intranet, local area network,
wireless network), operation 1403 performs pattern matching
substitutions to expand the encoded web information into decoded
information. Operation 1405 renders the decode information (e.g.,
scripts, HTML text, HTML forms) in a web browser. In one embodiment
of the present invention, a script in JavaScript evaluated in the
web browser decodes the web browser. Thus, typical
JavaScript-enabled web browsers (e.g., Netscape Navigator or
Internet Explorer) can use the scripts and encoded information
according to embodiment of the present invention without
modification. Alternatively, the web browsers may be modified to
understand additional tags that can be used to direct the web
browsers to perform the regular expression based substitution. For
example, additional tags can be designed to specify regular
expression based substitutions, or a subset of pre-defined regular
expression based substitution rules, so that the web browser will
perform the substitutions for a portion of the received web
information before rendering it for display.
[0161] FIG. 15 is a detailed process flow diagram illustrating a
process of decoding web information that is encoded to reduce the
size of transmitted data according to one embodiment of the present
invention. After operation 1501 receives a web page from a network
(e.g., in HTML and using an HTTP protocol), operation 1503
downloads one or more script files (e.g., JavaScript) according to
tags specified in the web page if the script files are not already
in the cache. Operation 1505 evaluates one or more script commands
to perform regular expression based substitution to expand at least
a portion of information specified as encoded data for the script
commands (e.g., to generate tags in HTML and syntax in JavaScript).
Operation 1507 submits the expanded data as a portion of the web
page to the web browser for processing. If operation 1509
determines the expanded data contain one or more script commands,
operation 1511 evaluates the scripts commands (e.g., to perform
further substitution); otherwise, operation 1513 renders the
expanded data for display in the web browser.
[0162] Although some examples of embodiments of the present
invention use scripts (e.g., JavaScript or Java) in a web browser
to decode information, embodiments of the present invention can
also be implemented using other approaches. For example, additional
native software modules for a web browser can be dynamically
downloaded and linked with a web browser to extend the capability
of the web browser (e.g., as a dynamic library). In another
example, the regular expression based substitution rules may be
specified as values of attributes of one or more tags (e.g., in
XML) so that the document in the markup language can be processed
accordingly the specified substitution rules. In a further example,
a markup language (e.g., HTML) may be extended to allow regular
expression based substitution before so that the tags of the markup
language may be customized for the reduction of the data size for
specifying a document. Since scripting capabilities (e.g.,
JavaScript) are well incorporated into mostly used web browser, the
implementation based on a scripting language, such as JavaScript,
can provide convenience to the user without security concerns. Note
that the web page may include scripts for other purposes, such as
mini-assemblers for creating corresponding objects for a user
interface. These scripts for other purposes may or may not be
encoded. When these scripts are encoded for reduced data
transmission sizes, these scripts can also be decoded through
regular expression based substitutions. The regular expressions for
specifying the patterns of character strings can be hardwired in a
script file. Alternatively, the regular expressions can be in a
configuration file, embedded in a document (e.g., as a parameter of
a variable, an argument of a call to a function, or the value of a
special tag), or as a data file for a script.
[0163] While the invention has been described in terms of several
embodiments, those skilled in the art will recognize that the
invention is not limited to the embodiments described, but can be
practiced with modification and alteration within the spirit and
scope of the appended claims. The description is thus to be
regarded as illustrative instead of limiting.
* * * * *