Abstract:
An electronic document processing system is disclosed for a communications network, wherein the network protocol has the property of repeatingly breaking down each established communication connection between network nodes attempting to carry on a dialog session. Related document data is exchanged between a network server and a client node, wherein the network communication connection between the server and the client must be repeatedly re-established and the prior dialog session context must be reassociated with continued dialog session communications between the server and client. Accordingly, the server node embeds a dialog session identifier within each communication to the client so that a response from the client may return the identifier thereby allowing the server to associate new client input with previously stored input related to the dialog session. The present invention is useful in maintaining a dialog session on the World Wide Web network wherein the widely used hypertext transfer protocol is the network protocol. Further, the present invention allows the server to customize document templates for responding to a client node communication. For the World Wide Web, the document templates are encoded in an enhanced version of the hypertext mark-up language wherein portions of such templates are capable of being replaced with stored dialog session data for customizing a document (particularly, a fill-out form) to be used for responding to a client.

Description:
FIELD OF THE INVENTION 
     The present invention relates to an electronic forms processing and communication system for a communications network utilizing a communication protocol that automatically disconnects communicating nodes one or more times during a dialog session; in particular, the present invention relates to forms processing and communication on the World Wide Web using a hypertext transfer protocol. 
     BACKGROUND OF THE INVENTION 
     There are numerous methods for transferring information over interconnected networks such as the Internet. In one common scenario, a user having a computer for accessing such interconnected networks activates a browser on his/her computer and interacts with a &#34;server&#34; network node (or simply server node) for obtaining data and/or computational services. Thus, the user&#39;s computer assumes the role of a client in a client/server computing model while the server node assumes the role of server (i.e., service provider). 
     Since such interconnected networks may allow an exceptionally large number of anonymous users to dynamically access such server nodes, some communication protocols used by client browsers and server nodes do not maintain a context that persists over a plurality of communications between a client node and a server node. That is, a client node request to a server node is performed without the server node retaining information regarding previous client node requests. Thus, server node access is idempotent in that repeated requests to the same server node application by the same client will yield the same results. In particular, such idempotent or contextless communication is characteristic of client/server communications on the World Wide Web (WWW) using a common application communication protocol such as the hypertext transfer protocol (HTTP). 
     In certain network communications, however, it is desirable to maintain a context throughout a series of discrete network communications between a client node and a server node even though the communication protocol used does not support maintaining such a context. That is, it is desirable to have repeated communication exchanges between a client and server network nodes wherein information from one or more previous communications is retained for use in processing a subsequent communication between the client and server. 
     SUMMARY OF THE INVENTION 
     The present invention is a processing system and method for electronic fill-out forms, wherein forms information is repeatedly exchanged between two nodes on a communications network. More particularly, the present invention allows an application on a network server node and a network browser on a client node of the communications network to repeatedly exchange information, such as fill-out forms information, wherein a continuity in the context of the dialog between these network nodes is maintained by the application on the server node even though the network communications protocol may not provide a sustained network connection between the client and the server node (i.e., the protocol breaks down or disconnects an established communication channel between the client and server node). Furthermore, the present invention provides such a dialog context by utilizing the capabilities of standard network browsers already residing on client nodes, wherein graphics, hypertext and electronic fill-out forms may be provided in a standard fashion through these browsers. 
     The present invention includes a hardware/software configuration on a network server node for storing and associating information related to fill-out forms input received from a client node so that this information may provide a context for the processing of subsequent forms information between the server and client node. The forms processor of the present invention establishes and maintains a client context at the server node by: (a) creating an identifier for uniquely identifying communications between the client and server node that belong to a particular &#34;dialog session&#34; of iterative fill-out form (or more generally, document) information exchanges, and (b) embedding this identifier within a data structure compatible with the network protocol so that the data structure can be provided in communications from the server node to the client node and, additionally, automatically returned with each client node response that is part of the dialog session. In conjunction with the above described identifier (hereinafter also known as a session identifier), the server node maintains a data base of information (hereinafter also known as the user context data base) accumulated regarding currently active dialog sessions with network clients or users. In particular, for each dialog session with a user (at a client node), the accumulated information related to user responses received at the server node is stored in the user context data base so that it is accessible via the session identifier for the dialog session. 
     In providing a document processing dialog session, the present invention may access a plurality of stored document templates, such as fill-out form templates, for selecting an appropriate such template and customizing the selected template with user specific information, for example, from the user context data base. Subsequently, such customized templates may be transferred to the user as a continuation of the dialog session. 
     A networking environment for the present invention is the World Wide Web (WWW), wherein a communications application protocol that is widely used is the hypertext transfer protocol (HTTP), this protocol having the property of terminating client-server node network connections after every server response to a client request. For this environment, it is an aspect of the present invention that the above mentioned session identifier is exchanged between the client and server node using a HTTP compatible format of (name,value) pairs wherein an identifier, &#34;name&#34;, is associated with a value, &#34;value&#34;, for exchanging information between WWW clients and servers as one skilled in the art will appreciate and as will be described further in the detailed description hereinafter. Additionally, it is a further aspect of the present invention to also use a representation of the (name,value) pairs for storing a dialog session context in the user context data base and for subsequently selecting and customizing a selected document template (from the stored plurality of such templates) so that a resulting new document form may be transferred to a client node as a response to a communication from the client node. 
     Note that it is a further aspect of the present invention that in the WWW environment, the document templates are encoded in an enhanced or specialized variation of the widely used hypertext mark up language (HTML). In particular, the specialized HTML includes &#34;replace&#34; instructions wherein each replace instruction, when performed, is replaced by a character string yielding a non-specialized or conventional HTML statement. Further, such replacement character strings are determined by examining the dialog session context in the user context data base. Accordingly, the resulting customized documents are encoded in HTML with no enhancements or specializations, and therefore, when transferred to a client node, can be readily interpreted by most WWW client node browsers as one skilled in the art will appreciate. 
     It is a further aspect of the present invention to provide a programmatic pattern or template for constructing server node document processing applications for constructing customized documents (e.g., fill-out forms) as described above. In particular, the present invention provides one such programmatic template for the WWW network environment. Thus, by incorporating into the programmatic template the steps for performing the semantics of a particular document processing application, a document processing program may be easily constructed that outputs documents compatible with both HTTP and HTML. Accordingly, when executed, such a program, upon receiving (name,value) pairs from a user communication, identifies the dialog session to which the (name,value) pairs correspond, updates the context information for this dialog session (in the user context data base) according to the particular document processing application being performed, then determines a document template to customize using the stored dialog session context, and subsequently customizes the determined document template and transmits it to the user&#39;s client node. 
     Thus, the present invention is particularly advantageous in that each user at a WWW client node, having a conventional WWW browser, may repeatedly interact with an application utilizing the present invention such that a context for successive interactions is accumulated. That is, each user may be supplied with additional information or granted access to additional services depending on the user&#39;s input received by the application in previous network communications. Accordingly, the application may use such a context to automatically tailor documents for responding to the user. Therefore, the present invention may be particularly useful in commercializing the WWW wherein business transactions requiring a user to supply various context related types of information may be conducted substantially automatically. Thus, for example, the user may be presented with electronic fill-out forms customized to the user&#39;s needs for insurance services, credit services, telecommunication services, etc. Further, note that such context sensitive network communications are also particularly useful for network server node applications where a model of a user must be created or accessed such as in many training or teaching applications. 
     Other features and benefits of the present invention will become apparent from the detailed description with the accompanying figures hereinafter. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     FIGS. 1A and 1B present a high level block diagram of the fill-out forms processing system of the present invention; 
     FIG. 2 illustrates a simple fill-out form as it might appear on a browser 36; 
     FIG. 3 is a flowchart of the steps performed when an enhanced common gateway interface script 48 of the present invention is activated subsequently to the server node 28 receiving new document related information from a client node 32; and 
     FIGS. 4-7 are successive illustrations of fill-out form displays on a client node 32 as an example illustrating the operation of the present invention. 
    
    
     DETAILED DESCRIPTION 
     FIGS. 1A and 1B represent a high level configuration of the network document processing system 20 of the present invention for customizing documents presented to a user according to user context information gathered and stored by the present invention during a dialog session with the user. Further, FIGS. 1A and 1B illustrate the present invention within a network environment 24 (such as, in one embodiment, the WWW), wherein a number of users have access to the server node 28 upon which much of the document processing system 20 executes. For illustration purposes only, note that three users are represented in FIG. 1A, each such user interacting with the present invention substantially identically although the sub-networks and communicating intermediate nodes 40a-40c used may be different. Thus, using interactions related to user 1 as illustrative in describing FIGS. 1A and 1B, user 1 interacts with client node (e.g., personal computer) 32a to communicate with the present invention. In particular, user 1 activates a network browser 36a on client node 32a for communicating with other nodes in the network environment 24 such as communicating nodes 40a (which may themselves include a sub-network in which the client node 32a is included). Using some of the nodes 40a as communication pass-through nodes, user 1 may obtain access to server node 28 and, more particularly, to network server 44 which interprets network requests and controls the fulfillment of the requests. The network server 44, in turn, may activate document processing programs including WWW common gateway interface scripts (CGI) 48, three such CGI scripts being illustrated in FIG. 1B. Note that the CGI scripts 48 are enhanced or &#34;specialized&#34; CGI scripts in that they include executable statements not provided in typical WWW CGI scripts, such statements being desirable in the embodiment of the invention as will be discussed below. 
     Upon activation, each such CGI script 48 communicates with the user context data base 52 of the present invention for storing, in a user specific area, newly received user information provided from user input, for example, one of the electronic fill-out form documents displayed on the user&#39;s browser (e.g., browser 36a). Further, each activated CGI script 48 may cause application specific document processing to be performed, each programmatic encoding of such processing being denoted by application specific logic 56. In particular, each application specific logic 56 may be used for examining and/or modifying user information in the user context data base 52. Additionally, each activated specialized CGI script 48 may retrieve a generic electronic document template from the document template storage 60 and subsequently customize or particularize the retrieved document template according to information in the user&#39;s specific area of the user context data base 52. 
     I. The Present Invention and the World Wide Web 
     In one embodiment, the present invention is directed to context preserving electronic document based communications of the World Wide Web. Accordingly, a brief discussion of the World Wide Web (WWW) as it relates to the present invention follows. 
     The WWW adopts a client/server model for distributed computing. That is, two independent processing units or nodes, one referred to as a client and the other referred to as a server, communicate with one another wherein the client commences the communication by sending a request to the server. Subsequently, the server determines how to respond to the request. Further, once a response to the request is received by the client, there will be no further communication between the client and server until the client sends another server request. In particular, a plurality of network nodes 32, each having a WWW browser (e.g., browsers 36), are considered clients and they make requests to a server node 28 for various services and, subsequently, the server node 28 determines how to respond to such requests. As one skilled in the art will understand, such client requests on the WWW may be communicated in the hypertext transfer protocol (HTTP), which is a protocol layered on top of the Transmission Control Protocol/Internet Protocol (TCP/IP). Typically, an HTTP request from a WWW client node asks a WWW server node to return a document formatted in a format known as the hypertext markup language (HTML). Upon receiving a return response from the WWW server node, a WWW browser on the WWW client node subsequently interprets and visually displays the requested document to a user (e.g., user 1). 
     Note that the HTTP is stateless, i.e., a WWW server node may not maintain any information regarding a WWW client after an HTTP request has been satisfied. Furthermore, the HTTP is a protocol for establishing only short-lived communication connections between WWW client and server nodes. That is, upon submittal of a HTTP request by a client node for information from a server node, the underlying network connection protocol, such as TCP/IP, establishes a communication connection between the WWW client and the server node. However, once this single request is satisfied (i.e., the server node detects that the requested information has been transmitted to the client), the server initiates a breaking or disconnecting of the communication connection in accordance with the HTTP protocol. Thus, to establish a dialog session having a series of communications from the WWW client node to the WWW server node interleaved with a series of responses from the WWW server node to the WWW client node where there is a continuity of context throughout the dialog session, some additional context preserving capability must be provided. 
     Each HTML document transferred on the WWW consists of a sequence of WWW browser displayable characters interspersed with specially-formatted strings called &#34;HTML tags.&#34; Many HTML tags are directives used by WWW browsers to determine some aspect of a document&#39;s visual display, such as font size, line break location, etc. To illustrate, in the following HTML fragment, the HTML tags are the strings &#34;&lt;b&gt;&#34; and &#34;&lt;/b&gt;&#34;: 
     This is &lt;b&gt;bold&lt;/b&gt; text. 
     As this illustration shows, many HTML tags come in pairs, effecting the appearance of all text falling between each tag of the pair. Note that the exact appearance of the text is browser-dependent. However, when displayed by a typical WWW browser, the HTML fragment above might appear something like this: 
     This is bold text. 
     HTML documents may contain &#34;hyperlinks.&#34; A hyperlink is an HTML tag in a document which, when activated through user interaction, typically causes a WWW browser to issue a request to some WWW server node for retrieval and delivery of some additional document. Thus, a hyperlink typically includes a specification, known as a &#34;universal resource locator&#34;, defining how a client node is to communicate with a server node. In particular, a universal resource locator includes: a specification of the network protocol to be used, the WWW server node&#39;s network address, and the particular document to be retrieved. For example, the following HTML fragment includes a hyperlink: 
     &lt;a href=&#34;http://www.someserver.com/someDocument.html&#34;&gt; Click here&lt;/a&gt; to see another document. 
     That is, the hyperlink extends from the beginning of this HTML fragment to (and including) the &#34;&lt;/a&gt;&#34;. Further, in the preceding HTMS fragment, the URL is the string &#34;http://www.someserver.com/someDocument.html&#34;. 
     Note that the above HTML fragment may be displayed on a WWW browser as: 
     
         Click here to see another document.                         1.1! 
    
     A hyperlink is normally activated by user interaction such as mouse-clicking on the hyperlink visual display in a WWW browser. To illustrate, referring to  1.1! above, when the user mouse-clicks on the string &#34;Click here&#34;, the WWW browser interprets this as a request to use the HTTP protocol to request the document called &#34;someDocument.html&#34; from the WWW server whose internet address is &#34;www.someserver.com&#34;. 
     Further note that CGI scripts 48 in a WWW environment are programs that may be identified by URLs in user WWW server requests (such as hyperlinks). Such CGI scripts 48 are executed by WWW server nodes in response to requests from WWW browsers. When executed, a CGI script is responsible for generating a document which the executing WWW server will subsequently return to the requesting browser. CGI scripts, then, provide a mechanism whereby a WWW server node may deliver a dynamic, programmatically-generated document, as opposed to delivering a pre-existing, static document, to a requesting WWW client node. 
     Additionally, an HTML document may contain HTML tags for defining one or more fill-out forms wherein, when visually displayed to a user by a WWW browser, each such fill-out form appears as a region of a document containing graphical widgets such as text entry fields, buttons, scrolling lists, etc. Note that HTML tags defining named graphical widgets can be nested within the scope of a fill-out form HTML tag, as one skilled in the art will appreciate. As an example, the following HTML fragment specifies a fill-out form defining two graphical widgets, the first of which is named: &#34;userName&#34;. 
     &lt;form action=&#34;http://www.someserver.com/someCGIScript&#34; method=POST&gt; 
     Please enter your name: &lt;input type=text name=userName&gt; 
     &lt;input type=submit&gt; 
     &lt;/form&gt;  1.2! 
     When displayed by a WWW browser, the fragment  1.2! may appear as in FIG. 2. Note that in this HTML fragment, the second line provides for the display of graphical widget 204, while the third line provides for the display of graphical widget 208. Further, note that the first line of the HTML fragment is an instruction for activating &#34;someCGIScript&#34; with the user input supplied in text box 212 when the user mouse-clicks on the widget 208. 
     Note that every fill-out form is associated with a URL identifying a CGI script (e.g., a specialized CGI 48) to process the user information supplied in the form. In particular, such a URL may be associated with a &#34;submit&#34; button such as widget 208. Further note that when a user activates such a submit button, any values entered into the fill-out form&#39;s named graphical widgets are encoded by the WWW browser as a series of one or more (name,value) pairs, then transmitted to the WWW server node identified by the fill-out form&#39;s associated URL. When that WWW server node subsequently executes the indicated CGI script, these (name,value) pairs are made available to the script as input data. Referring to the previous HTML fragment  1.2! and FIG. 2, if the user types the string &#34;Mary Smith&#34; into the text box 212 and activates the submit button, the WWW browser will send an HTTP request to the WWW server node at the address &#34;www.someserver.com&#34;, requesting the server to execute the CGI script 48 identified as &#34;someCGIScript&#34;, and providing it with the (name,value) pair: (userName,Mary Smith) which is alternatively denoted as &#34;userName=Mary Smith&#34;. 
     It is important to note that for the present invention, in the environment of the WWW, each document template in the document template storage 56 is represented in an extended version of HTML. In particular, the HTML extensions may include specialized HTML tags. In the present invention, such a specialized HTML tag is treated by a specialized CGI script 48 as an instruction to perform the following: (a) interrogate the user context data base 52 and retrieve the &#34;value&#34; field of a (name,value) pair, and (b) replace or rewrite the specialized HTML tag with the retrieved value. More precisely, since such a specialized HTML tag includes a &#34;name&#34; identifier (e.g., name1), upon execution of the tag, a value (e.g., value1) results wherein the pair (name1,value1) occurs in the user specific area for the user whose WWW server request caused the specialized HTML tag to be processed. Subsequently, the resulting value (e.g., value1) replaces the specialized HTML tag in the document template. However, if no corresponding (name,value) pair is found in the user specific area of the user context data base 52, then the specialized HTML tag is simply replaced or rewritten within the document template with the empty string. 
     To illustrate the processing of a specialized HTML tag, suppose a document template being processed by a specialized CGI script 48 contains the following fragment: 
     Hello &lt;replace name=&#34;customerName&#34;&gt;. 
     wherein the &#34;&lt;replace name=&#34;customerName&#34;&gt;&#34; is a specialized HTML tag. Further, suppose the user context data base 52 contains the (name,value) pair (customerName,John Doe) in the user specific area (of the user context database 52) for the user who requested activation of the CGI script 48. After rewriting, the preceding fragment becomes: 
     Hello John Doe. 
     In this case, the specialized HTML tag has the form &lt;replace name=&#34;. . . &#34;&gt;. Note that other types of specialized HTML tag processing are also contemplated. In particular, the types of specialized HTML tags and the processing they receive by specialized CGI scripts 48 is completely application dependent. Three examples of other possible specialized HTML tags and the processing they may receive follow: 
     (i) &lt;replace name=&#34;someName&#34; value=&#34;someValue&#34; text=&#34;someText&#34;&gt; 
     Look up the name &#34;someName&#34; in the user context data base 52. If a (name,value) pair having &#34;someName&#34; as the name is found in the appropriate user specific area, and if the value component of the (name,value) pair is &#34;someValue&#34;, then replace the specialized HTML tag (in the form template being processed) by &#34;someText&#34;; otherwise, replace the tag by the empty string. 
     (ii) &lt;replace name|=&#34;someName&#34; text=&#34;someText&#34;&gt; 
     Look up the name &#34;someName&#34; in the user context data base 52. If a (name,value) pair having &#34;someName&#34; as the name is not found, then replace the specialized HTML tag by &#34;someText&#34;; otherwise, replace the tag by the empty string. 
     (iii) &lt;replace name˜=&#34;aRegExp&#34;&gt; 
     Replace this specialized HTML tag by the value of the first (name,value) pair found in the user specific area of user context data base 52 wherein the value component matches the regular expression &#34;aRegExp&#34;. If no match is found, then replace the specialized HTML tag by the empty string. 
     II. Specialized CGI Script 48 Processing 
     Referring now to FIG. 3, a high level flowchart is provided giving the steps performed by the document processing system 20 at the server node 28 when one of the specialized CGI scripts 48 is activated by a request from a browser 36. It is important to note that the flowchart of FIG. 3 may be considered a pattern for all document processing CGI scripts 48 for the present invention. Thus, additional specialized CGI scripts 48 may be easily provided by utilizing FIG. 3 as a pattern. 
     It is also important to note that an activation of the flowchart of FIG. 3 may be only one of a series of activations by a single user wherein substantially every activation is linked to previous activations of the series in a manner allowing user supplied information (e.g., fill-out form related information) from earlier activations to be used in subsequent activations. To link such a series, hereinafter also denoted as a &#34;dialog session&#34;, a &#34;session identifier&#34; or key is transferred back and forth between the user&#39;s browser and the specialized CGI script(s) 48 sequentially activated during a dialog session. 
     Furthermore, to provide continuity with the description in Section I above, user supplied information used in FIG. 3 (i.e., a specialized CGI script 48) is understood to be a collection of (name,value) pairs as described above. 
     Accordingly, assuming a specialized CGI script 48 represented by the flowchart of FIG. 3 is activated, then in step 304 a collection of one or more (name,value) pairs is obtained as input from a user. This collection of pairs is supplied by the network server 44. Subsequently, in step 308 a determination is made as to whether the input information includes a session identifier for a dialog session between the user (at a client node) and the document processing application of which the present activation of FIG. 3 is a part. If not, then in step 312 a new session identifier is created and in step 316 this new session identifier is designated as the index for a new user specific area in the user context data base 52, wherein user supplied information for the dialog session is to be accumulated to provide a context for successive responses to user communications. In particular, the user supplied information obtained in step 304 is stored in the newly created user specific area as (name,value) pairs. Further, each network communication from this user, having the session identifier, will also be used in updating (name,value) pairs in this user specific area. Accordingly, for notational convenience only, such stored dialog session information in a user specific area of the user context data base 52 will be referred to hereinafter as the &#34;session context&#34;. 
     Alternatively, if in step 308 a session identifier is found, then the current specialized CGI script 48 activation is part of an ongoing dialog session and the steps 312 and 316 have been performed in a previous activation for the dialog session. 
     Regardless of the control branch taken from step 308, step 320 is eventually encountered wherein all newly received (name,value) pairs are merged into the context session indexed by the session identifier of the input received by the current network communication. Note that, in general, the merge operation of this step adds each new (name,value) pair to any previously accumulated pairs for the current session identifier. More precisely, if the &#34;name&#34; component of a new pair is not found in any (name,value) pair previously accumulated, then the new pair is added; otherwise, the new (name,value) pair is substituted for the previously accumulated pair having the same name component. Subsequently, in step 324 a predetermined application specific logic 56 is performed for examining the (name,value) pairs indexed by the current session identifier. In particular, such application specific logic 56 may insert, modify and/or delete (name,value) pairs in the current session context. In doing so, note that each application specific logic 56 includes a programmatic encoding of the semantics for processing document information for the particular application associated with the present dialog session. 
     Subsequently, in step 328 a new document template (referenced by the variable &#34;TEMPLATE&#34;) is determined from the document template storage 60 for customizing and sending to the user. In an embodiment, as will be illustrated in an example below, the determination of the new document template is accomplished by using the &#34;value&#34; component of a predetermined (name,value) pair in the session context. In particular, the value component of this pair includes a list of one or more document templates, one of which is to be accessed as the next document template to process in the dialog session. Note that the determination made in this step may also be specific to the particular processing application for the dialog session. For example, there may be a document template on such a list for each of a number of possible session contexts including at least one document template for informing the user of the dialog session that an error has been detected in the input information. 
     Subsequently, in step 332 all replaceable term or tags in the document template, TEMPLATE, are replaced by components of (name,value) pairs in the current session context. Thus, in the environment of the WWW, where TEMPLATE is specified in an extension of HTML having the specialized HTML tags described previously, the specialized HTML tags of TEMPLATE are replaced resulting in an HTML document to be transferred back to the dialog session user as step 336 indicates. 
     III. An Example Application 
     The present invention may be utilized in an application whereby a customer of a long distance telephony carrier uses a WWW browser to interact with that carrier&#39;s WWW site to determine the tariff pertaining to a long distance call originating from the customer&#39;s residential line at some point in time and of some duration, with due consideration of any applicable discounts or surcharges applicable to that customer. The application presents a series of dynamically-generated HTML documents to the customer, logically linked together to form a single dialog session. 
     Note that in referring to FIGS. 1A and 1B, the present application requires the server node 24 to have access: (a) to an additional data base of long distance tariff rates and customer account information; (b) to some number of specialized CGI scripts 48 designed for the present application; and (c) to some number of specialized form templates contained in the form template storage 60 designed for the present application. 
     For initial contact, the customer contacts the carrier&#39;s WWW site (e.g., server node 28) by specifying to a browser 36 the site&#39;s associated URL. The browser 36 uses the URL to form a network connection to the WWW site. The WWW site responds by transmitting to the browser 36 an HTML document containing a fill-out form presenting fields for the customer to provide identification information such as customer phone number, personal identification number (PIN), or any other information needed to authenticate the identity of the customer. The text for such a fill-out form is given below (note: this and all subsequent example fill-out forms or documents do not represent complete HTML documents; details of HTML having nothing to do with the present invention have been omitted for clarity): 
     &lt;h2&gt;Call tariff Application&lt;/h2&gt; 
     &lt;form action=&#34;http://someserver/tariffApplication&#34;&gt; 
     Enter your phone number: &lt;input name=phone --  number&gt; &lt;br&gt; 
     Enter your 4-digit PIN: &lt;input name=PIN &gt; &lt;br&gt; 
     &lt;input type=hidden name=next --  file value=getlnfo.html&gt; 
     &lt;input type=submit&gt; 
     &lt;/form&gt;  3.1! 
     The resulting screen displayed to the customer is shown in FIG. 4. 
     Subsequently, the customer may enter the requisite form information and submit the form to the WWW server node identified by &#34;someserver&#34; thereby causing the WWW server (e.g., network server 44) to execute the specialized CGI script 48 identified as &#34;tariffApplication&#34;. Further, in executing the tariffApplication specialized CGI script, this script receives input data from the WWW server consisting of (name,value) pairs corresponding to the form data (step 304 of FIG. 3). 
     The tariffApplication CGI script may now execute the remaining steps of FIG. 3. Thus, in step 308, a scan of the input data is performed for a session identifier. Since no session identifier is present, the script generates a new, unique session identifier (step 312). Subsequently, in step 316 a new user specific area in the user context data base 52 is created, and the session identifier itself is inserted into the customer&#39;s newly created user specific area in the user context data base 52. 
     Following this (step 320), the (name,value) pairs corresponding to the received form data are entered into the customer&#39;s user specific area, indexed by the new session identifier. At this point, assuming the customer entered a phone number of &#34;123 456 7890&#34; and a PIN of &#34;1234&#34;, and assuming the session identifier is &#34;1A3&#34;, the customer&#39;s user specific area may be represented as follows: 
     Session 1A3: 
     (phone --  number, 123 456 7890) 
     (PIN, 1234) 
     (next --  file, getinfo.html) 
     (session --  key, 1A3)  3.2! 
     Subsequently, the specialized CGI script, in step 324, executes a predetermined application specific logic 56 wherein the customer account data base is queried using the customer&#39;s phone number and PIN. If the customer&#39;s identity is successfully established, additional information such as the customer&#39;s name and any discount or surcharge information associated with this customer is obtained from the customer account data base. This information is converted into (name,value) pairs and merged into the customer&#39;s user specific area. Next, the tariffApplication CGI script inserts an extra (name,value) pair into the customer&#39;s user specific area to advise the customer of this month&#39;s specials. At this point, the customer&#39;s user specific area may be represented as follows: 
     Session 1A3: 
     (phone --  number, 123 456 7890) 
     (PIN, 1234) 
     (next --  file, getlnfo.html) 
     (session --  key, 1A3) 
     (customer --  name, Mr. John Doe) 
     (discount, Frequent Caller&#39;s Program) 
     (specials, Note: This month, half price on all out-of-state calls| &lt;br&gt;)  3.3! 
     Next, in step 328, a determination is made as to the next document template, from the document template storage 60, to process. Since the customer&#39;s user specific area (e.g., as in  3.3!) contains the entry (next --  file . getInfo.html), the document template identified by getinfo.html is chosen. Assume this document contains the following specialized HTML statements: 
     Hello &lt;replace name=customer --  name&gt;.&lt;br&gt; 
     Your phone number is &lt;replace name=phone --  number&gt;.&lt;br&gt; 
     You are eligible for the following discounts: &lt;replace name=discounts&gt;.&lt;br&gt; 
     &lt;replace name=specials &gt; 
     &lt;replace name=error&gt; 
     &lt;form action=http://someserver/computeTariff&#34;&gt; 
     Enter the calling number: &lt;input name=call --  number value=&lt;replace name=call --  number&gt;&gt; &lt;br&gt; 
     Enter the time of this call: &lt;input name=call --  time value=&lt;replace name=call --  time&gt;&gt; &lt;br&gt; 
     Enter the date of this call: &lt;input name=call --  date value=&lt;replace name=call --  date&gt;&gt; &lt;br&gt; 
     Enter the duration of this call: &lt;input name=call --  length value=&lt;replace name=call --  length&gt;&gt; &lt;br&gt; 
     &lt;input type=hidden name=session --  key value=&lt;replace name=session --  key&gt;&gt; 
     &lt;input type=hidden name=next --  file value=answer.html,error.html&gt; 
     &lt;input type=submit&gt; 
     &lt;/form&gt;  3.4! 
     In the above document template excerpt  3.4!, all the &lt;replace . . . &gt;HTML tags are specialized. Thus, in step 332 all these specialized tags are rewritten using the contents of the customer&#39;s user specific area. Upon completion of step 332, the following HTML document is obtained: 
     Hello Mr. John Doe.&lt;br&gt; 
     Your phone number is 123 456 7890.&lt;br&gt; 
     You are eligible for the following discounts: Frequent Caller&#39;s Program.&lt;br&gt; 
     Note: This month, half price on all out-of-state calls| &lt;br&gt; 
     &lt;form action=http://someserver/computeTariff&gt; 
     Enter the calling number: &lt;input name=call --  number value=&gt; &lt;br&gt; 
     Enter the time of this call: &lt;input name=call --  time value=&gt; &lt;br&gt; 
     Enter the date of this call: &lt;input name=call --  date value=&gt; &lt;br&gt; 
     Enter the duration of this call: &lt;input name=call --  length value=&gt; &lt;br&gt; 
     &lt;input type=hidden name=session --  key value=1A3&gt; 
     &lt;input type=hidden name=next --  file value=answer.html,getinfo.html&gt; 
     &lt;input type=submit&gt; 
     &lt;/form&gt;  3.5! 
     Note that since the names &#34;error&#34;, &#34;call --  number&#34;, &#34;call --  time&#34;, &#34;call --  date&#34; and &#34;call --  length&#34; do not appear in the customer&#39;s user specific area, the corresponding specialized HTML tags have been replaced by the empty string. 
     Subsequently, when HTML form excerpt  3.5! is delivered to the customer&#39;s WWW browser, the customer sees a screen similar to that of FIG. 5. 
     At this point, assume the customer fills out all the requested information except the &#34;Enter the duration of this call:&#34; and then presses the submit button. A data transfer to the carrier&#39;s WWW server node is performed. This causes the WWW server &#34;someserver&#34; (e.g., network server 44) to execute the specialized CGI script identified as &#34;computeTariff&#34;. Note that the server provides computeTariff with, for example, the following (name,value) pairs: 
     (call --  number, 111 222 3333) 
     (call --  time, 8:30 PM) 
     (call --  date, September 21) 
     (session --  key, 1A3) 
     (next --  file, answer.html,getinfo.html)  3.6! 
     The computeTariff specialized CGI script searches this data, looking for a session identifier. Accordingly, it extracts the value of the name &#34;session --  key&#34;, that is to say, &#34;1A3&#34;, then merges all the input data into the customer&#39;s user specific area identified by the session identifier, 1A3. Next, application specific logic 56 is executed by the computeTariff script for examining all the (name,value) pairs in the customer&#39;s user specific area. Assuming the application specific logic determines that there is no &#34;call --  duration&#34; name in the customer&#39;s user specific area and therefore cannot process the &#34;answer.html&#34; HTML document template without this information, computeTariff may choose instead to process the getinfo.html document template after first merging the following (name,value) pair into the customer&#39;s user specific area: 
     (error, Error:&lt;br&gt; 
     You forgot to enter the duration of this call. 
     Please enter and resubmit.&lt;br&gt;)  3.7! 
     Consequently, the application specific logic 56 again processes the &#34;getinfo.htmll&#34; document template, and then transmits the following result to the customer&#39;s browser: 
     Hello Mr. John Doe. &lt;br&gt; 
     Your phone number is 123 456 7890. &lt;br&gt; 
     You are eligible for the following discounts: Frequent Caller&#39;s Program. &lt;br&gt; 
     Note: This month, half price on all out-of-state calls| &lt;br&gt; 
     Error: &lt;br&gt; 
     You forgot to enter the duration of this call. 
     Please enter and resubmit. &lt;br&gt; 
     &lt;form action=http://someserver/computeTariff&gt; 
     Enter the calling number: &lt;input name=call --  number value=111 222 3333&gt; &lt;br&gt; 
     Enter the time of this call: &lt;input name=call --  time value=8:30 PM &gt; &lt;br&gt; 
     Enter the date of this call: &lt;input name=call --  date value=September 21 &gt; &lt;br&gt; 
     Enter the duration of this call: &lt;input name=call --  length value=&gt; &lt;br&gt; 
     &lt;input type=hidden name=session --  key value=1A3&gt; 
     &lt;input type=hidden name=next --  file value=answer.html,getinfo.html&gt; 
     &lt;input type=submit&gt; 
     &lt;/form&gt;  3.8! 
     Since the names &#34;error&#34;, &#34;call --  number&#34;. &#34;call --  date&#34; and &#34;call-time&#34; are now all present in the customer&#39;s user specific area, their values may serve to pre-populate graphical widgets in the resulting fill-out form. Thus, upon transfer to the customer&#39;s browser, the customer sees a document similar to FIG. 6. 
     Next, assuming the customer enters the duration of this call, and presses the submit button, the WWW server 44 &#34;someserver&#34; executes the specialized CGI script 48 identified as &#34;computeTariff&#34; once more. This time, the server provides the CGI script computeTariff with the following (name,value) pairs: 
     (call --  number, 111 222 3333) 
     (call --  time, 8:30 PM) 
     (call --  date, September 21) 
     (call --  length, 1 hr.) 
     (session --  key, 1A3) 
     (next --  file, answer.html,getlnfo.html)  3.9! 
     Subsequently, the application specific logic 56 executed on the previous communication from this customer is again invoked (step 324). However, during this invocation the application determines that it has now received all the required user data, so it removes the &#34;error&#34; (name,value) pair of  3.7! from the customer&#39;s user specific area. The application specific logic 56 then consults the data base of long distance tariff rates and computes the tariff for this call, and writes the result into the customer&#39;s user specific area as the (name,value) pair: 
     (tariff, $5.00) 
     Next, a determination is made as to which document template to customize for the customer. Assume the answer.html document template is selected, which contains the following: 
     The tariff for calling &lt;replace name=call --  number&gt; from &lt;replace name=phone --  number&gt; 
     on &lt;replace name=call --  date&gt; at &lt;replace name=call --  time&gt; for &lt;replace name=call --  length&gt; 
     is &lt;br&gt; &lt;h2&gt; &lt;replace name=tariff&gt;.&lt;/h2&gt;  3.10! 
     At this point, the customer&#39;s user specific area contains the following (name,value) pairs: 
     Session 1A3: 
     (phone --  number, 123 456 7890) 
     (PIN, 1234) 
     (session --  key, 1A3) 
     (customer name, Mr. John Doe) 
     (discount, Frequent Caller&#39;s Program.) 
     (specials, Note: This month, half price on all out-of-state calls| &lt;br&gt;) 
     (call --  number, 111 222 3333) 
     (call --  time, 8:30 PM) 
     (call --  date, September 21) 
     (call-length, 1 hr.) 
     (next --  file, answer.html,getinfo.html) 
     (tariff, $5.00)  3.11! 
     Therefore, the display of the resulting HTML document transferred back to the customer will be similar to FIG. 7. 
     The dialog session now being completed once this last document transfer to the customer is performed, the CGI script 48 deletes the customer&#39;s user specific area from the user context data base 52. 
     The foregoing discussion of the invention has been presented for purposes of illustration and description. Further, the description is not intended to limit the invention to the form disclosed herein. Consequently, variation and modification commensurate with the above teachings, within the skill and knowledge of the relevant art, are within the scope of the present invention. The embodiment described hereinabove is further intended to explain the best mode presently known of practicing the invention and to enable others skilled in the art to utilize the invention as such, or in other embodiments, and with various modifications required by their particular application or uses of the invention. It is intended that the appended claims be construed to include alternative embodiments to the extent permitted by the prior art.