Dynamic Semantics of the Web: Useful Tool for the New Generation Agent-Based Software Aasia Riasat1, Syed S. Rizvi2, Faraz Arain3, Rizwan M. Qureshi4
Department of Computer Science, Institute of Business Management1, Karachi, Pakistan Computer Science and Engineering Department, University of Bridgeport2, 3, 4, Bridgeport, CT
[email protected], {srizvi2, farain3,mqureshi}@bridgeport.edu
Abstract— A complex relationship between the semantic and the dynamic web is derived based on the concepts of ontology engineering. The resultant complex relationship can then be used to construct new generation intelligent agent-based software. Although the World Wide Web (WWW) was originally designed as a distributed information space that supported human navigation through related linked documents, the machine or software agent based assistance has been hindered by the type of markup used within the documents. Our derived relationship can show that how the dynamic semantics of the web enables software agents to derive underlying semantics on the basis of common ontologies and common agreed semantic to generate and process the semantics dynamically. In addition, an ontological relationship between the static and the dynamic semantics of the web is also presented. The Ontological view of this concept highlights the need of dynamic web semantics. Also, we show that how the dynamic semantics will be enabled by and useful to the new generation of the intelligent agent software that will increasingly inhabit the web in the coming years. I. INTRODUCTION World Wide Web (WWW) has drastically changed the availability of electronically accessible information. Currently, there are around three billion static documents in the www that are used by more than 200 million users internationally [8]. However, the rapid growth of the www makes it increasingly difficult to find, access, present and maintain information of use to a void variety of users. Currently, pages on the web must use the representation in formal language such as HTML [9] and employ protocols that allow browsers to represent information to the human users. The information contents, however, is mainly presented via natural language. Thus, there is a wide gap between the information available for tools to use in creating and maintaining the web pages and the information kept in human readable form on those pages, a gap that causes serious problems in accessing and processing the available information. The next phase of the web called the semantics web, stores the information regarding the properties and the relationships between the objects on the web. The semantics that changes relatively slowly as web pages are created, destroyed or
modified typically by human action is called the declarative or static semantic. Equal importance should be given to the dynamic semantic that involves the web contents generated on the fly in response to some user request. In static semantics a web page may also include metadata about certain web pages (written in RDF, SHOE or OIL) [5, 6]. Using dynamic semantics we can enable a web page to compute a metadata from human understandable information, which not only stores information about other web pages, but also stores information about the user activity, user interest and the structure of the text. This paper presents the relationship between static and dynamic semantics of the web. In addition, it highlights the need of dynamic web semantics and discusses how the dynamic semantics will be enabled by and useful to the new generation of the intelligent agent software that will increasingly inhabit the web in the coming years. Since the vision of the semantic web is now closed to be a reality, with the goal of giving semantics to the static contents of the web, this paper emphasizes the need to make the web a dynamic semantic web by programming the procedures in the web material as a first class objects. In this context, this paper reviews the new language of formal semantics “Glue” which is an XML based web programming language that completely integrates static and dynamic semantics of the web, recently proposed by the researchers at MIT [7]. The rest of the paper is organized as follows. In section 2, we present a comprehensive comparative analysis of static and dynamic semantics of the web. Particularly, we demonstrate that how the deployment of dynamic semantics can affect the upcoming implementation of the semantic web. In section 3 of this paper, we review the new language GLUE which is an xml based extension of html that integrates static and dynamic semantics of the web. In section 4 we will conclude the paper. II. COMPLEXITIES OF STATIC AND DYNAMIC SEMANTICS OF THE WEB As Discussed in the first section adding static semantics to web contents empowers the web to let software agents and machines to extract and reason the information that is over the web, however as knowledge becomes complex and huge its static semantics description will sooner become less useful and complete. This fact implies that some other mechanism
M. Iskander (ed.), Innovative Techniques in Instruction Technology, E-learning, E-assessment, and Education, 542–547. © Springer Science+Business Media B.V. 2008
DYNAMIC SEMANTICS OF THE WEB
should be adopted by the semantic web researchers to get the full advantage of the future semantic web and to tackle this potential problem the future semantic web will face. We believe that, the dynamic semantics has the potential to over come this prevailing problem of static semantics of the web. The successful implementation of dynamic semantics of the web can not be achieved unless the researchers have a sound understanding of various semantics: their nature, sources and their applications to varying web semantics usage scenarios. In this section we follow the same organization to give a better understanding of our audience about the dynamic semantics of the web. We first describe various semantics that are involved in the semantic web vision, identify relationships between static and dynamic semantic of the web and highlight their relative importance to the big picture of semantic web vision. Our main emphasis here remain on the extreme importance of the dynamic semantics and the advantage that it offers to greater enhance the semantic web potential, and how well it suits with the current requirements of the dynamically changing requirements of semantics web. A. The Future Semantic Web - A big picture A set of widely established standards guarantees interoperability at various levels and hence the concept of semantic web is soon to become a reality. Current web has been designed for human processing where as Semantic Web vision aims at developing a global medium of information exchange while extending the web with structured contents and machine-understandable information. The future semantics web will enable intelligent services such as intelligent information services, personalized Websites, and semantically empowered search engines, and knowledge base information retrieval along with improved functionality and interoperability. To make machine knows what to do with information on the web is to enable machine to read and process a machine process-able specification of the semantics of the information. This is a very challenging approach and mostly beyond the current state of the web. A much simpler approach is to let the Web application developers to hardwire the knowledge into the software so that when the machine/agent runs the software, it does the correct thing with the information. In this second situation, machines already use information on the Web. B. What is Semantic? Where it originates? Semantics appears in fact at various layers of applications of the semantic web. For a simple personal Web site with the purpose of presenting some information, developers could use HTML or XML. This markup language has its own semantics. When we develop a model of knowledge or a commonly agreed domain specific knowledge (such as ontologies), that can be represented by means of a computer language (DAML+OIL, SHOE) with certain semantics. To annotate a Web document by a reference to a model of knowledge, we will use some specific language and its semantics
543
Theses Semantic Web contexts include: achieving successful communication among agents on the Web, the meaning of the content of various information sources that agents require in order to perform their tasks as shown in Fig. 1. Our focus here is to describe complete detail about what different kind of semantics are involved in the semantic web, what scenarios include semantics, where these semantics actually exist or generated are and how they are used. Our emphasis is on the kind of semantic involved ranging from the various semantics that exist in the today’s WWW to a complex semantic infrastructure that will exist in the Semantic Web of the future. C. Implicit Semantics -Common Consensus When meaning is conveyed by means of a shared understanding derived from human consensus or a commonly used terminology of some entity, it is categorized as implicit semantics. The common terminology includes price, order, invoice, date of shipping etc. Since on the basis of this implicit shared consensus about what these terms mean, then application developers can hardcode this implicit semantics into web application programs using wrappers. This is the way today’s shopping agents and shopbot applications are implemented that search web sites for the best deals based on what is directed or coded within the application. The downside of the implicit semantics is that they are filled with complexity or irregularity. It is not necessary that the people always agree on the meaning and the use of the same term. The amount of efforts required to remove this irregularity is too high as it demands to have some publicly accepted terminology to share it at global scale with consistency. D. Informal Semantics - Static Web Semantic Semantics can be explicitly expressed in an informal manner, e.g., describing resources over the web using the RDF. This semantics is provided basically for humans, machines still can not infer any useful knowledge from this informally expressed semantics. Many examples of informal semantics exist such as: read-me text specification documents. HTML tags specifications, UML for expressing a model, documents or resources specifications using RDF or RDF Schema, Dublin Core definitions of the terms. In order to make use of this informal semantics, the application software hardwires the semantics in order to let software work in specified manner. The example of informal semantics include: compilers written over language descriptions, RDF and UML descriptions to develop modeling tools like Rational Rose. This ambiguity may arise again by the use of this semantics with inconsistency or incompatibility in its two different implementations with different features and characteristics. This will cause interoperability problems among separate implementation and hence an informal static semantics sometimes becomes a bottleneck to implement the semantic web motive to improve and enhanced interpretability. This problem highlights the need and motivates towards the
544
RIASAT ET AL.
development of formal (Dynamic Semantics) semantics of the web. E.
Formal Semantics -Human Processing Semantics can be expressed explicitly in a formal language, but intended to serve the purpose of human processing only. Examples of formal semantics include formal specifications of defining ontological categories. Again these specifications are to enhance the ability of humans processing and to reduce the ambiguity in defining the meaning of these ideas. This modeling of the logic enhances communication between web agents. The cross layer designed is presented in Fig. 2. The Ontologies on different information domains have been created in an attempt to help better communication of terminologies for same domains can be established. Again this involves inherited problems if these ontologies would be used for automated inference. F. Formal Semantics-Machine Processing: The Basis of Dynamic Semantics The heart of Semantics Web idea is to make web contents machine process-able that is machine can understand the web content it encounters. This ideology requires that the semantics can be hard-coded within the Web applications along with the existence of a commonly agreed, overall consistent, and well established semantics. The problem here arises with the size of knowledge domain to grow as related domain information grows and consequently the knowledge description (formal-static semantics) will become more difficult to manage. In order to handle this problem effectively another efficient approach is to formally represent the semantics and allow the machine to process it to dynamically discover what the content means and how to use it. This semantics is categorized as formal dynamic semantics for machine processing. Still this is a future possibility to achieve this goal in its full entirety of enabling machine to generate and process the dynamic semantic completely randomly. Some of the possible questions that we face in this idea to implement include: How to enable a software agent to learn something about the meaning of a term that it has never before encountered? There comes the procedural or dynamic semantics perspective. From the procedural perspective: the question is how agent can learn the meaning of a new term from a formal,
Fig.1: Heterogeneous Semantics of Semantic Web
Fig. 2. Ontological view of the complex dynamic semantic of the web
declarative semantics. For dynamic semantics generation we would like to do this without making any assumptions at all. In this case, all symbols might as well be in a never-before encountered terms for the web agents. We have no knowledge of the meaning of the symbols, the rules of syntax for the language. However, we may have some information on the semantics of the language in the form of an ontology is available. This paradigm is most challenging, and difficult for machines to work for. III. DYNAMIC SEMANTICS – POSSIBLE CHALLENGES There can be some prevailing problems when trying to implement dynamic semantics generation. One problem can arise due to the different ontology languages based on different description logic. Other differences can be based on degree of expressiveness, details of formally defined semantics, existence of inference support, etc. If we keep these different ontology languages in mind this will be a difficult task to perform dynamic translation in between. This task could be made easy if we assume that the terms that the agent will encounter are from one ontology language whose syntax and semantics (such as RDF schema or DAML+OIL) are already known to the web agent. Again if we assume that a commonly agreed ontology language is available, it can have incompatible assumptions in the conceptualization. From a logic perspective, the two representations may use the same language. As a result another assumption that needs to be made is: that the underlying conceptualizations of ontologies are compatible. If we assume the above two conditions of a shared language and compatible conceptualizations, it is still possible, that two different language’s terms may have the same meaning and the same term may have two different meanings. The same ideas may be described using different levels of details, different set of primitives, modeled in different structures. G. The Static Semantic Web - Current Picture In today’s Semantic Web concept: XML, RDF, SHOE+OIL languages have been introduced as formal languages for expressing concepts and relations that exist in the knowledge description of the contents (documents or resources) over the web and to provide machine understandable meaning to enable machine processing the web contents in an efficient way. In static semantics the web is typically viewed as a repository of web pages including meta-data (using XML,
DYNAMIC SEMANTICS OF THE WEB
RDF, SHOE, OIL, etc.), which consists of the information about all the web page contents, their resources, objects and their links. The web in this model is database of information that changes rare through database upgrades. However, all this is limited to static semantics. These knowledge descriptions are authored by its author in exactly the same way that HTML pages are presently authored by a Web designer [1]. This static semantic is represented declaratively in the form of passive data that can be retrieved and changes relatively slowly when the web page in created, modified or destroyed. Since these events are rare to happen this authoring of the knowledge description become a rare activity. Structured static semantics are a huge advance for the web since they will enable software agents to find and reason about information over the web, but as mentioned the problem with the structure static semantic is that : the larger and more complex the knowledge, the less complete and useful its static representations become. In addition the modification of the description and keep it up to date will become a tedious task to perform. For static semantics, there is no alternative other than to hardwire it into the web application software to let software agents perform the task as dictated by the code. In the case of formal partially dynamic semantics: it always serves the important role in reducing ambiguity and the complexity in specifying Web application behavior, compared to static informal semantics. There is always a possibility of using automated inference to process the semantics at runtime. This would allow for much more efficient, consistent and autonomous Web applications, in which agents automatically learn something about the meaning of terms at runtime by generating dynamics semantics. H. Dynamic Semantic Web – A Potential Opportunity The Dynamic semantics is represented procedurally & computed by applications running on the client or server side, based on immediate user input, context, real time and userinitiated actions. It changes relatively rapidly. A single user click can cause the semantics to be generated or to change, or it can be changed by the actions of programs continuously in real-time [2]. As the idea of the semantic web flourish, there are many ways in which static semantics are being augmented and replaced randomly by dynamic semantics. The Web application that render the dynamic contents such as : an Active Server Page extract results from the database and constructs a page on the fly or the search engine results pages, and customized ads based on cookies are examples of dynamically created Web pages. The important relation ship between static and dynamic contents of the web page make the originating source of the contents entirely transparent to the browser. The HTTP stream that is delivered by some random procedure call is identical to that which would have come from a statically stored page [4]. This transparency between static and dynamic data is an extremely important property of the web that can be exploited efficiently to replace or extend the dynamic contents such as replacing some static
545
data over the web page stream with a new, dynamically generated or calculated data at run time. I.
The Origins and Usage of Dynamic Semantics The potential sources of dynamic semantics generation are the intelligent web software agents. These are intelligent web applications that provide useful assistants to the user. They keep track of the user interests, learn through interacting with user, explore the Web proactively depending on the user interactions and provide personalized services and information. The examples are intelligent shopping agent programs that provide the pricing information available over different web sites about a product to the user. The real power of the Semantic Web will be realized when people will be able to create many web agent software applications that collect web content from diverse sources, process the information by generating the dynamic semantics i.e., the meaning of how to infer this information and exchange the results with other software agent application. The effectiveness and the utility of such software agents will increase exponentially as more machine-process-able Web content and automated information extraction and retrieval services including other software agents of the same domain will be added to this picture as shown in Fig. 3. The Semantic Web promotes the idea of web agents working together and transferring requested information among themselves when the data and semantics combined become available to the web agents. Web agents are unique since compute concepts and relations dynamically from the data stored and retrieved on the Web, form user’s interaction, or with the procedure tags attached with the data. Example are the shopping agents: they extract the information by exploring different web sites, querying their search forms, extracting relative information and showing the results in lowest to highest price order. They provide the valuable information by saving the user time and convenient of giving them the knowledge of smart price choices on a single click. In this process of self learning the
Fig.3: Web agents and the generation of Dynamic Semantics.
546
RIASAT ET AL.
web software agents generate dynamic semantics and utilized the same to continue their search goals or to communicate with other similar shopping agents online. IV. WEB AGENT SOFTWARE METHODOLOGY Current web agents work in the complete absence of any formal Semantics over the web. This is because in the current web no web sites provide any clues about what kind of contents are being placed over the web site. How web agents make use of current web contents in the apparent absence of semantics. This is because the way to interact with a web site, what to look for, how to query and how to extract the information is completely hardwired within the application code of the agent. There is no common agreement among different Web sites for how they will use the terminology, even though there is much similarity of the relevant concepts. The machine or the web agent knows what to do with the content. Because the developers hardwire the semantics of the content that will be encountered by the web agents and web agent response and create appropriate procedures that execute. So the web agents can work without any formal representation of semantics and even without any explicit representation of semantics at all. But of course their performance will be extremely restricted to the limited knowledge they have and the availability of the data structure and the semantics over the web that is hardwire in them. A. Web Agents and the power of Dynamic Semantics Once data and semantics are made available this will allow web agents to do problem-solving and highly relevant knowledge base retrieval over the web by going beyond the traditional keyword based information retrieval methods. Web agents keep track of the users’ browsers history and use it as a persistent context. Let us consider a simple example of how the intelligent web software agents can effectively make use of dynamic semantics i.e., machine processing of formal semantics with current technology. We are assuming that the web agent is using a commonly agreed terminology based publicly declared ontology language with complete conceptual compatibility. Assume that a web software agent is searching for information about mechanical devices over the web. It is using a public ontology (SHO) language. Web agent encounters a term “Fuel Pump,” which the agent has never encountered. Semantic description assists the web agent to refer to the concept fuel-pump, which is a kind of “pump,” which is defined in SHO as a kind of mechanical device. The agent infers that the document is relevant. On the basis of this inference web agent knows that it is some kind of pump. This information allow the web agent to return the document containing this term as being relevant to the search of mechanical devices, even though web agents never before had any clues about the term fuel-pump. This scenario illustrates the potential of inferring the meaning of knowledge that is imparted to the web contents, the importance of shared ontologies and the effectiveness of dynamic semantics
generation and its usage that enables the web agents to work in an automated manner to learn how to generate semantics and how to make use of it. The power of formal ontologies and automated inference can be joined together to derive a knowledge base for a wide variety of purposes. It allows agents to use theorem proving and consistency checking techniques to determine whether or not they have common semantics agreement and to infer the meaning of complex expressions built up using language primitives [3]. V. AN OVERVIEW OF FORMAL LANGUAGE OF SEMANTICS - GLUE One possible question that arises is: how future Semantic Web should be able to integrate not only text, links, and semantic descriptions, but also dynamic and procedural semantics in it? The existing web standards allow adding well defined semantics over the Web. However, procedural or dynamic semantics has not been covered by any of the existing proposals. Most today’s web applications are a combination of several programming languages, such as javascript, Java Servlets, Perl, VB-script, PHP and ASP etc. The disadvantages of such multi-language environments should be obvious. Along with the above problems outlines, the worst problem that exists with the given scenario is: With the availability of wide variety of prevailing languages, it prevents representing procedural or dynamic semantics in any sort of specified or standard way. The web definitely needs the integrity of overall existing Web functionality, along with the ability to tackle the challenges the future web applications need to face. What is needed here is a language that will unify all the static and dynamic aspects of the web application’s functionality with it and eliminate the efforts that are needed to learn variety of languages. In addition to cut down the learning efforts we need to extend HMTL to encode procedural/dynamic semantics in Web pages and employ XML as data structuring language as it is well known and standardized to enable better interoperability over the web. The web development language that is recently being proposed by some of the MIT researcher is called “Glue”. Glue is an XML based web programming language, which is an extension to html and it completely integrates static and dynamic semantics of the web in one unified manner. This language provides the three primary featured functionalities of web development into one unified language. Developer can simply insert tags into the page. Plain text, markup, data, and code can be freely combined together on a page with no barriers between different functionalities and no “data format mismatches” and the most functionality as desired. B. Glue – Some Examples Analysis Here is an example of generating a catalogue for a store. To setup inventory “database”, data is entered here directly as a vector of vectors like so: root.inventory. page.content. page.content. page.content. page.content. At the end of running this program the "page" variable contains our page object. We can get the string of HTML like so : page. To Add some dynamic variability based on the day of the month: Now is_sale_day is true if its the first day of the month and false otherwise. price
/> Above the price will be multiplied dynamically by .75 if we're on the first of the month. C. Glue Comparison with Java Language Analysis Some Glue’s features fix the inconsistencies and complexities inherent in Java language as outlined below. Glue data types are full-fledged objects. While java contains simple data types and objects, which adds in the complexity. Glue has true multiple inheritances. Whereas Java uses interfaces to allow multiple inheritance. This approach increases undue complexity. Glue supports both a prefix syntax and an infix syntax –automatically and hence does not need require precedence rules or parentheses. Unlike Java, Glue’s “evaluation kinds” permit the easy construction of high-level code manipulation methods which reduces the complexity of packaging up and calling advanced functionality. This enables developers to write their own control structures and other methods that can “delay
547
evaluation” until a programmer-chosen time. In Glue, there is no need to create a class with one instance object. In Glue object can be treated just like an instance object and this is because of Glue’s prototype object system. One can call its methods directly using the “class” as “this”. There is no need to have a distinction between static variables and instance variables, nor static and instance methods. VI. CONCLUSION We have presented some future possibilities and potentials of the semantic web form the Dynamic Semantic Web perspective. We have shown that the heart of the semantics web is the availability of machine-process able Web content. In this paper, we discussed the concept of semantic web and some of the challenges that are big obstacle in making it a reality. We described various semantics involved and emphasized on the point that the success of the Semantic Web correlates with the ability of Web applications to correctly determine the intended semantics of web contents. In this paper we shed the light on the use and advantages of formal semantics for machine processing which enable us to dynamically infer something about the meaning of the contents over the web in real time. We have shown that instead of just hardwiring the informal semantics over the web, the greater advantages can be gained by hardwiring the semantics of the common ontology specification languages that enable web agent to perform dynamic semantic generation and inference. REFERENCES [1] [2] [3] [4] [5] [6] [7] [8] [9]
Dieter Fensel, James Hendler, Henry Lieberman and wolfgang wahlster, -Spinning the Semantic Web: Bringing the World Wide Web to its full potential. T. Berners-Lee, James Hendler and Ora Lassila. “The Semantic Web”. Scientific American, May 2001. Dieter Fensel, James Hendler, Henry Lieberman and wolfgang wahlster, -Spinning the Semantic Web: Bringing the World Wide Web to its full potential. Lieberman, ed. 01 Henry Lieberman, ed., Your Wish is My Command: Programming by Example, Morgan Kaufmann, San Francisco, 2001. Lieberman, Fry & Weitzman 01 Why Surf Alone? Exploring the Web with Reconnaissance Agents, Communications of the ACM, to appear, 2001. Ungar & Smith 87 Self: The Power of Simplicity. ACM Conference on Object- Oriented Programming Languages, Systems, and Applications [OOPSLA-87]. T. Berners-Lee, J. Hendler, and O. Lassila. The Semantic Web. Scientific American, 284(5):34–43, 2001. O. Lassila and R. R. Swick. Resource Description Framework (RDF) Model and Syntax Specification. Available at: http://www.w3.org/TR/REC-rdf-syntax/, 1999. R. G. Smith. The Contract Net Protocol: High-Level Communications and Control in a Distributed Problem Solver. IEEE Transactions on Computers, C29 (12), 1980.
