US20040258089A1

US20040258089A1 - System and method for reducing bandwidth requirements for remote applications by utilizing client processing power

Info

Publication number: US20040258089A1
Application number: US10/859,766
Authority: US
Inventors: Jacob Derechin; Luis Derechin
Original assignee: Jackbe LLC
Current assignee: Jackbe LLC
Priority date: 2002-11-18
Filing date: 2004-06-02
Publication date: 2004-12-23
Also published as: AU2003295680A1; EP1576483A2; EP1576483A4; MXPA03002742A; WO2004046887A2; AU2003295680A8; US8108488B2; CA2505310A1; US20040109470A1; CN1729461A; WO2004046887A3

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.

Description

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.[0001]

FIELD

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

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.

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.

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.

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.

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.

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.

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.

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.

At

operation

110 the server DPS receives the petition. The petition is received by the web server/application server of the server DPS.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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

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: [0029]
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; [0030]
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; [0031]
FIG. 3 is an architectural overview diagram for a system in accordance with one embodiment of the invention; [0032]
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; [0033]
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; [0034]
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; [0035]
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; [0036]
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; [0037]
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; [0038]
FIG. 10 illustrates a system to provide remote access according to one embodiment of the present invention; [0039]
FIG. 11 illustrates a system to reduce bandwidth requirements according to one embodiment of the present invention; [0040]
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; [0041]
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; [0042]
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; [0043]
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; [0044]
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. [0045]

DETAILED DESCRIPTION

Overview [0046]
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). [0047]
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. [0048]
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. [0049]
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. [0050]
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. [0051]
System [0052]
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 [0053] DPSs 200 includes a plurality of client DPSs, shown as client DPSs 205 a-205 d, coupled to one or more server DPSs, shown as server DPS 220. The server DPS 220 and client DPSs 205 a-205 d 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 205 a and 205 d are coupled to the server 220 through LAN 211, while client DPSs 205 b and 205 c 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.
An embodiment of a digital processing system that may be used for the [0054] server DPS 220, or client DPSs 205 a-205 d, in accordance with an embodiment of the invention is described below in reference to FIG. 8.
FIG. 3 is an architectural overview diagram for a system in accordance with one embodiment of the invention. The [0055] 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 311 a; servlets 312 and RDTE servlets 312 a; JSPs 313 and RDTE JSPs 313 a; and CGIs 314 and RDTE CGIs 314 a. 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 340 a-340 d 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.
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 [0062] 370 a-370 c 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.
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. [0063]
The various functions of the core library as well as SMAs and AMAs are discussed in greater detail below. [0064]
Generic Mini-Assembler [0065]
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. [0066]
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. [0067]
Specific Mini-Assemblers [0068]
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. [0069]
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. [0070]
Alpha Mini-Assemblers [0071]
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. [0072]
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. [0073]
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. [0074]
Deltalyzers [0075]
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. [0076]
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. [0077]
Process [0078]
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. [0079] 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.
At [0080] 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.
At [0081] 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.
At [0082] 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.)
At [0083] 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.
At [0084] 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.
At [0085] 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.
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. [0086]
Additional Processes [0087]
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). [0088]
Pacemakers [0089]
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. [0090]
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. [0091]
Database Validation Process [0092]
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). [0093]
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. [0094] 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.
At [0095] 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.
At [0096] 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.
At [0097] operation 520, the database (e.g., a customer name database) is queried using the data input by the user (e.g., CID).
If, at [0098] 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.
At [0099] operation 526, the focus is reset to the data input field and the data is selected.
If, at [0100] 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).
At operation [0101] 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.
Refresh Process [0102]
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. [0103]
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. [0104] 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).
At [0105] 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.
At [0106] 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.
At [0107] 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).
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. [0108]
Data Type and Field Completion Validation Process [0109]
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. [0110]
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. [0111] 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.
At [0112] 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.
At [0113] 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.
At operation [0114] 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.
At operation [0115] 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.
At [0116] 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.
At operation [0117] 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.
At operation [0118] 726, if the field is not required, the process continues with the next data input field.
At operation [0119] 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.
At operation [0120] 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.
At operation [0121] 732, if the required data input field is complete, a determination is made if there are other fields to validate.
At operation [0122] 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.
General Matters [0123]
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. [0124]
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. [0125]
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. [0126]
FIG. 8 illustrates an embodiment of a digital processing system that may be used for the [0127] server DPS 220, or client DPSs 205 a-205 d, 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.
For one embodiment of the present invention, [0129] 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.
In one embodiment of the present invention, [0130] 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.
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. [0132]
Pattern Matching Based Substitution [0133]
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. [0134]
s(\d+)
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., [0135] 901) can be used to replace the string that matches the regular expression s(\d+) with the following expression:
size=“$1”
When the [0136] 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).
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. [0137]
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. [0138]
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. [0139]
<TABLE [0140]
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. [0141]
Similarly, another symbol, such as x9B (=155) can be used to represent the following character string. [0142]
</TABLE [0143]
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., (/)*\x9A) can be used to convert x9A and /x9A back to “<TABLE” and “</TABLE” respectively. [0144]
Similarly, a regular expression (e.g., <(/)*TABLE) can be used to map both “<TABLE” and “</TABLE” to x9A and /x9A respectively. [0145]
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. [0146]
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. [0147]
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. [0148]
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. [0149]
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 ([0150] 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.
In one embodiment of the present invention, a web page displayed in the browser ([0151] 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.
In one embodiment of the present invention, a number of mini-assemblers are encoded as encoded assemblers ([0152] 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.
In one embodiment of the present invention, the encoded information is further compressed through a traditional compression scheme (e.g., using the compression program [0153] 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).
In one embodiment of the present invention, at least a portion of the encoded assemblers ([0154] 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.
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 ([0155] 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.
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., [0156] 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).
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 [0157] 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.
In one embodiment of the present invention, the encoding operation (e.g., [0158] 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.
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 [0159] 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.
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 [0160] 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.
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 [0161] 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.
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. [0162]
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. [0163]

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:

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;

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;

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:

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.