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

System and method for reducing bandwidth requirements for remote applications by utilizing client processing power Download PDF

Info

Publication number
US20040258089A1
US20040258089A1 US10859766 US85976604A US2004258089A1 US 20040258089 A1 US20040258089 A1 US 20040258089A1 US 10859766 US10859766 US 10859766 US 85976604 A US85976604 A US 85976604A US 2004258089 A1 US2004258089 A1 US 2004258089A1
Authority
US
Grant status
Application
Patent type
Prior art keywords
information
method
encoded information
web page
web browser
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
US10859766
Inventor
Jacob Derechin
Luis Derechin
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
JackBe Corp
Original Assignee
JackBe Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46Multiprogramming arrangements
    • G06F9/54Interprogram communication

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. [0002]
  • 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. [0003]
  • 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. [0004]
  • 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. [0005]
  • 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. [0006]
  • 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. [0007]
  • 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. [0008]
  • 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. [0009]
  • 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 [0010] 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 [0011] 110 the server DPS receives the petition. The petition is received by the web server/application server of the server DPS.
  • At operation [0012] 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 [0013] 115 the petition is not a JSP file, the server DPS obtains the HTML code from the virtual directory at operation 118.
  • At operation [0014] 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 [0015] 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 [0016] 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. [0017]
  • 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. [0018]
  • 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. [0019]
  • 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. [0020]
  • 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. [0021]
  • 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. [0022]
  • 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. [0023]
  • 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. [0024]
  • 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. [0025]
  • 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. [0026]
  • 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. [0027]
  • 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. [0028]
  • 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 DPSs [0053] 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 server DPS [0054] 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 exemplary system [0055] 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.
  • System [0056] 300 includes exemplary embodiments of a server tier 301, a back end 302, and a client tier 303, as further described below.
  • Server tier [0057] 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.
  • Server tier [0058] 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.
  • Server tier [0059] 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.
  • Backend [0060] 302, which provides database management functions, among others, includes various database environments 340 a-340 d for responding to user queries.
  • Client tier [0061] 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. Process [0079] 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 operation [0080] 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 operation [0081] 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 operation [0082] 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 operation [0083] 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 operation [0084] 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 operation [0085] 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. Process [0094] 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 operation [0095] 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 operation [0096] 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 operation [0097] 520, the database (e.g., a customer name database) is queried using the data input by the user (e.g., CID).
  • If, at operation [0098] 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 operation [0099] 526, the focus is reset to the data input field and the data is selected.
  • If, at operation [0100] 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. Process [0104] 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 operation [0105] 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 operation [0106] 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 operation [0107] 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. Process [0111] 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 operation [0112] 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 operation [0113] 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 operation [0116] 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 server DPS [0127] 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.
  • Processing system [0128] 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, communication signal [0129] 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, processor [0130] 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.
  • Storage [0131] 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 command [0136] 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 operation [0157] 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 operation [0159] 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 operation [0160] 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 operation [0161] 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 (103)

    What is claimed is:
  1. 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. 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. 3. The method of claim 1, wherein a pattern for the pattern matching substitution is specified using a regular expression.
  4. 4. The method of claim 3, wherein the regular expression matches different strings of characters.
  5. 5. The method of claim 2, wherein the decoded information comprises information in a markup language.
  6. 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. 7. The method of claim 5, wherein the pattern matching substitution generates one or more tags in the markup language.
  8. 8. The method of claim 7, wherein the pattern matching substitution is according to a script evaluated in the web browser.
  9. 9. The method of claim 2, wherein the decoded information comprises a script executable by the web browser.
  10. 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. 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. 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. 13. The method of claim 12, wherein the web page is in a markup language.
  14. 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. 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. 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. 17. The method of claim 16, wherein the web page causes the browser to retrieve the script.
  18. 18. The method of claim 17, wherein the script is embedded in the web page.
  19. 19. The method of claim 17, wherein the script is retrieved from a different server DPS.
  20. 20. The method of claim 16, further comprising:
    retrieving information specifying a set of substitutions to be performed on the encoded information.
  21. 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. 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. 23. The method of claim 21, wherein at least one of said performing and said processing calls the function a plurality of times.
  24. 24. The method of claim 23, wherein the function is called recursively.
  25. 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. 26. The method of claim 25, wherein the decoded information is for rendering in a web browser of the client DPS.
  27. 27. The method of claim 25, wherein the pattern matching substitution is specified using a regular expression.
  28. 28. The method of claim 26, wherein the encoded information is embedded in a web page.
  29. 29. The method of claim 28, wherein the web page is in a markup language.
  30. 30. The method of claim 28, wherein the decoded information is in a markup language.
  31. 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. 32. The method of claim 31, wherein the script comprises regular expressions.
  33. 33. The method of claim 28, wherein the pattern matching substitution generates one or more tags in a markup language.
  34. 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. 35. The method of claim 34, further comprising:
    transmitting information to the web browser to specify a set of regular expression based substitutions.
  36. 36. The method of claim 26, further comprising:
    generating the encoded information in response to a request from the web browser.
  37. 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. 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. 39. The method of claim 37, wherein said converting comprises:
    performing a pattern matching substitution.
  40. 40. The method of claim 39, wherein said pattern matching substitution is based on a regular expression.
  41. 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. 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. 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. 44. The method of claim 42, wherein the encoded information is expandable through calling the function a plurality of times.
  45. 45. The method of claim 44, wherein the function is called recursively.
  46. 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. 47. The medium of claim 46, wherein the decoded information is for rendering in a web browser running on the client DPS.
  48. 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. 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. 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. 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. 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. 53. The medium of claim 52, wherein the web page further specifies a set of substitutions to be performed on the encoded information.
  54. 54. The medium of claim 51, wherein said performing comprises:
    calling a function with at least one parameter, the function creating a set of objects for a user interface, a value for the at least one parameter specifying a set of features of the objects.
  55. 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. 56. The medium of claim 54, wherein said performing calls the function a plurality of times.
  57. 57. The medium of claim 56, wherein the function is called recursively.
  58. 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. 59. The medium of claim 58, wherein the decoded information is for rendering in a web browser in the client DPS.
  60. 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. 61. The medium of claim 60, wherein the decoded information is in one of:
    a markup language; and
    a scripting language.
  62. 62. The medium of claim 60, wherein the pattern matching substitution generates one or more tags in a markup language.
  63. 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. 64. The medium of claim 63, wherein the method further comprises:
    specifying a set of regular expression based substitutions in the web page.
  65. 65. The medium of claim 59, wherein the encoded information is generated in response to a request from the web browser.
  66. 66. The medium of claim 65, wherein said generating the encoded information comprises:
    retrieving information requested by the web browser;
    converting at least a portion of the information requested by the web browser into the encoded information; and
    combining a script with the encoded information as a response to the web browser.
  67. 67. The medium of claim 66, wherein said converting comprises:
    performing regular expression based substitution.
  68. 68. The medium of claim 66, wherein the method further comprises:
    determining a set of substitutions required to decode the encoded information;
    wherein the response further includes information specifying the set of substitutions.
  69. 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. 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. 71. The medium of claim 69, wherein the encoded information is expandable through calling the function a plurality of times.
  72. 72. The medium of claim 71, wherein the function is called recursively.
  73. 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. 74. The data processing system of claim 73, wherein the processor renders the decoded in a web browser.
  75. 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. 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. 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. 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. 79. The data processing system of claim 77, wherein the processor performs a set of substitutions specified in the web page.
  80. 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. 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. 82. The data processing system of claim 80, wherein the processor expands the encoded information through calling the function a plurality of times.
  83. 83. The data processing system of claim 82, wherein the function is called recursively.
  84. 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. 85. The data processing system of claim 84, wherein the pattern matching substitution is specified using a regular expression.
  86. 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. 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. 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. 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. 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. 91. The data processing system of claim 89, wherein the encoded information is expandable through calling the function a plurality of times.
  92. 92. The data processing system of claim 91, wherein the function is called recursively.
  93. 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. 94. The medium of claim 93, wherein the method is performed in a web browser running on said system.
  95. 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. 96. The medium of claim 93, wherein the computer program instructions comprise a script embedded in the web page.
  97. 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. 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. 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. 100. The medium of claim 93, wherein at least one of said performing and said processing comprises:
    calling a function with at least one parameter, the function creating a set of objects for a user interface, a value for the at least one parameter specifying a set of features of the objects.
  101. 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. 102. The medium of claim 100, wherein at least one of said performing and said processing calls the function a plurality of times.
  103. 103. The medium of claim 102, wherein the function is called recursively.
US10859766 2002-11-18 2004-06-02 System and method for reducing bandwidth requirements for remote applications by utilizing client processing power Abandoned US20040258089A1 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US10299260 US8108488B2 (en) 2002-11-18 2002-11-18 System and method for reducing bandwidth requirements for remote applications by utilizing client processing power
US10859766 US20040258089A1 (en) 2002-11-18 2004-06-02 System and method for reducing bandwidth requirements for remote applications by utilizing client processing power

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US10859766 US20040258089A1 (en) 2002-11-18 2004-06-02 System and method for reducing bandwidth requirements for remote applications by utilizing client processing power

Related Parent Applications (1)

Application Number Title Priority Date Filing Date
US10299260 Continuation-In-Part US8108488B2 (en) 2002-11-18 2002-11-18 System and method for reducing bandwidth requirements for remote applications by utilizing client processing power

Publications (1)

Publication Number Publication Date
US20040258089A1 true true US20040258089A1 (en) 2004-12-23

Family

ID=32324374

Family Applications (2)

Application Number Title Priority Date Filing Date
US10299260 Active 2028-11-17 US8108488B2 (en) 2002-11-18 2002-11-18 System and method for reducing bandwidth requirements for remote applications by utilizing client processing power
US10859766 Abandoned US20040258089A1 (en) 2002-11-18 2004-06-02 System and method for reducing bandwidth requirements for remote applications by utilizing client processing power

Family Applications Before (1)

Application Number Title Priority Date Filing Date
US10299260 Active 2028-11-17 US8108488B2 (en) 2002-11-18 2002-11-18 System and method for reducing bandwidth requirements for remote applications by utilizing client processing power

Country Status (5)

Country Link
US (2) US8108488B2 (en)
EP (1) EP1576483A4 (en)
CN (1) CN1729461A (en)
CA (1) CA2505310A1 (en)
WO (1) WO2004046887A3 (en)

Cited By (39)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20040181444A1 (en) * 2004-04-26 2004-09-16 Sandrew Barry B. System and method for manipulating motion picture data using labor outsourcing
US20050086608A1 (en) * 2003-10-17 2005-04-21 Andreas Roessler Selective rendering of user interface of computer program
US20050240916A1 (en) * 2004-04-26 2005-10-27 Sandrew Barry B System and method for distributed project outsourcing
US20060143059A1 (en) * 2004-04-26 2006-06-29 Barry Sandrew System and method for minimizing transfer of motion picture data manipulated with outsourced labor
US20060277179A1 (en) * 2005-06-03 2006-12-07 Bailey Michael P Method for communication between computing devices using coded values
US20070050476A1 (en) * 2005-08-25 2007-03-01 International Business Machines Corporation Mechanism for generating dynamic content without a web server
US20070078810A1 (en) * 2005-09-30 2007-04-05 Keith Hackworth Methods, systems, and products for updating web content
US20070101322A1 (en) * 2005-11-02 2007-05-03 International Business Machines Corporation Extending markup of a browser using a plug-in framework
US20080172451A1 (en) * 2007-01-11 2008-07-17 Samsung Electronics Co., Ltd. Meta data information providing server, client apparatus, method of providing meta data information, and method of providing content
US20080228773A1 (en) * 2007-03-14 2008-09-18 Hand Held Products, Inc. Apparatus and method for data input device
US20080228927A1 (en) * 2007-03-15 2008-09-18 Microsoft Corporation Server directed browsing
US20080260135A1 (en) * 2007-04-19 2008-10-23 Art Technology Group, Inc. Method and apparatus for cross channel data processing
US20080276183A1 (en) * 2007-04-19 2008-11-06 Joseph Siegrist Method and apparatus for web page co-browsing
US20090150805A1 (en) * 2007-12-06 2009-06-11 Shepherd David J Indicating pending asynchronous updates in a graphical user interface (gui)
US20090172519A1 (en) * 2008-01-02 2009-07-02 Microsoft Corporation Web page based program versioning
US20100095272A1 (en) * 2008-10-14 2010-04-15 Microsoft Corporation Declarative programming model for authoring and execution control and data flow for resource oriented system
US20100094926A1 (en) * 2008-10-14 2010-04-15 Microsoft Corporation Declarative programming model for modeling and execution of triggers for resource oriented system
US20100100868A1 (en) * 2008-10-17 2010-04-22 Microsoft Corporation Interactive design environments to visually model, debug and execute resource oriented programs.
US20100322404A1 (en) * 2009-06-23 2010-12-23 Art Technology Group, Inc. Cross channel identification in electronic commerce environments
US7975019B1 (en) 2005-07-15 2011-07-05 Amazon Technologies, Inc. Dynamic supplementation of rendered web pages with content supplied by a separate source
US7975020B1 (en) * 2005-07-15 2011-07-05 Amazon Technologies, Inc. Dynamic updating of rendered web pages with supplemental content
US20120128150A1 (en) * 2009-06-28 2012-05-24 Nds Limited Pattern-free encryption
US20120284528A1 (en) * 2010-10-07 2012-11-08 Stephen Orovitz Multi-purpose multi-dimensional, variable and multi-key e-mail and data encryption method
US8730232B2 (en) 2011-02-01 2014-05-20 Legend3D, Inc. Director-style based 2D to 3D movie conversion system and method
US8775603B2 (en) 2007-05-04 2014-07-08 Sitespect, Inc. Method and system for testing variations of website content
US8897596B1 (en) 2001-05-04 2014-11-25 Legend3D, Inc. System and method for rapid image sequence depth enhancement with translucent elements
US8953905B2 (en) 2001-05-04 2015-02-10 Legend3D, Inc. Rapid workflow system and method for image sequence depth enhancement
US20150089377A1 (en) * 2013-09-21 2015-03-26 Oracle International Corporation Method and system for selection of user interface rendering artifacts in enterprise web applications using a manifest mechanism
US9007365B2 (en) 2012-11-27 2015-04-14 Legend3D, Inc. Line depth augmentation system and method for conversion of 2D images to 3D images
US9007404B2 (en) 2013-03-15 2015-04-14 Legend3D, Inc. Tilt-based look around effect image enhancement method
US9241147B2 (en) 2013-05-01 2016-01-19 Legend3D, Inc. External depth map transformation method for conversion of two-dimensional images to stereoscopic images
US9282321B2 (en) 2011-02-17 2016-03-08 Legend3D, Inc. 3D model multi-reviewer system
US9286941B2 (en) 2001-05-04 2016-03-15 Legend3D, Inc. Image sequence enhancement and motion picture project management system
US9288476B2 (en) 2011-02-17 2016-03-15 Legend3D, Inc. System and method for real-time depth modification of stereo images of a virtual reality environment
US9407904B2 (en) 2013-05-01 2016-08-02 Legend3D, Inc. Method for creating 3D virtual reality from 2D images
US9438878B2 (en) 2013-05-01 2016-09-06 Legend3D, Inc. Method of converting 2D video to 3D video using 3D object models
US9547937B2 (en) 2012-11-30 2017-01-17 Legend3D, Inc. Three-dimensional annotation system and method
US9609307B1 (en) 2015-09-17 2017-03-28 Legend3D, Inc. Method of converting 2D video to 3D video using machine learning
US9842308B1 (en) 2010-02-25 2017-12-12 Stamps.Com Inc. Systems and methods for rules based shipping

Families Citing this family (8)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN1955990B (en) * 2005-10-28 2010-09-01 深圳市东进通讯技术股份有限公司 Flow executing method and system of integral telecommunication platform
US20080033997A1 (en) * 2006-08-04 2008-02-07 Sap Portals (Israel) Ltd. Transformation tool for migration of web-based content to portal
US8290929B2 (en) * 2007-10-26 2012-10-16 Yahoo! Inc. Media enhancement mechanism using embed code
US8412802B2 (en) * 2009-02-11 2013-04-02 American Express Travel Related Services Company, Inc. System and method to optimize data communication in a computational network
US8706803B1 (en) * 2010-09-24 2014-04-22 Imdb.Com, Inc. Client-side generation of preliminary version of network page
US8495630B2 (en) 2010-11-03 2013-07-23 International Business Machines Corporation Transferring objects between virtual machines
US9575873B2 (en) 2013-09-13 2017-02-21 Sap Se Software testing system and method
RU2014122128A (en) * 2014-05-29 2015-12-10 Общество С Ограниченной Ответственностью "Яндекс" Mode web property the user with a web browser and electronic device used therein

Citations (20)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6272484B1 (en) * 1998-05-27 2001-08-07 Scansoft, Inc. Electronic document manager
US6292115B1 (en) * 1997-12-02 2001-09-18 Hughes Electronics Corporation Data compression for use with a communications channel
US6295645B1 (en) * 1997-12-22 2001-09-25 Texas Instruments Incorporated Method and apparatus for providing downloadable functionality to an embedded coprocessor
US20010037405A1 (en) * 2000-04-07 2001-11-01 Sideek Sinnathambi Mohamed Wireless web generation from conventional web sites by pattern identification and dynamic content extraction
US20020156815A1 (en) * 2001-04-19 2002-10-24 International Business Machines Corporation Method and apparatus for the separation of web layout, logic, and data when used in server-side scripting languages
US6477550B1 (en) * 1999-03-16 2002-11-05 Mcafee.Com Corporation Method and system for processing events related to a first type of browser from a second type of browser
US20030009488A1 (en) * 2001-05-22 2003-01-09 Reuters America, Inc System and method of accelerating delivery of dynamic web pages over a network
US6507867B1 (en) * 1998-12-22 2003-01-14 International Business Machines Corporation Constructing, downloading, and accessing page bundles on a portable client having intermittent network connectivity
US20030055723A1 (en) * 2001-09-20 2003-03-20 Paul English Vendor comparison, advertising and switching
US6546554B1 (en) * 2000-01-21 2003-04-08 Sun Microsystems, Inc. Browser-independent and automatic apparatus and method for receiving, installing and launching applications from a browser on a client computer
US20030197630A1 (en) * 2002-04-22 2003-10-23 John Border Method and system for data compession with dictionary pre-load of a set of expected character strings
US20030233404A1 (en) * 2002-06-13 2003-12-18 Hopkins Christopher D. Offline simulation of online session between client and server
US6687745B1 (en) * 1999-09-14 2004-02-03 Droplet, Inc System and method for delivering a graphical user interface of remote applications over a thin bandwidth connection
US20040117349A1 (en) * 2002-12-09 2004-06-17 Moricz Michael Zsolt Intermediary server for facilitating retrieval of mid-point, state-associated web pages
US20040119740A1 (en) * 2002-12-24 2004-06-24 Google, Inc., A Corporation Of The State Of California Methods and apparatus for displaying and replying to electronic messages
US20040148375A1 (en) * 2001-02-12 2004-07-29 Levett David Lawrence Presentation service which enables client device to run a network based application
US6782431B1 (en) * 1998-09-30 2004-08-24 International Business Machines Corporation System and method for dynamic selection of database application code execution on the internet with heterogenous clients
US6792605B1 (en) * 1999-06-10 2004-09-14 Bow Street Software, Inc. Method and apparatus for providing web based services using an XML Runtime model to store state session data
US6807559B1 (en) * 2000-04-06 2004-10-19 Attachmate Corporation System and method for applet management
US20040216042A1 (en) * 2003-04-24 2004-10-28 International Business Machines Corporation System and method for generating high-function browser widgets with full addressability

Family Cites Families (13)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6012083A (en) * 1996-09-24 2000-01-04 Ricoh Company Ltd. Method and apparatus for document processing using agents to process transactions created based on document content
CA2319996A1 (en) 1999-09-22 2001-03-22 Goodhome.Com Method and system for generating web pages with information displayed in a carousel
US6691176B1 (en) * 1999-11-04 2004-02-10 Microsoft Corporation Method for managing client services across browser pages
US6892067B1 (en) * 1999-12-30 2005-05-10 Nokia Corporation Script based interfaces for mobile phones
US6622168B1 (en) * 2000-04-10 2003-09-16 Chutney Technologies, Inc. Dynamic page generation acceleration using component-level caching
US7379963B1 (en) 2000-07-14 2008-05-27 Knownow-Delaware Delivery of any type of information to anyone anytime anywhere
US7925703B2 (en) * 2000-12-26 2011-04-12 Numedeon, Inc. Graphical interactive interface for immersive online communities
US20020092012A1 (en) * 2001-01-09 2002-07-11 Shah Alexandre K. Smart-caching system and method
US20020143800A1 (en) * 2001-01-24 2002-10-03 Henrik Lindberg Model view controller
US7171443B2 (en) * 2001-04-04 2007-01-30 Prodigy Communications, Lp Method, system, and software for transmission of information
US6948151B2 (en) * 2001-06-29 2005-09-20 International Business Machines Corporation System and method for dynamic packaging of component objects
WO2003065242A1 (en) 2002-01-25 2003-08-07 Tibco Software, Inc. Single applet to communicate with multiple html elements contained inside of multiple categories on a page
US20040010563A1 (en) * 2002-06-26 2004-01-15 John Forte Method for enterprise device naming for storage devices

Patent Citations (20)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6292115B1 (en) * 1997-12-02 2001-09-18 Hughes Electronics Corporation Data compression for use with a communications channel
US6295645B1 (en) * 1997-12-22 2001-09-25 Texas Instruments Incorporated Method and apparatus for providing downloadable functionality to an embedded coprocessor
US6272484B1 (en) * 1998-05-27 2001-08-07 Scansoft, Inc. Electronic document manager
US6782431B1 (en) * 1998-09-30 2004-08-24 International Business Machines Corporation System and method for dynamic selection of database application code execution on the internet with heterogenous clients
US6507867B1 (en) * 1998-12-22 2003-01-14 International Business Machines Corporation Constructing, downloading, and accessing page bundles on a portable client having intermittent network connectivity
US6477550B1 (en) * 1999-03-16 2002-11-05 Mcafee.Com Corporation Method and system for processing events related to a first type of browser from a second type of browser
US6792605B1 (en) * 1999-06-10 2004-09-14 Bow Street Software, Inc. Method and apparatus for providing web based services using an XML Runtime model to store state session data
US6687745B1 (en) * 1999-09-14 2004-02-03 Droplet, Inc System and method for delivering a graphical user interface of remote applications over a thin bandwidth connection
US6546554B1 (en) * 2000-01-21 2003-04-08 Sun Microsystems, Inc. Browser-independent and automatic apparatus and method for receiving, installing and launching applications from a browser on a client computer
US6807559B1 (en) * 2000-04-06 2004-10-19 Attachmate Corporation System and method for applet management
US20010037405A1 (en) * 2000-04-07 2001-11-01 Sideek Sinnathambi Mohamed Wireless web generation from conventional web sites by pattern identification and dynamic content extraction
US20040148375A1 (en) * 2001-02-12 2004-07-29 Levett David Lawrence Presentation service which enables client device to run a network based application
US20020156815A1 (en) * 2001-04-19 2002-10-24 International Business Machines Corporation Method and apparatus for the separation of web layout, logic, and data when used in server-side scripting languages
US20030009488A1 (en) * 2001-05-22 2003-01-09 Reuters America, Inc System and method of accelerating delivery of dynamic web pages over a network
US20030055723A1 (en) * 2001-09-20 2003-03-20 Paul English Vendor comparison, advertising and switching
US20030197630A1 (en) * 2002-04-22 2003-10-23 John Border Method and system for data compession with dictionary pre-load of a set of expected character strings
US20030233404A1 (en) * 2002-06-13 2003-12-18 Hopkins Christopher D. Offline simulation of online session between client and server
US20040117349A1 (en) * 2002-12-09 2004-06-17 Moricz Michael Zsolt Intermediary server for facilitating retrieval of mid-point, state-associated web pages
US20040119740A1 (en) * 2002-12-24 2004-06-24 Google, Inc., A Corporation Of The State Of California Methods and apparatus for displaying and replying to electronic messages
US20040216042A1 (en) * 2003-04-24 2004-10-28 International Business Machines Corporation System and method for generating high-function browser widgets with full addressability

Cited By (61)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9286941B2 (en) 2001-05-04 2016-03-15 Legend3D, Inc. Image sequence enhancement and motion picture project management system
US8897596B1 (en) 2001-05-04 2014-11-25 Legend3D, Inc. System and method for rapid image sequence depth enhancement with translucent elements
US8953905B2 (en) 2001-05-04 2015-02-10 Legend3D, Inc. Rapid workflow system and method for image sequence depth enhancement
US20050086608A1 (en) * 2003-10-17 2005-04-21 Andreas Roessler Selective rendering of user interface of computer program
US7571391B2 (en) * 2003-10-17 2009-08-04 Sap Ag Selective rendering of user interface of computer program
US20060143059A1 (en) * 2004-04-26 2006-06-29 Barry Sandrew System and method for minimizing transfer of motion picture data manipulated with outsourced labor
US20040181444A1 (en) * 2004-04-26 2004-09-16 Sandrew Barry B. System and method for manipulating motion picture data using labor outsourcing
US20050240916A1 (en) * 2004-04-26 2005-10-27 Sandrew Barry B System and method for distributed project outsourcing
US20060277179A1 (en) * 2005-06-03 2006-12-07 Bailey Michael P Method for communication between computing devices using coded values
US8103880B2 (en) * 2005-06-03 2012-01-24 Adobe Systems Incorporated Method for communication between computing devices using coded values
US20110238524A1 (en) * 2005-07-15 2011-09-29 Nigel Green Browser-based retrieval and display of content associated with a link that matches a link signature
US7975020B1 (en) * 2005-07-15 2011-07-05 Amazon Technologies, Inc. Dynamic updating of rendered web pages with supplemental content
US7975019B1 (en) 2005-07-15 2011-07-05 Amazon Technologies, Inc. Dynamic supplementation of rendered web pages with content supplied by a separate source
US8296392B2 (en) * 2005-07-15 2012-10-23 Amazon Technologies, Inc. Browser-based retrieval and display of content associated with a link that matches a link signature
US9117232B2 (en) 2005-07-15 2015-08-25 Amazon Technologies, Inc. Browser-based retrieval and display of content associated with a link that matches a link signature
US7937715B2 (en) 2005-08-25 2011-05-03 International Business Machines Corporation Mechanism for generating dynamic content without a web server
US20070050476A1 (en) * 2005-08-25 2007-03-01 International Business Machines Corporation Mechanism for generating dynamic content without a web server
US20070078810A1 (en) * 2005-09-30 2007-04-05 Keith Hackworth Methods, systems, and products for updating web content
US20100169286A1 (en) * 2005-09-30 2010-07-01 Keith Hackworth Methods, Systems, and Products for Updating Web Content
US7698321B2 (en) * 2005-09-30 2010-04-13 At&T Intellectual Property I, L.P. Methods, systems, and products for updating web content
US8117171B2 (en) 2005-09-30 2012-02-14 At&T Intellectual Property I, L.P. Methods, systems, and products for updating web content
US7739589B2 (en) 2005-11-02 2010-06-15 International Business Machines Corporation Extending markup of a browser using a plug-in framework
US20070101322A1 (en) * 2005-11-02 2007-05-03 International Business Machines Corporation Extending markup of a browser using a plug-in framework
WO2007098476A2 (en) * 2006-02-21 2007-08-30 Legend Films, Inc. System and method for minimizing transfer of motion picture data manipulated with outsourced labor
WO2007098476A3 (en) * 2006-02-21 2008-05-15 Legend Films Inc System and method for minimizing transfer of motion picture data manipulated with outsourced labor
US20080172451A1 (en) * 2007-01-11 2008-07-17 Samsung Electronics Co., Ltd. Meta data information providing server, client apparatus, method of providing meta data information, and method of providing content
US9794310B2 (en) * 2007-01-11 2017-10-17 Samsung Electronics Co., Ltd. Meta data information providing server, client apparatus, method of providing meta data information, and method of providing content
US20080228773A1 (en) * 2007-03-14 2008-09-18 Hand Held Products, Inc. Apparatus and method for data input device
US20080228927A1 (en) * 2007-03-15 2008-09-18 Microsoft Corporation Server directed browsing
US7941755B2 (en) * 2007-04-19 2011-05-10 Art Technology Group, Inc. Method and apparatus for web page co-browsing
US20080260135A1 (en) * 2007-04-19 2008-10-23 Art Technology Group, Inc. Method and apparatus for cross channel data processing
US20080276183A1 (en) * 2007-04-19 2008-11-06 Joseph Siegrist Method and apparatus for web page co-browsing
US8064584B2 (en) 2007-04-19 2011-11-22 Art Technology Group, Inc. Method and apparatus for cross channel data processing
US8775603B2 (en) 2007-05-04 2014-07-08 Sitespect, Inc. Method and system for testing variations of website content
US20090150805A1 (en) * 2007-12-06 2009-06-11 Shepherd David J Indicating pending asynchronous updates in a graphical user interface (gui)
US8635541B2 (en) * 2007-12-06 2014-01-21 International Business Machines Corporation Indicating pending asynchronous updates in a graphical user interface (GUI)
US8887039B2 (en) * 2008-01-02 2014-11-11 Microsoft Corporation Web page based program versioning
US20090172519A1 (en) * 2008-01-02 2009-07-02 Microsoft Corporation Web page based program versioning
US20100094926A1 (en) * 2008-10-14 2010-04-15 Microsoft Corporation Declarative programming model for modeling and execution of triggers for resource oriented system
US20100095272A1 (en) * 2008-10-14 2010-04-15 Microsoft Corporation Declarative programming model for authoring and execution control and data flow for resource oriented system
US8490052B2 (en) 2008-10-14 2013-07-16 Microsoft Corporation Declarative programming model for authoring and execution control and data flow for resource oriented system
US8438295B2 (en) * 2008-10-14 2013-05-07 Microsoft Corporation Declarative programming model for modeling and execution of triggers for resource oriented system
US8533666B2 (en) 2008-10-17 2013-09-10 Microsoft Corporation Interactive design environments to visually model, debug and execute resource oriented programs
US20100100868A1 (en) * 2008-10-17 2010-04-22 Microsoft Corporation Interactive design environments to visually model, debug and execute resource oriented programs.
US20100322404A1 (en) * 2009-06-23 2010-12-23 Art Technology Group, Inc. Cross channel identification in electronic commerce environments
US8571201B2 (en) 2009-06-23 2013-10-29 Oracle Otc Subsidiary Llc Cross channel identification in electronic commerce environments
US9031227B2 (en) * 2009-06-28 2015-05-12 Cisco Technology Inc. Pattern-free encryption
US20120128150A1 (en) * 2009-06-28 2012-05-24 Nds Limited Pattern-free encryption
US9842308B1 (en) 2010-02-25 2017-12-12 Stamps.Com Inc. Systems and methods for rules based shipping
US20120284528A1 (en) * 2010-10-07 2012-11-08 Stephen Orovitz Multi-purpose multi-dimensional, variable and multi-key e-mail and data encryption method
US8730232B2 (en) 2011-02-01 2014-05-20 Legend3D, Inc. Director-style based 2D to 3D movie conversion system and method
US9282321B2 (en) 2011-02-17 2016-03-08 Legend3D, Inc. 3D model multi-reviewer system
US9288476B2 (en) 2011-02-17 2016-03-15 Legend3D, Inc. System and method for real-time depth modification of stereo images of a virtual reality environment
US9007365B2 (en) 2012-11-27 2015-04-14 Legend3D, Inc. Line depth augmentation system and method for conversion of 2D images to 3D images
US9547937B2 (en) 2012-11-30 2017-01-17 Legend3D, Inc. Three-dimensional annotation system and method
US9007404B2 (en) 2013-03-15 2015-04-14 Legend3D, Inc. Tilt-based look around effect image enhancement method
US9438878B2 (en) 2013-05-01 2016-09-06 Legend3D, Inc. Method of converting 2D video to 3D video using 3D object models
US9407904B2 (en) 2013-05-01 2016-08-02 Legend3D, Inc. Method for creating 3D virtual reality from 2D images
US9241147B2 (en) 2013-05-01 2016-01-19 Legend3D, Inc. External depth map transformation method for conversion of two-dimensional images to stereoscopic images
US20150089377A1 (en) * 2013-09-21 2015-03-26 Oracle International Corporation Method and system for selection of user interface rendering artifacts in enterprise web applications using a manifest mechanism
US9609307B1 (en) 2015-09-17 2017-03-28 Legend3D, Inc. Method of converting 2D video to 3D video using machine learning

Also Published As

Publication number Publication date Type
US20040109470A1 (en) 2004-06-10 application
US8108488B2 (en) 2012-01-31 grant
CN1729461A (en) 2006-02-01 application
EP1576483A4 (en) 2008-05-07 application
CA2505310A1 (en) 2004-06-03 application
WO2004046887A3 (en) 2005-04-28 application
WO2004046887A2 (en) 2004-06-03 application
EP1576483A2 (en) 2005-09-21 application

Similar Documents

Publication Publication Date Title
US7428725B2 (en) Inserting devices specific content
US5973696A (en) Embedded web server
US6457066B1 (en) Simple object access protocol
Shklar et al. Web application architecture
US6993559B2 (en) System, method, apparatus and computer program product for operating a web site by electronic mail
US6489980B1 (en) Software apparatus for immediately posting sharing and maintaining objects on a web page
US6507817B1 (en) Voice IP approval system using voice-enabled web based application server
US6976059B1 (en) System and method to provide applets using a server based virtual machine
US5875296A (en) Distributed file system web server user authentication with cookies
US6633913B1 (en) Scan system and method for scanning images to an online web page
US6757900B1 (en) State management of server-side control objects
US6631010B1 (en) Web-based imaging system utilizing “cookies” to provide a single-action printing option
US7346842B1 (en) Methods and apparatus for incorporating a partial page on a client
US6481621B1 (en) System method and article of manufacture for accessing and processing smart card information
US6996833B1 (en) Protocol agnostic request response pattern
US6718390B1 (en) Selectively forced redirection of network traffic
US6041365A (en) Apparatus and method for high performance remote application gateway servers
US7346840B1 (en) Application server configured for dynamically generating web forms based on extensible markup language documents and retrieved subscriber data
US7051084B1 (en) Methods and apparatus for regenerating and transmitting a partial page
US6237031B1 (en) System for dynamically controlling a network proxy
US20080098291A1 (en) Method and System for Cross-Platform Form Creation and Deployment
US20100050089A1 (en) Web browser system of mobile communication terminal, using proxy server
US20040216127A1 (en) Method and apparatus for accelerating web services
US6438619B1 (en) Operating system based remote communication system
US20030200332A1 (en) Method and apparatus for dynamic proxy insertion in network traffic flow

Legal Events

Date Code Title Description
AS Assignment

Owner name: JACKBE CORPORATION, MEXICO

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:DERECHIN, JACOB;DERECHIN, LUIS;REEL/FRAME:015647/0822

Effective date: 20040802