(12) United States Patent
`Haverstock et al.
`
`US006192415B1
`US 6,192,415 B1
`*Feb. 20, 2001
`
`(10) Patent N0.:
`(45) Date of Patent:
`
`(54)
`
`WEB SERVER WITH ABILITY TO PROCESS
`URL REQUESTS FOR NON-MARKUP
`LANGUAGE OBJECTS AND PERFORM
`ACTIONS ON THE OBJECTS USING
`EXECUTABLE INSTRUCTIONS CONTAINED
`IN THE URL
`
`(75)
`
`Inventors: Paul Haverstock, Acton, MA (US);
`Miguel Estrada, Nashua, NH (US);
`Julio Estrada, Carlisle, MA (US)
`
`(73)
`
`Assignee: International Business Machines
`Corporation, Armonk, NY (US)
`
`(*)
`
`Notice:
`
`Under 35 U.S.C. 154(b), the term of this
`patent shall be extended for 0 days.
`
`This patent is subject to a terminal dis
`claimer.
`
`(21)
`(22)
`
`(60)
`
`(51)
`(52)
`
`(58)
`
`Appl. No.: 09/100,117
`Filed:
`Jun. 19, 1998
`
`Related US. Application Data
`Provisional application No. 60/050,153, ?led on Jun. 19,
`1997.
`
`Int. Cl.7 ........................... .. G06F 15/16; G06F 15/17
`US. Cl. ........................ .. 709/245; 709/201; 709/202;
`707/513
`Field of Search ........................... .. 707/513; 709/202,
`709/245
`
`(56)
`
`References Cited
`U.S. PATENT DOCUMENTS
`
`5,745,360 * 4/1998 Leone et al. ....................... .. 707/513
`5,819,302 * 10/1998 Nielsen ..... ..
`.. 707/523
`5,848,410 * 12/1998 Walls et al. ..
`707/4
`5,944,791 * 8/1999 Scherpbier ..
`.. 709/218
`5,956,483 * 9/1999 Grate et al. ........................ .. 709/203
`* cited by examiner
`Primary Examiner—Mark H. Rinehart
`Assistant Examiner—Paul Kang
`(74) Attorney, Agent, or Firm—Hunton & Williams
`(57)
`ABSTRACT
`
`A system for enabling access to non-HTML objects from a
`Web broWser. The system includes a database for storing
`non-HTML objects. A system user requests a non-HTML
`object from a database using a Web broWser. The Web
`broWser transmits the request to a server via a HTTP server
`and module. The server locates and retrieves the document
`requested. The module translates the document to a format
`supported by the Web broWser. The HTTP server commu
`nicates the translated object to the Web broWser over a
`network. The Web broWser then presents the translated
`object to the system user. The system also enables a server
`to respond to a URL requests containing action commands
`from a broWser. Action commands and additional arguments
`are input into the URL. The server receives the request for
`the URL and processes the actions and arguments identi?ed
`in the URL.
`
`16 Claims, 3 Drawing Sheets
`
`Client
`12
`
`4
`
`5 """"" GAE;
`:
`14
`I
`I
`
`g
`
`Network
`54
`
`Terminal
`
`26
`
`Browser
`28
`
`4
`
`5
`0
`:
`2
`4
`:
`
`4
`:
`;
`
`URL
`Interface
`46
`all; Interface
`Module
`7 Module
`,0 i
`
`Non-HTML
`Server
`Mod a
`24“
`
`HTML
`Translator
`"“
`
`At
`
`I
`I
`1
`
`I
`I
`I
`:
`
`1
`
`'
`
`Non-HTML
`Database
`16
`
`18a- 18n
`
`62a-62n
`
`2O
`
`22a~ 22n
`
`' """""""""""" ' “
`- - - ' - ' ' ' I l - - _ - ' ' F ' ' _ ‘
`
`\j/
`
`1 0
`
`HTML Database
`Index
`48
`Sign
`64
`
`3
`
`Son
`gm
`
`0 m
`
`HTML
`Objects
`503-50"
`
`AKAMAI
`EXHIBIT 1005
`
`

`
`U.S. Patent
`
`30.10
`
`US 6,192,415 B1
`
`Or
`
`._s_.:..
`
`28.30
`
`comaom
`
`
`
`E:3mmfimao.__>_E
`
`
`
` UmlullE1AHIN_.mmmmmH3.Hvcoémz2_..ofi_m:m._._..9._45::_._mines..$.a_:uo_2
`
`..m>_om.I.Fcmomam"m_=.%.28_2.2:_at:m"Bzmw
`:3$3".__>:.I-coz#3T9__
`
`4_>FI-:oz__Em__OH3H”Ezmm“
`mmmnflmoW_N_‘
`8.m.w_=__
`
`.........................................--__m:_.E3
`
`Smm
`
`1D!»a3W..mm2,o.m
`
`
`
`

`
`U.S. Patent
`
`Feb. 20, 2001
`
`Sheet 2 of3
`
`US 6,192,415 B1
`
`N 9%.?“
`
`35.62 3056;
`62mm 2262
`
`wN 2:022
`0:602 mm =52
`
`3.58m
`
`225E
`
`ow
`
`momtog
`
`
`
`@582 at:
`
`
`
`mm 62mm
`
`cm
`
`vm
`
`
`Ewwo @582
`
`938800 Em ,
`59650
`
`mm
`
`minmnow
`
`62mm
`
`vr
`
`

`
`U.S. Patent
`
`Feb. 20, 2001
`
`Sheet 3 of3
`
`US 6,192,415 B1
`
`mm
`
`O
`
`5a
`
`22“. — $5532 63932
`
`o 0
`
`O O
`
`0
`
`*5
`
`mg m com S
`
`O
`
`O O
`
`O O
`
`cow O
`
`Mu mvHHFWMnH
`
`22“. 5m
`
`.5285
`
`N»
`
`Em _oo.r
`
`E
`
`.E:
`
`E
`
`
`
`8:22 Esoniim
`
`2 is
`
`3m 83952
`
`m8
`
`

`
`US 6,192,415 B1
`
`1
`WEB SERVER WITH ABILITY TO PROCESS
`URL REQUESTS FOR NON-MARKUP
`LANGUAGE OBJECTS AND PERFORM
`ACTIONS ON THE OBJECTS USING
`EXECUTABLE INSTRUCTIONS CONTAINED
`IN THE URL
`
`RELATED APPLICATIONS
`
`This application claims priority based on US. Provisional
`Patent Application Ser. No. 60/050,153, entitled “Web
`Server Application,” ?led Jun. 19, 1997. This application is
`also related to co-pending US. patent applications entitled,
`“Web Server Enabling BroWser Access to HTML and Non
`HTML Documents,” Serial No. 09/100,131, ?led hereWith,
`“Web Server With Direct Mail Capability,” Serial No.
`09/100,130, ?led hereWith, “Web Server With Automated
`Work?oW,” Serial No. 09/100,129, ?led hereWith, “Web
`Server Providing Role-Based Multi-level Security,” Serial
`No 09/100,128 ?led hereWith, “Web Server With Unique
`Identi?cation of Linked Objects,” Ser. No. 09/100,118, ?led
`hereWith, “Web Server With Integrated Scheduling and
`Calendaring,” Ser. No. 09/100,119, ?led hereWith, “Web
`Server Providing HTML Pages Embedded With Non-HTML
`VieWs,” Ser. No. 09/100,120, ?led hereWith, and “Web
`Server Enabling Attachment of HTML and Non-HTML
`Files To Web Pages,” Ser. No. 09/100,121, ?led hereWith.
`
`10
`
`15
`
`20
`
`25
`
`FIELD OF THE INVENTION
`
`The invention relates to a Web server that has the ability
`to process a URL With action commands.
`
`30
`
`2
`desired links. Editing an HTML page or a link typically
`requires using HTML to edit the original Web page or link.
`One signi?cant problem With HTML links is that if a Web
`page (or other object is linked to it) is moved or deleted any
`links to that page or object needs to be manually changed or
`a “?le not found” message Will appear When a user clicks on
`the link.
`One limitation of Web broWsers and Web servers is that
`they Were designed primarily to access HTML documents.
`BroWsers typically cannot cause a Web server to retrieve and
`return non-HTML documents. This inhibits a user from
`accessing non-HTML documents, objects or databases from
`a Web broWser. Non-HTML objects, for example, may
`include non-HTML documents, stored vieWs for documents
`in a database, identi?cation ?les stored in a user directory
`and many other types of objects. VieWs provide a convenient
`Way to index a plurality of documents. Identi?cation ?les
`may comprise information about a system user (e.g., elec
`tronic mail address, role, pro?le, etc.).
`One example of a non-HTML database is Lotus Notes.
`Lotus Notes is a popular softWare system, rich With a
`number of Well-knoWn functions. These functions, hoWever,
`are typically accessed via a client terminal (loaded With
`Lotus Notes client softWare) communicating With a server
`(loaded With Lotus Notes server softWare). Because Notes is
`not an HTML-based application, it has not been practical to
`access objects in a Notes database via a standard Web
`broWser.
`Standard Web servers can read a URL to locate a page in
`pages speci?ed in the URL. One limitation of existing
`broWser/Web server systems is that they cannot access
`non-page based databases. For example, a knoWn, popular
`database is Lotus Notes®. Notes® databases include Forms,
`Document VieWs, etc. Because URLs specify page
`locations, URLs have not to date been useable to access
`other types of objects.
`Using broWser technology, a system user can read or ?ll
`out a form With data to create a page. But cannot, for
`example, create a form from a Web client (broWser).
`Typically, this requires programming (e.g., using a computer
`gateWay interface (CGI)). A simple example, is as folloWs:
`
`<FORM METHOD=POST ACTION=PCWEEK/
`PROCESS.EXE>
`
`<INPUT TYPE=TEXT NAME=SSN>
`
`</FORM>
`
`35
`
`40
`
`45
`
`BACKGROUND OF THE INVENTION
`
`Web broWsers such as Netscape Navigator and Microsoft
`Internet Explorer are Well knoWn. Web broWsers are soft
`Ware residing on a client (e.g., a personal computer). Via the
`broWser, the client can communicate With a Web server to
`enable access to and vieWing of Hypertext Markup Lan
`guage (HTML) documents. AWeb server typically includes
`a server (e.g., a UNIX- or WindoWs NT-based computer)
`connected to a netWork (e.g., the Internet, an intranet or
`other network), Web server softWare con?gured With the
`host name of the server and the location of HTML objects
`on the servers and the HTML objects stored by that server.
`In general operation, to access a Web page, a user enters
`a request by specifying a uniform resource locator (URL)
`via the broWser and hitting “Submit” (or another function
`key) and the URL is sent to the Web server using HTTP. The
`Web server responds by locating the requested HTML docu
`ment and returning it to the broWser. The broWser receives
`the HTML document, interprets the HTML codes, translates
`them into a Web page, and displays the Web page. In this
`Way, Web broWsers enable access to the vast number of
`HTML documents via the World Wide Web, the Internet or
`intranets. HTML generally is Well knoWn. A primary pur
`pose of HTML is to describe hoW to format the text (and
`other content) of a Web page. HTML uses tags to indicate
`hoW text of a Web page should be displayed and to specify
`the URL of objects to Which a page is linked. HTML objects
`are commonly stored on a Web server as standard text ?les
`With a HTM or HTML extension. Linking is a poWerful
`feature of HTML. One draWback With HTML links is that
`links are created by coding a page With HTML tags to link
`it to other objects (e.g., another document or a speci?c
`location Within a document). Therefore creating Web pages
`and links requires a Working knoWledge of HTML and the
`time required to Write HTML code a create a page and any
`
`50
`
`This simple code resides on the Web server.
`
`SUMMARY OF THE INVENTION
`
`55
`
`60
`
`65
`
`One object of the invention is to overcome these and other
`draWbacks present in existing systems.
`Another object of the invention is to provide a Web server
`that can respond to requests from a Web broWser for either
`HTML or non-HTML documents and return the requested
`documents to the Web broWser.
`Another object of the invention is to provide Web broWser
`access to objects other than HTML pages by incorporating
`action commands into URLs.
`Other objects and advantages of the invention also exist.
`According to one embodiment of the invention, the sys
`tem comprises a novel Web server for a client/server
`netWork, Where the client side is equipped With a standard
`broWser. The server comprises standard Web server func
`
`

`
`US 6,192,415 B1
`
`3
`tionality (e.g., HTTP server), an HTML translator, a server
`side software (e.g., Lotus Notes server softWare) and a
`database (e.g., a Lotus Notes database). Signi?cantly, the
`database does not need HTML objects. Preferably, the server
`receives a URL-based request from a broWser via HTTP, the
`HTTP server and HTML translator determine the object
`(e.g., documents or databases) speci?ed by the URL,
`retrieves that object, translates that object to HTML format
`and sends the HTML doWnloaded object to the client side
`broWser for display.
`According to one aspect of the invention, the system
`enables a server to respond to URL requests containing
`action commands from a broWser. A system user inputs a
`URL into a broWser. In addition to identifying the object, the
`system user may also input action commands and arguments
`in the URL. The server locates and retrieves the object and
`processes the actions and arguments identi?ed in the URL.
`
`15
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`FIG. 1 is a block diagram illustrating an overall system in
`accordance With one embodiment of the invention.
`FIG. 2 is a block diagram illustrating an interface module
`in accordance With one embodiment of the invention.
`FIG. 3 is a vieW of a display in accordance With one
`embodiment of the invention.
`
`25
`
`DETAILED DESCRIPTION OF THE
`PREFERRED EMBODIMENTS
`
`As schematically illustrated in the block diagram of FIG.
`1, one aspect of the invention relates to a client/server
`netWork system 10 enabling access to both HTML objects
`50a—50n (e.g., HTML documents) and non-HTML objects
`18a—18n using a Web broWser 28 residing on a terminal 26.
`Preferably, Web broWser 28 supports Internet and Web
`protocols (e.g., HyperText Transfer Protocol (HTTP) and
`TCP/IP). The system may further comprise a client 12 to
`enable a non-broWser client access to non-HTML server
`module 24 to retrieve non-HTML objects 18a—18n from
`non-HTML database 16.
`A server 14 preferably comprises a HTTP server module
`30, interface module 32 and non-HTML server module 24.
`As further illustrated in FIG. 1, the server side of system 10
`may comprise a non-HTML database 16 in communication
`With server 14. Preferably, non-HTML database 16 stores
`one or more non-HTML objects 18a—18n, each at least some
`of Which having one or more non-HTML ?elds 62a—62n) and
`a user directory 20. User directory 20 includes one or more
`user objects 22a—22n. User objects 22a—22n may include
`information about a user (e.g., electronic mail address, role,
`pro?le, etc.). Terminal 26 and server 14 can be in commu
`nication via a netWork 54 (e.g., Internet, Intranet or other
`network).
`According to one aspect of the invention, a user submits
`a URL-based request for an object via broWser 28. The
`request is passed to server 14 using HTTP (or other
`protocol). Server 14 receives the request via HTTP server
`module 30 and passes object location information to inter
`face module 32 via URL interface 46. URL interface 46
`transmits that information to non HTML server module 24.
`Non-HTML server module 24 retrieves the requested object
`and passes it to interface module 32. A HTML translator
`portion 44 of interface module 32 translates the non-HTML
`object to a HTML representation of the requested object and
`the HTML representation is returned to broWser 28 via
`HTTP server module 30.
`
`35
`
`45
`
`55
`
`65
`
`4
`System 10 also enables broWser 28 to access HTML
`objects 50a—50n using HTTP server 30 or a conventional
`Web server 56 in a knoWn manner. A conventional editor
`may be used to edit HTML objects Within the system. A
`conventional technique (e.g., a computer gateWay interface
`(CGI)) may be used to store the edited HTML objects in the
`HTML database.
`Thus, one advantage of the invention is that server 14
`enables a broWser 28 to request both HTML objects
`50a—50n and non-HTML objects 18a—18n. Additional
`advantages derive from this capability. For example, one
`signi?cant advantage is that the invention exposes poWerful
`resources available in non-HTML databases 16 to a Web
`broWser 28 according to one embodiment of the invention.
`Preferably, the invention comprises a Lotus Notes server.
`Advantageously, even With this embodiment a standard
`broWser-based client may be used. As detailed beloW, Lotus
`Notes provides the non-HTML server module 24 a rich set
`of services that has made it a leading messaging and
`groupWare platform. By expressing Notes capabilities to the
`Web (using a broWser) via the present invention, Web
`developers can take advantage of an architecture that inte
`grates database, security, directory, messaging, Work?oW,
`replication, and application development technology in a
`single platform heretofore lacking in broWser based systems
`using HTML objects.
`Lotus Notes, for example, is a robust system offering
`many features (e.g., forms, vieWs, navigators, agents,
`folders, etc.). These resources in general are knoWn,
`hoWever, the ability to expose the features to a Web broWser
`is accomplished according to one aspect of the invention.
`Because Lotus Notes provides these and other features,
`Notes Will be used to illustrate hoW features of a non-HTML
`database may be exposed to a Web broWser using the
`invention. Although Lotus Notes is used by Way of example,
`the invention may be used With other non-HTML databases.
`One advantage of the invention is that it enables broWser
`28 access to non-HTML objects (e.g., user objects 22a—22n)
`via a non-HTML server module 24. Through communica
`tion With the non-HTML server module 24, broWser 28 is
`provided With additional functionality (i.e., functions sup
`ported by non-HTML server module). For example, non
`HTML server module may comprise a security module.
`Because broWser 28 retrieves non-HTML objects using
`non-HTML server module 24, the security module controls
`access to the non-HTML objects based on predetermined
`criteria. Therefore, this function is exposed to broWsers.
`For example, system 10 retrieves non-HTML objects
`18a—18n via non-HTML server module 24. By communi
`cating With non-HTML server module 24, system 10 permits
`Web broWser 28 to utiliZe functions of non-HTML server
`module 24. For example, a system user may access non
`HTML objects 18 from non-HTML database 16 (e.g., a
`Lotus Notes database). When non-HTML object 18a is
`retrieved using non-HTML server module 24, functions
`associated With non-HTML object 18a become available to
`the system user. For example, non-HTML object 18a may
`comprise an agent Which transmits a message or facsimile
`notifying another system user that non-HTML object 18a
`has been accessed. The invention exposes this and other
`functions provided by non-HTML server modules 24 to
`broWsers 28.
`The system may use a bi-directional replication process to
`ensure that all system users are accessing the most recent
`versions of HTML objects 50a—50n. The replication process
`used is ef?cient because it is selective, can be scheduled, and
`
`

`
`US 6,192,415 B1
`
`15
`
`25
`
`5
`can perform at the ?eld-level. Selective replication enables
`administrators to replicate only a subset of data Within the
`HTML database (for example, speci?c databases or HTML
`objects). Replication may be scheduled to run When net
`Working costs are minimiZed. With ?eld level replication,
`only those ?elds Within HTML objects that are neW or have
`been changed on either side of the replication process need
`to be replicated. With these sophisticated replication capa
`bilities as a part of the infrastructure, developers can focus
`on creating Web applications Which enable business pro
`cesses Within and across lines of business and corporate
`boundaries. The bene?t to the user is easier manageability of
`databases and data integrity in all sites.
`During replication, directory changes are also replicated,
`because the directory is simply another database in the
`invention, With the same structure and properties as a Web
`page library. Therefore, for example, discussion forums can
`be replicated, because discussions are simply another
`instance of a database.
`When a user requests an HTML object from a HTML
`database using a URL, the URL typically only identi?es the
`object, Without identifying any non-HTML commands. In
`general, HTTP servers use the URL to identify the location
`of a resource (e.g., an object). They typically do not perform
`action on or relating to the object itself. By exposing Lotus
`Notes functionality to a broWser-based system, the system of
`the invention, hoWever, enables non-HTML actions to be
`identi?ed in the URL and the action to be performed on or
`relating to the object. For example, a system user Wishing to
`retrieve a sales record for a salesperson (“John”) Working in
`the east coast division of “Company A” may enter the
`folloWing URL into a broWser: http://WWW.companya.com/
`sales.nsf/east/john?opendoc. This URL permits server 24
`(e.g., Notes server) to retrieve the ?le containing John’s
`sales records and open that document. Other actions may
`also be used (e. g., run ?le, create neW ?le, etc.) Additionally,
`the system user may identify additional non-HTML argu
`ments placed on the ?le being retrieved. For example, John’s
`sales records ?le may be opened to display only John’s last
`ten (10) sales, sales that occurred Within the past ?ve (5)
`years, etc.
`Identifying non-HTML actions and arguments in the URL
`alloWs system users to retrieve objects and identify actions
`With a single input command Without requiring program
`ming code. This is a signi?cant advantage over prior systems
`that cannot process such action commands included in a
`URL. For example, in some prior systems, if a system user
`Wishes to have an action carried out When a particular object
`is retrieved, the action must be preprogrammed into the code
`or identi?ed outside the URL (e.g., get or post actions). The
`ability to enable functions Without require preprogramming
`is one feature of the invention.
`Preferably, When interface module 32 receives a URL
`based request, interface module 32 parses the URL to
`determine non-HTML object information (e.g., type,
`identity, location, etc.). If the URL includes an action
`command to be performed on the non-HTML object, inter
`face module 32 also determines the action to be performed.
`This information is passed to non-HTML server module 24
`Which retrieves the requested non-HTML object. Interface
`module 32 then translates the requested non-HTML object
`into an HTML object. If an action command is speci?ed in
`the URL, interface module 32 determines the HTML com
`mand corresponding to the non-HTML command supported
`by non-HTML server module 24 (e.g., open, create, delete,
`etc.). As part of the process, the HTML command is per
`formed and the HTML object is communicated to Web
`broWser 28 via HTTP server module 30.
`
`6
`Translating commands may be performed using a rules
`based translation. A rules-based translation mediates
`betWeen tWo or more server formats and determines com
`mands corresponding to the other object formats. For
`example, Lotus Notes includes a table sort command. This
`permits tables to be sorted according to column headings. If
`a user Wishes to sort a table according to a particular
`heading, the user may “click” on the heading. Notes then
`sorts the table according to the heading. If a system user
`requests a non-HTML object (e.g., a table) from a Notes
`database and speci?es an action command (e.g., sort) in the
`URL, interface module 32 translates the actions to a corre
`sponding Notes action and performs the action command.
`Notes creates a vieW including the sorted table. Interface
`module 32 then provides a link to the vieW created.
`Collaboration sites handle the activity that occurs among
`people and the information that they handle. Typical col
`laborative activities include discussions and brainstorming,
`revieW and approval cycles, human resource employee
`revieWs and candidate intervieW processes. The creation of
`most content is a collaborative process: creating a press
`release, White paper, or even a job posting normally involves
`more than one person. Providing customer service after a
`sale has been made is also a collaborative process that
`involves the customer and at least one other person inside a
`company. That is, collaboration is an integral activity that
`surrounds content and commerce. There is very little, if any,
`Web technology in place to effectively support collabora
`tion.
`One embodiment of the invention relates to a Web appli
`cation server, its basic architecture and the integral services
`that lend themselves to the rapid development and deploy
`ment of collaborative applications that support content and
`commerce.
`To realiZe these and other capabilities, server 14 may
`further comprise various modules as depicted in FIG. 2. For
`example, HTTP server 30 may further comprise a mail
`application module 34 and a scheduling and calendaring
`application module 36. Interface module 32 may further
`comprise a Work?oW module 38, command cache 42 and a
`security module 40.
`The additional components shoWn in FIG. 2 enable vari
`ous capabilities to be provided to enhance the advantages of
`the system. Each of these components and examples of the
`added capabilities is described beloW.
`FIG. 3 illustrates a HTML object 50a in accordance With
`one embodiment of the invention. System 10 permits a
`representation of non-HTML objects 18a—18n to be embed
`ded Within HTML objects 50a—50n. For example, a system
`user may retrieve HTML object 50a. The system user may
`request non-HTML object 18a to be displayed Within HTML
`object 50a. System 10 retrieves non-HTML object 18a.
`Non-HTML object 18a is translated to a HTML represen
`tation 5011 of non-HTML object 18a. System 10 uses HTML
`representation 5011 to embed HTML representation 5011 in
`HTML object 50a. FIG. 3 shoWs HTML object 50a With
`non-HTML objects (and other objects) embedded therein
`(e.g., pull-doWn menus 72, a tool bar 74, a URL identi?er 76,
`a form 78, navigators 80, links 66, attachments 82 and ?elds
`62). After non-HTML object 18a is embedded Within HTML
`object 50a, HTML object 50a may be saved as another
`object Which includes embedded non-HTML object 18a.
`Preferably, HTML representation 50n comprises a table
`tag and HTML formatting tags. HTML tags are codes used
`in a HTML object that determine the layout of a HTML
`object. VieWs may comprise links to other vieWs. For
`
`35
`
`45
`
`55
`
`65
`
`

`
`US 6,192,415 B1
`
`10
`
`15
`
`7
`example, an object may contain a graphical representation of
`a vieW. The representation provides a link to the vieW Which
`is retrieved When a user “clicks” on the representation.
`When a system user “clicks” on the representation, a URL
`request for that vieW is transmitted to HTTP server module
`30. HTTP server module communicates the request to URL
`interface 46 of interface module 32. URL interface 46
`converts the request into a format supported by non-HTML
`server module 24. Non-HTML server module 24 locates and
`retrieves the vieW requested and transmits the vieW to
`interface module 32. HTML translator 44 translates the vieW
`into HTML and passes the translated vieW to HTTP server
`module 30. HTTP server module 30 communicates the vieW
`requested to broWser 28 for presenting to the system user.
`This process may be repeated for each additional vieW
`requested by the system user.
`Navigators may also be embedded Within HTML objects
`50a—50n. Navigators assist system users in moving through
`documents. Navigators may be graphical representations or
`text that identify other portions of a document, other
`documents, etc. For example, a non-HTML object is
`requested by a system user. The non-HTML document may
`comprise a navigator. Module 30 translates the non-HTML
`object and navigator into HTML object 50a.
`System 10 may also comprise a command cache 42.
`Command cache 42 maintains a record of a predetermined
`number of commands input by a system user. Commands
`may be stored based on system users. For example, a system
`user inputs a command, system 10 stores the command in
`command cache 42. Once a command is stored, system 10
`checks Whether subsequent commands input by the system
`user are stored in command cache 42. If system 10 locates
`the command in command cache 42, the stored command is
`used to process the command. This reduces the time neces
`sary to process requests because system 10 does not have to
`repeat commands already executed. For example, a system
`user inputs a command “Retrieve Work File.” The retrieve
`Work ?le command may require system 10 to determine the
`object store storing the ?le, locate the position Within the
`object store, retrieve the ?le and transmit the ?le to the
`system user. Subsequently (e.g., the folloWing day), the
`system user inputs the same command. Before processing
`the command, system 10 determines Whether the command
`“Retrieve Work File” is stored in command cache 42. If
`system 10 locates the command, the stored command is used
`to execute the command because the command has already
`been processed. In this manner, system 10 does not repeat
`commands previously executed and thus reduces processing
`time.
`What is claimed is:
`1. A server system enabling a server to process URL
`requests for one or more non-markup language objects, the
`URL comprising at least one executable instruction, the
`system comprising:
`a server;
`at least one database in communication With the server;
`one or more non-markup language objects stored on the at
`least one database;
`a communicating module being operable to communicate
`the URL request for the one or more non-markup
`language objects, Wherein the URL comprises an object
`locator and at least one executable instruction; and
`Wherein the server, upon receipt of the URL, asks the one
`or more non-markup language objects to perform the at
`least one executable instruction provided in the URL.
`2. The system of claim 1 Wherein said server is operable
`to convert the non-markup language object to a markup
`language object.
`
`8
`3. The system of claim 1 Wherein the URL further
`comprises arguments identifying parameters associated With
`the at least one executable instruction.
`4. A server system enabling a server to process URL
`requests for one or more non-markup language objects, the
`URL comprising at least one executable instruction, the
`system comprising:
`storing means for storing one or more non-markup lan
`guage objects;
`requesting means for requesting the one or more non
`markup language objects using the URL, the URL
`comprising an object locator and at least one executable
`instruction;
`receiving means for receiving the URL for the one or
`more non-markup language objects; and
`Wherein the receiving means, upon receipt of the URL,
`asks the one or more non-markup language objects to
`process the at least one executable instruction provided
`in the URL.
`5. The system of claim 4 Wherein the URL further
`comprises arguments identifying parameters associated With
`the at least one executable instruction.
`6. Amethod for enabling a server to process URL requests
`for one or more non-markup language objects, the URL
`comprising at least one executable instruction the method
`comprising the steps of:
`storing one or more non-markup language objects in at
`least one database;
`requesting the one or more non-markup language objects
`using the URL, the URL comprising at least one
`executable instruction; and
`asking the one or more non-markup language objects to
`process the at least one executable instruction provided
`in the URL.
`7. The method of claim 6, further comprising the step of
`identifying parameters associated With the at least one
`executable instruction.
`8. An electronic storage medium having processor read
`able code embodied therein for enabling a server to process
`at least one executable instruction contained in a URL, the
`electronic storage medium comprising:
`processor readable code for causing a processor to store
`one or more non-markup language objects in at least
`one database;
`processor readable code for causing a processor to request
`the one or more non-markup language objects by
`identifying the one or more non-markup language
`objects and at least one executable instruction associ
`ated With the one or more non-markup language objects
`in the URL;
`processor readable code for causing a processor to receive
`the URL and locate the one or more non-markup
`language objects; and
`processor readable code for causing a processor to ask the
`one or more non-markup language objects to process
`the at least one executable instruction provided in the
`URL.
`9. The medium of claim 8, Wherein the URL further
`comprises arguments identifying parameters associated With
`the at least one executable instruction.
`10. The medium of claim 8, Wherein the server is operable
`to convert the non-markup language object to a markup
`language object.
`
`25
`
`35
`
`45
`
`55
`
`65
`
`

`
`US 6,192,415 B1
`
`9
`11. The medium of claim 8, wherein the URL further
`comprises arguments identifying parameters associated With
`the at least one executable instruction.
`12. The system of claim 4, Wherein the server is operable
`to convert the non-markup language object to a markup
`language object.
`13. The system of claim 1, Wherein the executable instruc
`tion differs based on the one or more non-markup language
`objects requested.
`
`1O
`
`10
`14. The system of claim 4, Wherein the executable instruc
`tion differs based on the one or more non-markup language
`objects requested.
`15. The method of claim 6, Wherein the executable
`instruction differs based on the one or more non-markup
`language objects requested.
`16. The medium of claim 8, Wherein the executable
`instruction differs based on the one or more non-markup
`language objects requested.
`
`*
`
`*
`
`*
`
`*
`
`*