Conventionally, the World Wide Web has used HTML (Hyper-Text Markup Language) to encode documents (e.g., web pages). HTML was primarily intended for human consumption and hence has limitations with respect to the ability to perform more complex functions involving web documents, which may be static or dynamic. While the content of static web documents are fixed, the content of dynamic web documents may change. In this fashion, the web document may meet a user request for information, may provide a changing graphical display, etc. Conventionally, creating a dynamic web document involves combining stylesheets and scripts to create such web documents, which change in response to user interactions.
Conventional methods to generate dynamic web pages include using a JSP (Java Server Page) or using an ASP (Active Server Page). In the JSP case, a file containing a combination of JSP tags, HTML code and Java code is transformed into Java source code, compiled, and the resulting executable is run to generate a customized web page. The JSP file is transformed and compiled the first time it is accessed and also whenever the JSP source page is newer than the compiled version. The ASP technology is analogous to the JSP technology but uses Visual Basic as a primary server side scripting language.
Unfortunately, the above-mentioned conventional methods have several limitations. One such limitation relates to the ability to save the state associated with a web-page the user was accessing, such that the user may leave and come back to the web-page to pick up where the user left off. For example, a dynamic web-page may be designed to walk a user through of a number of steps to complete a process. A user accessing such a web-page may go off-line and come back to finish later. While some conventional systems may allow for this, the technique is often complex because the state associated with where the user is in the process must be linked to the copy of the code that was used to create the dynamic web page. Thus, multiple items must be saved (e.g., the identity of the page and the version of the code used to access it) and they must be linked together.
Some conventional methods also face difficulties when updating the code that accesses web pages. For example, a single piece of code (e.g., a JSP) is used to process incoming requests for web pages for multiple users. From time to time, this code must be re-compiled. Using the example above in which a user leaves a process and wishes to come back later, the code may have been re-compiled between the time the user left and the time the user returned. The newly compiled code may not allow the user to complete the process properly and saving the old code is logistically unattractive. Hence, problems of mixing old and new code arise.
An additional problem with such conventional methods is that they are not well-suited to providing machine-readable descriptions. For example, while the markup tags in HTML define how the content is to be formatted, they do not describe the content itself. Recently, XML (Extensible Markup Language) has been used to encode web-pages. In particular, with the introduction of higher-level representations such as RDF (Resource Description Format), it is practical to provide web pages that contain machine-readable descriptions. In this evolution of the World Wide Web to the Semantic Web, it is suggested that web pages may become a store of data to be mined by autonomous software agents.
Software agents are software routines that wait in the background and perform an action when a specified event occurs. Software agents may be autonomous, acting on behalf of the user. Some agents are intelligent, learning and adapting to environmental conditions. Software agents may perform a number of other tasks such as, information retrieval. In this example, a user may send a software agent to gather information on a specified topic while the user is off-line. When the user returns, the information is waiting. As another example, a software agent may function as a broker, seeking out prices for a specified product and returning a list to the users. As yet another example, software agents may transmit a summary file on the first day of the month or monitor incoming data and alert the user when a certain transaction has arrived.
One conventional method of coding agents is to describe the agent using a custom programming language with an XML syntax. While this may be effective for manipulating XML expressions, it requires that a new language be learned.
Other conventional systems may not require that a new language be learned to code the agent; however, the agent itself is not directly accessible. Consequently, debugging such an agent is complicated.
Therefore, one problem with conventional web access methods is the difficulty of saving the state associated with a web page. Another problem is the complexities involved in accessing a saved web page when the code that is used to access the web page is updated. An additional problem is the difficulty of providing web pages with machine-readable descriptions. Still other problems involve coding and debugging software routines such as agents.