Object Service Specification to define the interface of ISS, so that it is not only easily to ..... results, and then retrieve the returned references that includes a data ...
An Agent-based Search Engine based on the Internet Search Service on the CORBA# Yue-Shan Chang1* , Hsin-Chun Hsieh1, Shyan-Ming Yuan1, Winston Lo2 1 Department of Computer and Information Science National Chiao Tung University Hsin-Chu, Taiwan 30050, R.O.C. 2 Department of Computer and Information Science Tung Hai University Taichung, Taiwan, R.O.C. Abstract Search service is an important tool in the World Wide Web. In general, these standard web search engines are far from idea. Many researchers have therefore implemented Multi-Engine Search Service (MESS) using meta-broker. However these MESS are difficult to integrate a new search engine. On the other hand, the applications that need search service ability are also difficult using these MESS. In this paper, we propose an Internet Search Service (ISS) based on the CORBA. We follow the style of Common Object Service Specification to define the interface of ISS, so that it is not only easily to integrate any search engine into multi-search services, but also can be queried by application programs. In addition, two search engine agents are implemented in our project, one is for Yahoo and the other is for AltaVista. Programmers can use this interface to coding their search engine agent or to query search service in their applications. Finally, we build a heterogeneous search engine agent based on this architecture.
Galaxy5, and WebCrawler6 etc., are used in the world. Although these search engines may help users to find of what they want, these standard web search services have a few limitations. For example, no single search service are sufficient, many references returned by services are irrelevant, outdated, and unavailable [10] etc. In general, we are usually to query more search engines to get most references that you want. Beside, each search service on the Internet has its own interfaces, it are confused for novice to use various search services. To build a new and complete search engine which cover all of other search engines is very difficult. Therefore, many researchers have therefore implemented Multi-Engine Search Service (MESS) using meta-broker, such as Customizable Multiengine Search Tool [7], MetaCrawler[10], SavvySearch[9,15], and Softbot[17] etc. These multisearch services integrate various search engines into a system and act as a dispatcher, when WWW user issue a query request, it dispatch the request to various search engines and get the results.
1.1 Motivations Keyword: Internet Search Service, Search Engine, World Wide Web, CORBA, Heterogeneous Search Engine Agent
1. Introduction With progress in computer network and Internet, World Wide Web (WWW) become increasingly popular in recent year. There are more and more web sites on the Internet. Thereby, searching a resource from Internet becomes a nontrivial work. So that search engine becomes a most important tool in the World Wide Web. As the Web grows, various search services are increasing as well. Currently, there are a dozen of different search engines on the Internet, such as Yahoo1, AltaVista2, Lycos3, InfoSeek4,
* He is also a lecturer at the Department of Electronic Engineering of
However, previous problems may also appear in these MESSs, especially, no single search service is sufficient. Even if MESS consists of several search engines, they are necessary to integrate some new and more powerful search engines in future. But, most of MESS lack on the extensibility, because they don’t have uniform interface for standard search engine agent. General MESS is difficult to integrate a new search engine. On the other hand, those MESSs are useful for the Internet user, but not for programmer that needs coding their individual search component in their application. For Ming-Hsin Institute of Technology http://www.yahoo.com 2 http://www.altavista.digital.com 3 http://www.lycos.com 4 http://www.infoseek.com 5 http://galaxy.einet.net/galaxy.html 6 http://webcrawler.com 1
example, creating an individual multi-search tool or adding search ability in their application. These MESSs can be not used when it need search service ability in their applications. When a specific application requires searching ability, programmer must either create a search service in their application or explore the sophisticated interfaces and attributes of each search engines that he choice, then encapsulate query string and send to search engine. All of above are trivial and tedious works for programmer. In addition, object-oriented design [25] has been widely applied to software design and development since it offers greater potential in portability and reusability. In recent, most of new applications are built in object-oriented language, such as C++, Java etc. There are distributed object middle-wares have been proposed; such as Object Management Group’s CORBA [11], Microsoft’s DCOM [23] and Sun’s JAVA RMI. CORBA is an industrial standard and more than 800 members in the world. Moreover, CORBA have been ported to many operating environments, such as Microsoft’s Windows, UNIX and MVS etc. Thereby, in this paper, we create an agent-based search engine based on the Internet Search Service (ISS) on the Common Object Request Broker Architecture (CORBA) that, because, is an industrial standard of distributed object oriented platform [11]. We follow the style of COSS (Common Object Service Specification)[12] to define the interface of ISS. There are several reasons to motivate our work. First, each search service on the Internet has its own interfaces, it are confused for novice to use various search services. We should propose a uniform interface that covers most of interfaces of most of search services. Second, if applications require the searching ability, it must be ease to use. By means of ISS, programmers can use this interface to coding their search engine agent or to query search engine on the Internet in their applications. Through the CORBA standard, applications can be developed in other environment, such as CORBA, COM, and Java, as shown in figure 1. But the developed applications in the COM or Java environment must be mediated through IIOP bridges [11][16]. Third, because this interface is uniform, it is easily to implement a multi-search engine. To implement a multi-search engine based on our architecture, we can integrate a new search engine into the multi-search engine easily. Fourth, we hope to establish a standard for Internet Search Service on the OMG’s COSS. Finally, we believe that the ISS is easily to be applied into other type search engine, such as knowledge discovery system [21][22], real-estate system [18], and digital library [19] etc., and to build heterogeneous search engine agents. So, the most of search or query services, that whether on the Internet or not, can extent this approach to construct a multi-search service and inherit these advantages described above. To achieve our work, we, first, explored the interfaces and attributes of most of search engines, and then combined these interfaces into an uniform interface that form the ISS. Moreover, according to ISS interface, we implemented two representatives of search engine agents –
one is Yahoo agent and the other is AltaVista agent. Because the ISS was based on the CORBA, and it was implemented as an Internet search component, programmers could use the interface to search web site on the Internet in their application via these two agents. Besides, we integrated these two agents and implemented a heterogeneous full-text search engine agent prototype – Octopus. This system was implemented as multi-threaded and multi-agents version to serve incoming request, to collate and filtering the results and, finally, to return results to users. Because, these agents were implemented as a CORBA object, and the interface was uniform, it could add or integrate other search engine into our system easily.
S e a r c h E n g in e L a yer(rem ote)
IS S L ay er (A g e nt)
s e a r c h e n g in e 1
s e a r c h e n g in e 2
s e a r c h e n g in e N
i n t e rf a c e
i n t erf a c e
s e a r c h s e rv ic e 1
i n te r f a c e
s e a r c h se rv ic e 2
s e a r c h s e rv ic e N
C O R B A /O R B
D C O M /C O R B A I IO P B r i d g e
C O M C l ie n t
JA V A /C O R B A I I O P B r id g e
J A V A C lie n t
C O R B A c l ie n t CGI
C O R B A C lie n t
WW W e n v ir o n m e n t
Figure 1. Internet Search Service Architecture
1.2 Search engine exploration Search engines are powerful tools for assisting to navigate the rapidly expending World Wide Web. In the Internet, most of large-scale search engines can be divided into two categories: directory scheme, such as Yahoo and Yam7, and active search scheme, such as AltaVista and InfoSeek etc. For directory scheme, server owner needs to register his server information, includes address and description etc., into search engine, while active search scheme search Internet web site and indexing each related information into their database periodically. Most of search engines have it own interface and may be different between these search engines. We look through the interface of general search engine, and define the interface of ISS. Two representatives of search engines herein are explored - Yahoo and AltaVista, and result are shown in following table. The full description of individual interface may refer its home page. Table 1: Interface comparison of Yahoo and AltaVista
Yahoo Common Interface Include + Exclude Wildcard * OR Space Exact Phrase “ ” Title t:
7
http://taiwan.iis.sinica.edu.tw/b5/yam
AltaVista + * Space “” Title:
URL u: Different Interface Anchor Applet Domain Host Image Link Text Near Date 1 day ago Restriction 3 days ago 1 week ago 1 month ago 3 months ago 6 months ago 3 year ago Display 10 matches 20 Per page 50 100 Search Area Yahoo Categories Web Site Search Yahoo! Database Usenet
url: Anchor: Applet: Domain: Host: Image: Link: Text: ~ dd/mmm/yy
creator of Search and ResultCollection is a collection of results. Figure 2 shows the relationship of ISS. An arrow with a vertical bar is used to show that the target object supports the interface named next to the arrow; and that clients holding an object reference of this type can invoke the operations defined by the interface. In our design, it as involves most of search interfaces as possible. Then, we will describe the interface of ISS and its processing scenario. Internet Search
Search Factory
client
Search object
Usenet
All of interfaces can be clearly divided into common interfaces and different interfaces. We believe these interfaces already include most of search engine interfaces. Nevertheless, it is not enough in all search engines. We will extent these interfaces and as satisfy all of search engines as possible in ISS. The design of ISS is depicted in next section. This paper is organized as follows. Section 2 presents the design of Internet Search Service based on the CORBA and a program example to demonstrate how to coding the ISS. Section 3 depicts an experimental search engine agent based on our architecture. Section 4 makes a discussion. Finally the conclusions of this paper are given.
2. Design of Internet Search Service In this section, we depict the design of Internet Search Service deeply and show an example to demonstrate how to coding the ISS.
2.1 Architecture of ISS In this paper, we follow the style of COSS to define an ISS interface. The major objective of ISS is to provide an uniform interface for most search engines. In addition, programmers can use this interface to coding their search engine agents or to query search service in their application based on our object implementation. According to above descriptions, we design the Internet Search Service. It consists of three components: SearchFactory, Search, and ResultCollection. Search is the main-body of executing search in ISS. SearchFactory is a
Result object
Figure 2: Structure of Interface Search Service
2.2 Interfaces of ISS In our design, SearchFactory acts as a creator of Search object. Before gets Search object, client program must bind the SearchFactory and get its object reference. This interface shows as follows. interface SearchFactory interface { Search NewSearch(); };
//search factory
When a client program gets the object reference of SearchFactory object, it then invokes NewSearch() operation to get the Search object that is the main body to invoke search engine agent. In our design, Search interface have five methods- AddKeyword(), RemoveKeyword(), GetKeyword(), ExecuteSearch(), and AbortSearch() respectively. We will explain these methods as follows. When a client program gets the object reference of Search object, it then invoke AddKeyword() operation to put query string into Search object. It can also remove the query string using RemoveKeyword() operation. These two methods have an input keyword parameter that is the added or the removed string. In our design, each key word consists of a query string and an attribute. This attribute
denotes the string is included or not. In addition, client may look for the query string using GetKeyword() operation with a input parameter that is a key word index you want to get. Before invokes a search engine agent, client must put some attributes that are related to this query into Search object. After put the query string into Search object, client program issues the ExecuteSearch() operation to perform search. If client program want to discard this search during ExecuteSearch execution, it can perform the AbortSearch() operation. All of these method functions are shown in following table. struct Keyword { char Inclu_Exclu; string item; }; interface Search { attribute string Domain; attribute long Tag;
//keyword structure
//search interface //domain and host //title, URL, anchor, //applet, image, link, text
attribute string Date; attribute long Near;
//how many words //between two string attribute unsigned long DispNum; //how many //references displayed in a page attribute char Area; // Web site, Categories attribute boolean DataBase; readonly attribute long No_Keyword; //get the //number of added keyword boolean AddKeyword(in Keyword add); //add //keyword for future search boolean RemoveKeyword(in Keyword removed); //remove added keyword Keyword GetKeyword(in long index); //get added keyword ResultCollection ExcuteSearch(); //execute search Boolean AbortSearch(); //abort this search
to client program. Client program read the number of results, and then retrieve the returned references that includes a data structure consists of Title, URL, Description, Date, and weight etc., using retrieve_element_at() method.
struct Result //result structure { string Title; string URL; string Description; string Date; float weight; } interface ResultCollection //result collection interface { readonly attribute long No_Result; Result retrieve_element_at(in long where); };
2.3 Normal Scenario of ISS Client
SearchFactory
Result Collection
Search
::Bind ::NewSearch
create
::AddKeyword ::ExecuteSearch
create Send HTTP message
::Retrieve_element_at
}; Moreover, in order to cover all of search engine interfaces, we refer the table 1 and define a few of attributes in the Search interface. These attributes involve Domain, Tag, Date, Near, DispNum, Area, DataBase, and a readonly No_Keyword etc. Most of these attributes are bit-wise representation. For instance, the Tag attribute can represent the search object is in title, URL, anchor, applet, image, link, or text. We declare a long integer to represent this attribute. Each bit represents a tag, and the remainder bits are reserved for future. In CORBA, attributes can be translated into two operations by IDL compiler; it is get_xxx and set_xxx respectively. To use these attributes are implementation-dependent. Third interface of ISS is the ResultCollection, and as shown in following table. In this interface, retrieve_element_at() is the only method function. When client program perform ExecuteSearch() operation, Search object send out query message to related search engine, and create and return the ResultCollection object reference
Figure 3. Scenario of ISS Architecture
Figure 3 shows the normal scenario of ISS. From the viewpoint of client program, it first bind SearchFactory to get its object reference, and execute NewSearch() operation to new a Search object. When the SearchFactory receive a NewSearch request, it will create a Search object and return object reference to client. Once client gets the Search object reference, it can execute operations, such as AddKeyword, RemoveKeyword, and GetKeyword etc., and set related attributes into Search object. Then, client program executes ExecuteSearch operation to issue search request. Once Search object receives this request, it encapsulates related keywords and attributes into search engine query string and sends to search engine. When Search object receives search result from search engine, it de-encapsulates returned message and put into ResultCollection object. Then, Search object returns
ResultCollection object reference to client program. Finally, client program uses this object reference to retrieve query result.
2.4 Programming example In this section, we demonstrate the code development of a client program and show how to query via search engine agent. According to the above interface, we, first, compile the IDL file, and generate the client stub and server skeleton. Then, we coding the search engine agent component and compile with server skeleton. Finally, write a server program and register into ORB. The server program is as follows. int main(void) { InternetSearchService_SearchFactory_impl ISS_YAHOO; try { CORBA_Orbix.impl_is_ready("ISS_YAHOO"); } catch (CORBA_SystemException &SysEx) { ... } return 0; } Then, we demonstrate the development of client program. These code sequences are same as the scenario of ISS and shows as follows. If your system support multiple servers, the client program must bind to each server and set each attribute in each server. Client program can also be developed in other environment, such as CORBA, COM, and Java, but it must be mediated through IIOP bridges. void main (int argc, char* argv[]) { ................. SearchFactory_var=ISS_SearchFactory::_bind(" :ISS_YAHOO", hostname); Yahoo_Search_var = SearchFactory_var>NewSearch(); ISS_Keyword Keyword_element; ISS_Keyword* tmp_key_element; CORBA_Long i; for (i=1; i < argc ;i++){ //add query string if (argv[i][0] == ’+’ || argv[i][0] == ’-’){ if (argv[i][0] == ’+’) Keyword_element.Inclu_Exclu=0x01; else Keyword_element.Inclu_Exclu=0x02; Keyword_element.item= CORBA_string_alloc(strlen(argv[i]-1)+1); strncpy(Keyword_element.item, argv[i]+1,strlen(argv[i])); }else{ Keyword_element.Inclu_Exclu=0x00; Keyword_element.item= CORBA_string_alloc(strlen(argv[i])+1); strcpy(Keyword_element.item,argv[i]);
} if (! Yahoo_Search_var->AddKeyword (Keyword_element)){ ......; } delete Keyword_element.item; } // set Attributes Yahoo_Search_var->Tag(...); Yahoo_Search_var->Date(...); Yahoo_Search_var->Area(...); Yahoo_Search_var->DataBase(...); Yahoo_Search_var->DispNum(...); Result_var = Yahoo_Search_var->ExecuteSearch(); ISS_Result* result_element; CORBA_Long NoResult=Result_var->No_Result(); if(NoResult!=0) for (i=1; i No_Result(); i++){ result_element = Result_var>retrieve_element_at(i); } }
3. Application of ISS In this section, we implement an experimental heterogeneous search engine agent using ISS, named as Octopus that demonstrate the application of ISS. Nowadays, this system consists of Yahoo and AltaVista search engine agent. These two agents are implemented as CORBA object. By the same way, we believe that it is easily to add other search engine into our system.
3.1 System architecture Because the Octopus use ISS IDL definitions, it provides a single, central interfaces for Web document searching. Upon receiving a query from WWW user, the Octopus forwards the query to multiple search engines in parallel, and collates the returned references. Figure 4 shows the Octopus system architecture. In this system, WWW user posts a query request via Common Gateway Interface (CGI). Then the CGI forks a mediator for each request. The responsibilities of mediator are as follows: First, gets agent’s information from Service Repository, that keeps the number of agents and its name, and create multiple threads to perform this query. In our design, each created thread is a wrapper. Second, collates the returned information from all of agents, then merge them. Finally, send back the query results to WWW user. In addition, each wrapper are a CORBA client program, it is responsible to set the attributes of each search engine agent. Because every search engines have its attributes, though it is most similarity, but slightly difference. One agent has one wrapper. The first task of wrapper is to add keyword into related agent, and set its attributes. Then, it issues ExecuteSearch operation to invoke a searching. Once search engine returns the result, it will retrieve returned information from agent, and send to mediator. It is clearly, another advantage of our system is programmer
can coding its wrapper in his application to perform web search function to have the ability of search service. Another component in our system is agent. It also is the CORBA object implementation. When the agent receive the request from wrapper, it will encapsulate query information into related search engine’s HTTP format. Finally, send the query information to related engine and get the result from search engine. Currently, only Yahoo and AltaVista search engine agents were implemented in our system. Because we have an uniform interface- ISS, it is easily to add other agent into our system. Moreover, because these agents are implemented as CORBA object, general CORBA client can also use this interface to invoke search engine agent in their application program. Of course, client that belongs to other object model, such as Microsoft’s COM/DCOM, also can use these agents via CORBA’s Internet Inter-ORB Protocol [11] in the same way.
Figure 4: Octopus system architecture
3.2 User interface Octopus’s underlying system is implemented and run on two platforms (a SPARC and a Windows NT). The ORB of this system is IONA’s Orbix 2.02, which is a full implementation of CORBA specification. Currently, the conventional search engines included in Octopus are two typical search engines - Yahoo and Altavista search engine. Figure 5 and 6 shows the user interface. When a user submits a query using the query form (Figure 5), this system will perform the query process and get the results from the Octopus. The returned results are organized and displayed in a unified form, as shown in Figure 6.
3.3 Returned references filtering Though no single search service is sufficient in the WWW, and heterogeneous multi-search service might include most of references, there are many search engines can return repeated reference, or two search engine agents
return same reference to users. It is to perplex for users to use those returned information. In our system, in order to avoid multiple same references return to user, we use hashing function in the mediator to filtering the duplicated reference. Once the returned reference has the same network address with previous one, it is discarded. It is to guarantee the returned references are uniform. In addition, a dedicated thread can be used to guarantee the availability of which these filtered references in our system.
3.4 Performance evaluation The performance issue is important in the client/server model. In our system, in order to parallel serve user query, it is necessary to execute following components: one of mediator, multiple wrappers, one of ORB, and multiple agents. The performance is seriously effected. To improve the performance, following strategies are used in our system: multi-threading and various agents are configured on various host. Multi-threaded programming is well-known technology to improve the server performance. In our system, all of mediator, wrappers and search engine agents are multithreaded version. When a mediator thread was created, it creates immediately multiple threads of the wrapper. And each wrapper is correspondence to one of agent, that also is multi-threaded created by ORB. Besides, we separate each agent to one dedicated host. It can ease to configure in the CORBA environment. Thus, it can balance the overhead of system. In addition, we also consider applying object migration [14] techniques to balance the system load in future.
Figure 5: Octopus user interface
easily integrate new search engines into our system by creating the search engine agent. With progress of technology of developing search engines, more powerful search engines can also integrated into our system in the same way. System developer just only takes care the interface of new search engine and implement its agent. The remainder of system can be retained. Second, it is ease for programmer to coding their application that has searching ability. Application programmers utilize the interface to search information in their application can hide the complexity of network programming and do his/her most effort in other significant value-added services. In addition, through the CORBA standard, applications can be developed in other environment, such as CORBA, COM, and Java. But the developed applications in the COM or Java environment must be mediated through IIOP bridges
5. Conclusions
Figure 6: Octopus returned results
Performace measurement
Figure 7. Performance Measurement
We performed some preliminary measurements to assess the performance of our system, as shown in figure 7. We compare our system and two representative search engines- Yahoo and AltaVasta. From the result, though the overhead of Internet is unpredictable in most situations, it is obviously that our system is efficiency. The average query time of Octopus is the slower one of two representative engines plus reasonable overhead. This slightly overhead of our system is mainly due to create multiple threads to parallel execution and to filter returned references.
4. Discussions CORBA is one of industrial standard, which support more than a dozen of services in the COSS. Using CORBA to design and implementation our system, we found some additional advantages while use this method to build a heterogeneous search engines agent. First, we can
In this paper, we have been proposed an Internet Search Service (ISS) based on the CORBA that is an industrial standard of distributed object oriented platform and is announced by OMG. We follow the style of COSS to define the interface of ISS. In addition, according to ISS interface, we implement two representatives of search engine agents – one is Yahoo agent and the other is AltaVista agent. Because the ISS is based on the CORBA and it was implemented as an Internet search component, programmers can use the interface to search web site on the Internet in their application via these two agents. Besides, we integrate these two agents and implement a heterogeneous full-text search engine agent prototype – Octopus. Because, these agents are implemented as a CORBA object, and the interface is uniform, it can add or integrate easily other search engine into our system. The major objectives of our work are as follows: First, We hope to propose an uniform interface that covers most of interfaces of many search services. Second, if necessary, we also hope the function of search service can be used in the general applications that needs search service capability. Programmers can use this interface to coding their search engine agent or to query search engine on the Internet in their application. Third, because the interface is uniform, we can ease to implement a multi-search engine. To implement a multi-search engine based on our architecture, we can integrate a new search engine into the multi-search engine easily. Existing multi-search engines have no this ability. Finally, we hope to establish a standard for Internet Search Service on the OMG’s COSS. From our experience, it is obviously that using ISS to implement whether search engine agent or multi-search engines is easy. We also believe that it is easily to extent the ISS to other type search engine agent, such as knowledge or data discovery, real-estate system and digital library etc.
Acknowledgement This work was partially supported by National Science Council of Taiwan R.O.C. under Contract No. 87-2213-E035-008 and by Institute of Information Industrial of Taiwan R.O.C. under Contract No. C87-144.
Reference: [1] Michael Schwartz etc. al., WWW Home Pages Harvest Broker. http://town.hall.org/Harvest/broker/www-home-pages/. [2] IBM, Inc. Query By Images Content Home Page. http://wwwqbic.almaden.ibm.com/~qbic/qbic.html. [3] Brandon Plewe, The Virtual Tourist Home Page. http://wings.buffalo.edu/world. [4] Personal Library Software, Ine. Personal Library Software Home Page. http://www.pls.com. [5] LEXIS-NEXIS. LEXIS-NEXIS Communication Center. http://www.lexis-nexis.com. [6] Verity, Inc. Verity Home Page. http://www.verity.com [7] Chia-Hui Chang and Ching-Chi Hsu, “Customizable Multiengine Search Tool with Clustering”, Proceeding of the sixth international world wide web conference’97, Santa Clara, California, USA, April 1997, pp.257-264. [8] Massimo Marchiori, “The quest for Correct Information on the Web: Hyper Search Engineers”, Proceeding of the sixth international world wide web conference’97, Santa Clara, California, USA, April 1997, pp.265-276. [9] Daniel Dreilinger,” Integrating Heterogeneous WWW Search Engines”, May 1995. ftp://132.239.54.5/savvy/report.ps.gz. [10] E. Selberg, O. Etzioni,” Multi-Engines Search and Comparison Using the MetaCrawler”, proceeding of the Fourth World Wide Web Conference’95, Boston USA., Dec. 1995. [11] Object Management Group, Inc. The Common Object request Broker (CORBA): Architecture and Specification, v2.2, February 1998. [12] Object Management Group Inc., CORBA services: Common Object Services Specification, OMG Document Number 95-
3-31, March 31, 1995. [13] Daniel Dreilinger and Adele E. Howe, “Experiences with Selecting Search Engines Using MetaSearch”, ACM Trans. on Information Systems, Vol. 15, No. 3, pp. 195-222, July 1997. [14] M. Nuttall, “A Brief Survey of Systems providing Process or Object Migration Facilities”, ACM Operating System Reviews, 28(4): 64-80, October 1994. [15] Daniel Dreilinger, Adele E. Howe, “Experience with Selecting Search Engines Using Metasearch”, ACM Trans. on Information Systems, Vol. 15, No. 3, July 1997, Pages 195-222. [16] Sun Microsystems, Enterprise JavaBeans to CORBA Mapping, v1.0, March 23, 1998. [17] O. Etzioni and D. Weld, “A Softbot-Based Interface to the Internet.” CACM, 37(7): 72-76, july 1994. [18] L. Gravano, Hector Garcia-Molina, “Merging Ranks from Heterogeneous Internet Sources.” Technical Report: AR_300, Stanford University. [19] L. Gravano, C. C. K. Chang, Hector Garcia-Molina, “STARTS: Stanford Proposal for Internet Meta-Searching.” Proceeding of 1997 ACM SIGMOD, Vol.26, No. 2, Jun. 1997, pp. 207-218. [20] “Orbix Programming’s Guide”, IONA Technologies Ltd., Novermber 1994. [21] Donald F. Geddis, Michael R. Genesereth, Arthur M. Keller, and Narinder P. Singh, “Infomaster: A Virtual Information System,” Intelligent Information Agents Workshop, at CIKM’95, December 1995. [22] Anthony Tomasic, Remy Amouroux, Philippe Bonnet Olga Kapitskaia, “The Distributed Information Search Component (Disco) and the World Wide Web”, SIGMOD’97, AZ, USA. [23] K. Brockschmidt, “Inside OLE,” 2nd, ed., Microsoft Press, Redmond, Washington (1995). [24] Alexandros Moukas and Pattie Maes, “Amalthaea: An Evolving Multi-Agent Information Filtering and Discovery System for the WWW,” Autonomous Agents and MultiAgent System, 1, 59-88(1998). [25] G. Booch, “Object-Oriented Design with Applications,” The Benjamin Cummings Publishing Company, Inc. (1991).
