System, method and article of manufacture for advanced mobile bargain shopping

Abstract

A system is disclosed that facilitates web-based comparison shopping in conventional, physical, non-web retail environments. A wireless phone or similar hand-held wireless device with Internet Protocol capability is combined with a miniature barcode reader (installed either inside the phone or on a short cable) and utilized to obtain definitive product identification by, for example, scanning a Universal Product Code (UPC) bar code from a book or other product. The wireless device transmits the definitive product identifier to a service routine (running on a Web server), which converts it to (in the case of books) its International Standard Book Number or (in the case of other products) whatever identifier is appropriate. The service routine then queries the Web to find price, shipping and availability information on the product from various Web suppliers. This information is formatted and displayed on the hand-held device's screen. The user may then use the hand-held device to place an order interactively.

Claims

What is claimed is:

1. A method for creating an information summary, comprising the steps of:

(a) obtaining a product identifier;

(b) creating a query based on the product identifier;

(c) querying a network of information utilizing a wireless communication medium, wherein the network is the Internet;

(d) receiving the response to the query from the network of information;

(e) displaying the information associated with the product identifier on a display;

(f) ranking the information based on relevance to the product identifier; and

g) wherein the information relates to at least one of features, shipping, and availability associated with the product, and the information is displayed to reflect a relationship between the information and a user profile.

2. A method for creating an information summary as recited in claim 1, including the step of parsing the response to the query for subsequent display based on predefined criteria.

3. A method for creating an information summary as recited in claim 1, including the step of providing constants that are utilized by the system for dynamically configuring the system based on current user inputs.

4. A method for creating an information summary as recited in claim 1, including the step of utilizing a universal product identifier code for the product identifier.

5. A method for creating an information summary as recited in claim 1, including the step of reducing the communication transmission rate to enhance the transmission quality over the wireless communication.

6. A method for creating an information summary as recited in claim 1, including support for querying the Internet to obtain pertinent information.

7. A method for creating an information summary as recited in claim 1, including optimizing the query for a particular search engine.

8. A method for creating an information summary as recited in claim 1, including the step of querying for alternative product identifiers to obtain additional pertinent information.

9. An apparatus that creates an information summary, comprising;

(a) a processor;

(b) a memory that stores information under the control of the processor;

(c) logic that obtains a product identifier;

(d) logic that creates a query based on the product identifier;

(e) logic that queries a network of information utilizing a wireless communication medium, wherein the network is the Internet;

(f) logic that displays the information associated with the product identifier on a display;

(g) logic that ranks the information based on relevance to the product identifier; and

(h) wherein the information relates to at least one of features, shipping, and availability associated with the product, and the information is displayed to reflect a relationship between the information and a user profile.

10. A computer program embodied on a computer-readable medium that creates an information summary, comprising:

(a) a code segment that obtains a product identifier;

(b) a code segment that creates a query based on the product identifier;

(c) a code segment that queries a network of information utilizing a wireless communication medium, wherein the network is the Internet;

(d) a code segment that displays the information associated with the product identifier on a display;

(e) a code segment that ranks the information based on relevance to the product identifier; and

(f) wherein the information relates to at least one of features, shipping and availability associated with the product, and the information is displayed to reflect a relationship between the information and a user profile.

11. A computer program embodied on a computer-readable medium that creates an information summary as recited in claim 10, including logic that parses the response to the query for subsequent display based on predetermined criteria.

12. A computer program embodied on a computer-readable medium that creates an information summary as recited in claim 10, including logic that modifies constants that are utilized by the system for dynamically configuring the system based on current user inputs.

13. A computer program embodied on a computer-readable medium that creates an information summary as recited in claim 10, including logic that reduces the communication transmission rate to enhance the transmission quality over the wireless communication.

14. A computer program embodied on a computer-readable medium that creates an information summary as recited in claim 10, including logic that recognizes patterns to enhance the location of pertinent information.

15. A computer program embodied on a computer-readable medium that creates an information summary as recited in claim 10, including logic that queries the Internet to obtain pertinent information.

16. A computer program embodied on a computer-readable medium that creates an information summary as recited in claim 10, including logic that optimizes the query for a particular search engine.

17. A computer program embodied on a computer-readable medium that creates an information summary as recited in claim 10, including the step of querying for alternative product identifiers to obtain additional pertinent information.

Description

FIELD OF THE INVENTION

The present invention relates to agent based systems and more particularly to a mobile computing environment and more particularly to a mobile computing environment that accesses the Internet to obtain product information for a user.

Agent based technology has become increasingly important for use with applications designed to interact with a user for performing various computer based tasks in foreground and background modes. Agent software comprises computer programs that are set on behalf of users to perform routine, tedious and time-consuming tasks. To be useful to an individual user, an agent must be personalized to the individual user's goals, habits and preferences. Thus, there exists a substantial requirement for the agent to efficiently and effectively acquire user-specific knowledge from the user and utilize it to perform tasks on behalf of the user.

The concept of agency, or the user of agents, is well established. An agent is a person authorized by another person, typically referred to as a principal, to act on behalf of the principal. In this manner the principal empowers the agent to perform any of the tasks that the principal is unwilling or unable to perform. For example, an insurance agent may handle all of the insurance requirements for a principal, or a talent agent may act on behalf of a performer to arrange concert dates.

With the advent of the computer, a new domain for employing agents has arrived. Significant advances in the realm of expert systems enable computer programs to act on behalf of computer users to perform routine, tedious and other time-consuming tasks. These computer programs are referred to as "software agents."

Moreover, there has been a recent proliferation of computer and communication networks. These networks permit a user to access vast amounts of information and services without, essentially, any geographical boundaries. Thus, a software agent has a rich environment to perform a large number of tasks on behalf of a user. For example, it is now possible for an agent to make an airline reservation, purchase the ticket, and have the ticket delivered directly to a user. Similarly, an agent could scan the Internet and obtain information ranging from the latest sports or news to a particular graduate thesis in applied physics. Current solutions fail to apply agent technology to existing calendar technology to provide targeted acquisition of background information for a user's upcoming events.

SUMMARY OF THE INVENTION

According to a broad aspect of a preferred embodiment of the invention, A system is disclosed that facilitates web-based comparison shopping in conventional, physical, non-web retail environments. A wireless phone or similar hand-held wireless device with Internet Protocol capability is combined with a miniature barcode reader (installed either inside the phone or on a short cable) and utilized to obtain definitive product identification by, for example, scanning a Universal Product Code (UPC) bar code from a book or other product. The wireless device transmits the definitive product identifier to a service routine (running on a Web server), which converts it to (in the case of books) its International Standard Book Number or (in the case of other products) whatever identifier is appropriate. The service routine then queries the Web to find price, shipping and availability information on the product from various Web suppliers. This information is formatted and displayed on the hand-held device's screen. The user may then use the hand-held device to place an order interactively.

DESCRIPTION OF THE DRAWINGS

The foregoing and other objects, aspects and advantages are better understood from the following detailed description of a preferred embodiment of the invention with reference to the drawings, in which:

FIG. 1 is a block diagram of a representative hardware environment in accordance with a preferred embodiment;

FIG. 2 is a flowchart of the system in accordance with a preferred embodiment;

FIG. 3 is a flowchart of a parsing unit of the system in accordance with a preferred embodiment;

FIG. 4 is a flowchart for pattern matching in accordance with a preferred embodiment;

FIG. 5 is a flowchart for a search unit in accordance with a preferred embodiment;

FIG. 6 is a flowchart for overall system processing in accordance with a preferred embodiment;

FIG. 7 is a flowchart of topic processing in accordance with a preferred embodiment;

FIG. 8 is a flowchart of meeting record processing in accordance with a preferred embodiment;

FIG. 9 is a block diagram of process flow of a pocket bargain finder in accordance with a preferred embodiment;

FIG. 10A and 10B are a block diagram and flowchart depicting the logic associated with creating a customized content web page in accordance with a preferred embodiment;

FIG. 11 is a flowchart depicting the detailed logic associated with retrieving user- centric content in accordance with a preferred embodiment;

FIG. 12 is a data model of a user profile in accordance with a preferred embodiment;

FIG. 13 is a persona data model in accordance with a preferred embodiment;

FIG. 14 is an intention data model in accordance with a preferred embodiment;

FIG. 15 is a flowchart of the processing for generating an agent's current statistics in accordance with a preferred embodiment;

FIG. 16 is a flowchart of the logic that determines the personalized product rating for a user in accordance with a preferred embodiment;

FIG. 17 is a flowchart of the logic for accessing the centrally stored profile in accordance with a preferred embodiment;

FIG. 18 is a flowchart of the interaction logic between a user and the integrator for a particular supplier in accordance with a preferred embodiment;

FIG. 19 is a flowchart of the agent processing for generating a verbal summary in accordance with a preferred embodiment;

FIG. 20 illustrates a display login in accordance with a preferred embodiment;

FIG. 21 illustrates a managing daily logistics display in accordance with a preferred embodiment;

FIG. 22 illustrates a user main display in accordance with a preferred embodiment;

FIG. 23 illustrates an agent interaction display in accordance with a preferred embodiment;

FIG. 24 is a block diagram of an active knowledge management system in accordance with a preferred embodiment;

FIG. 25 is a block diagram of a back end server in accordance with a preferred embodiment; and

FIG. 26 is a block diagram of a magic wall in accordance with a preferred embodiment.

DETAILED DESCRIPTION

A preferred embodiment of a system in accordance with the present invention is preferably practiced in the context of a personal computer such as an IBM compatible personal computer, Apple Macintosh computer or UNIX based workstation. A representative hardware environment is depicted in FIG. 1, which illustrates a typical hardware configuration of a workstation in accordance with a preferred embodiment having a central processing unit 110, such as a microprocessor, and a number of other units interconnected via a system bus 112. The workstation shown in FIG. 1 includes a Random Access Memory (RAM) 114, Read Only Memory (ROM) 116, an I/O adapter 118 for connecting peripheral devices such as disk storage units 120 to the bus 112, a user interface adapter 122 for connecting a keyboard 124, a mouse 126, a speaker 128, a microphone 132, and/or other user interface devices such as a touch screen (not shown) to the bus 112, communication adapter 134 for connecting the workstation to a communication network (e.g., a data processing network) and a display adapter 136 for connecting the bus 112 to a display device 138. The workstation typically has resident thereon an operating system such as the Microsoft Windows NT or Windows/95 Operating System (OS), the IBM OS/2 operating system, the MAC OS, or UNIX operating system. Those skilled in the art will appreciate that the present invention may also be implemented on platforms and operating systems other than those mentioned.

A preferred embodiment is written using JAVA, C, and the C++ language and utilizes object oriented programming methodology. Object oriented programming (OOP) has become increasingly used to develop complex applications. As OOP moves toward the mainstream of software design and development, various software solutions require adaptation to make use of the benefits of OOP. A need exists for these principles of OOP to be applied to a messaging interface of an electronic messaging system such that a set of OOP classes and objects for the messaging interface can be provided.

OOP is a process of developing computer software using objects, including the steps of analyzing the problem, designing the system, and constructing the program. An object is a software package that contains both data and a collection of related structures and procedures. Since it contains both data and a collection of structures and procedures, it can be visualized as a self-sufficient component that does not require other additional structures, procedures or data to perform its specific task. OOP, therefore, views a computer program as a collection of largely autonomous components, called objects, each of which is responsible for a specific task. This concept of packaging data, structures, and procedures together in one component or module is called encapsulation.

In general, OOP components are reusable software modules which present an interface that conforms to an object model and which are accessed at run-time through a component integration architecture. A component integration architecture is a set of architecture mechanisms which allow software modules in different process spaces to utilize each others capabilities or functions. This is generally done by assuming a common component object model on which to build the architecture.

It is worthwhile to differentiate between an object and a class of objects at this point. An object is a single instance of the class of objects, which is often just called a class. A class of objects can be viewed as a blueprint, from which many objects can be formed.

OOP allows the programmer to create an object that is a part of another object. For example, the object representing a piston engine is said to have a composition-relationship with the object representing a piston. In reality, a piston engine comprises a piston, valves and many other components; the fact that a piston is an element of a piston engine can be logically and semantically represented in OOP by two objects.

OOP also allows creation of an object that "depends from" another object. If there are two objects, one representing a piston engine and the other representing a piston engine wherein the piston is made of ceramic, then the relationship between the two objects is not that of composition. A ceramic piston engine does not make up a piston engine. Rather it is merely one kind of piston engine that has one more limitation than the piston engine; its piston is made of ceramic. In this case, the object representing the ceramic piston engine is called a derived object, and it inherits all of the aspects of the object representing the piston engine and adds further limitation or detail to it. The object representing the ceramic piston engine "depends from" the object representing the piston engine. The relationship between these objects is called inheritance.

When the object or class representing the ceramic piston engine inherits all of the aspects of the objects representing the piston engine, it inherits the thermal characteristics of a standard piston defined in the piston engine class. However, the ceramic piston engine object overrides these ceramic specific thermal characteristics, which are typically different from those associated with a metal piston. It skips over the original and uses new functions related to ceramic pistons. Different kinds of piston engines have different characteristics, but may have the same underlying functions associated with it (e.g., how many pistons in the engine, ignition sequences, lubrication, etc.). To access each of these functions in any piston engine object, a programmer would call the same functions with the same names, but each type of piston engine may have different/overriding implementations of functions behind the same name. This ability to hide different implementations of a function behind the same name is called polymorphism and it greatly simplifies communication among objects.

With the concepts of composition-relationship, encapsulation, inheritance and polymorphism, an object can represent just about anything in the real world. In fact, our logical perception of the reality is the only limit on determining the kinds of things that can become objects in object-oriented software. Some typical categories are as follows:

Objects can represent physical objects, such as automobiles in a traffic-flow simulation, electrical components in a circuit-design program, countries in an economics model, or aircraft in an air-traffic-control system.

Objects can represent elements of the computer-user environment such as windows, menus or graphics objects.

An object can represent an inventory, such as a personnel file or a table of the latitudes and longitudes of cities.

An object can represent user-defined data types such as time, angles, and complex numbers, or points on the plane.

With this enormous capability of an object to represent just about any logically separable matters, OOP allows the software developer to design and implement a computer program that is a model of some aspects of reality, whether that reality is a physical entity, a process, a system, or a composition of matter. Since the object can represent anything, the software developer can create an object which can be used as a component in a larger software project in the future.

If 90% of a new OOP software program consists of proven, existing components made from preexisting reusable objects, then only the remaining 10% of the new software project has to be written and tested from scratch. Since 90% already came from an inventory of extensively tested reusable objects, the potential domain from which an error could originate is 10% of the program. As a result, OOP enables software developers to build objects out of other, previously built, objects.

This process closely resembles complex machinery being built out of assemblies and sub-assemblies. OOP technology, therefore, makes software engineering more like hardware engineering in that software is built from existing components, which are available to the developer as objects. All this adds up to an improved quality of the software as well as an increased speed of its development.

Programming languages are beginning to fully support the OOP principles, such as encapsulation, inheritance, polymorphism, and composition-relationship. With the advent of the C++ language, many commercial software developers have embraced OOP. C++ is an OOP language that offers a fast, machine-executable code. Furthermore, C++ is suitable for both commercial-application and systems-programming projects. For now, C++ appears to be the most popular choice among many OOP programmers, but there is a host of other OOP languages, such as Smalltalk, common lisp object system (CLOS), and Eiffel. Additionally, OOP capabilities are being added to more traditional popular computer programming languages such as Pascal.

The benefits of object classes can be summarized, as follows:

Objects and their corresponding classes break down complex programming problems into many smaller, simpler problems.

Encapsulation enforces data abstraction through the organization of data into small, independent objects that can communicate with each other. Encapsulation protects the data in an object from accidental damage, but allows other objects to interact with that data by calling the object's member functions and structures.

Subclassing and inheritance make it possible to extend and modify objects through deriving new kinds of objects from the standard classes available in the system. Thus, new capabilities are created without having to start from scratch.

Polymorphism and multiple inheritance make it possible for different programmers to mix and match characteristics of many different classes and create specialized objects that can still work with related objects in predictable ways.

Class hierarchies and containment hierarchies provide a flexible mechanism for modeling real-world objects and the relationships among them.

Libraries of reusable classes are useful in many situations, but they also have some limitations. For example:

Complexity. In a complex system, the class hierarchies for related classes can become extremely confusing, with many dozens or even hundreds of classes.

Flow of control. A program written with the aid of class libraries is still responsible for the flow of control (i.e., it must control the interactions among all the objects created from a particular library). The programmer has to decide which functions to call at what times for which kinds of objects.

Duplication of effort. Although class libraries allow programmers to use and reuse many small pieces of code, each programmer puts those pieces together in a different way. Two different programmers can use the same set of class libraries to write two programs that do exactly the same thing but whose internal structure (i.e., design) may be quite different, depending on hundreds of small decisions each programmer makes along the way. Inevitably, similar pieces of code end up doing similar things in slightly different ways and do not work as well together as they should.

Class libraries are very flexible. As programs grow more complex, more programmers are forced to reinvent basic solutions to basic problems over and over again. A relatively new extension of the class library concept is to have a framework of class libraries. This framework is more complex and consists of significant collections of collaborating classes that capture both the small scale patterns and major mechanisms that implement the common requirements and design in a specific application domain. They were first developed to free application programmers from the chores involved in displaying menus, windows, dialog boxes, and other standard user interface elements for personal computers.

Frameworks also represent a change in the way programmers think about the interaction between the code they write and code written by others. In the early days of procedural programming, the programmer called libraries provided by the operating system to perform certain tasks, but basically the program executed down the page from start to finish, and the programmer was solely responsible for the flow of control. This was appropriate for printing out paychecks, calculating a mathematical table, or solving other problems with a program that executed in just one way.

The development of graphical user interfaces began to turn this procedural programming arrangement inside out. These interfaces allow the user, rather than program logic, to drive the program and decide when certain actions should be performed. Today, most personal computer software accomplishes this by means of an event loop which monitors the mouse, keyboard, and other sources of external events and calls the appropriate parts of the programmer's code according to actions that the user performs. The programmer no longer determines the order in which events occur. Instead, a program is divided into separate pieces that are called at unpredictable times and in an unpredictable order. By relinquishing control in this way to users, the developer creates a program that is much easier to use. Nevertheless, individual pieces of the program written by the developer still call libraries provided by the operating system to accomplish certain tasks, and the programmer must still determine the flow of control within each piece after being called by the event loop. Application code still "sits on top of" the system.

Even event loop programs require programmers to write a lot of code that should not need to be written separately for every application. The concept of an application framework carries the event loop concept further. Instead of dealing with all the nuts and bolts of constructing basic menus, windows, and dialog boxes and then making these things all work together, programmers using application frameworks start with working application code and basic user interface elements in place. Subsequently, they build from there by replacing some of the generic capabilities of the framework with the specific capabilities of the intended application.

Application frameworks reduce the total amount of code that a programmer has to write from scratch. However, because the framework is really a generic application that displays windows, supports copy and paste, and so on, the programmer can also relinquish control to a greater degree than event loop programs permit. The framework code takes care of almost all event handling and flow of control, and the programmer's code is called only when the framework needs it (e.g., to create or manipulate a proprietary data structure).

A programmer writing a framework program not only relinquishes control to the user (as is also true for event loop programs), but also relinquishes the detailed flow of control within the program to the framework. This approach allows the creation of more complex systems that work together in interesting ways, as opposed to isolated programs, having custom code, being created over and over again for similar problems.

Thus, as is explained above, a framework basically is a collection of cooperating classes that make up a reusable design solution for a given problem domain. It typically includes objects that provide default behavior (e.g., for menus and windows), and programmers use it by inheriting some of that default behavior and overriding other behavior so that the framework calls application code at the appropriate times.

There are three main differences between frameworks and class libraries:

Behavior versus protocol Class libraries are essentially collections of behaviors that you can call when you want those individual behaviors in your program. A framework, on the other hand, provides not only behavior but also the protocol or set of rules that govern the ways in which behaviors can be combined, including rules for what a programmer is supposed to provide versus what the framework provides.

Call versus override. With a class library, the code the programmer instantiates objects and calls their member functions. It's possible to instantiate and call objects in the same way with a framework (i.e., to treat the framework as a class library), but to take full advantage of a framework's reusable design, a programmer typically writes code that overrides and is called by the framework. The framework manages the flow of control among its objects. Writing a program involves dividing responsibilities among the various pieces of software that are called by the framework rather than specifying how the different pieces should work together.

Implementation versus design. With class libraries, programmers reuse only implementations, whereas with frameworks, they reuse design. A framework embodies the way a family of related programs or pieces of software work. It represents a generic design solution that can be adapted to a variety of specific problems in a given domain. For example, a single framework can embody the way a user interface works, even though two different user interfaces created with the same framework might solve quite different interface problems.

Thus, through the development of frameworks for solutions to various problems and programming tasks, significant reductions in the design and development effort for software can be achieved. A preferred embodiment of the invention utilizes HyperText Markup Language (HTML) to implement documents on the Internet together with a general-purpose secure communication protocol for a transport medium between the client and the Newco. HTTP or other protocols could be readily substituted for HTML without undue experimentation. Information on these products is available in T. Berners-Lee, D. Connoly, "RFC 1866: Hypertext Markup Language-2.0" (November 1995); and R. Fielding, H, Frystyk, T. Berners-Lee, J. Gettys and J. C. Mogul, "Hypertext Transfer Protocol--HTTP/1.1: HTTP Working Group Internet Draft" (May 2, 1996). HTML is a simple data format used to create hypertext documents that are portable from one platform to another. HTML documents are SGML documents with generic semantics that are appropriate for representing information from a wide range of domains. HTML has been in use by the World-Wide Web global information initiative since 1990. HTML is an application of ISO Standard 8879:1986 Information Processing Text and Office Systems; Standard Generalized Markup Language (SGML).

To date, Web development tools have been limited in their ability to create dynamic Web applications which span from client to server and interoperate with existing computing resources. Until recently, HTML has been the dominant technology used in development of Web-based solutions. However, HTML has proven to be inadequate in the following areas:

Poor performance;

Restricted user interface capabilities;

Can only produce static Web pages;

Lack of interoperability with existing applications and data; and

Inability to scale.

Sun Microsystem's Java language solves many of the client-side problems by:

Improving performance on the client side;

Enabling the creation of dynamic, real-time Web applications; and

Providing the ability to create a wide variety of user interface components.

With Java, developers can create robust User Interface (UI) components. Custom "widgets" (e.g. real-time stock tickers, animated icons, etc.) can be created, and client-side performance is improved. Unlike HTML, Java supports the notion of client-side validation, off loading appropriate processing onto the client for improved performance. Dynamic, real-time Web pages can be created. Using the above-mentioned custom UI components, dynamic Web pages can also be created.

Sun's Java language has emerged as an industry-recognized language for "programming the Internet." Sun defines Java as: "a simple, object-oriented, distributed, interpreted, robust, secure, architecture-neutral, portable, high-performance, multithreaded, dynamic, buzzword-compliant, general-purpose programming language. Java supports programming for the Internet in the form of platform-independent Java applets." Java applets are small, specialized applications that comply with Sun's Java Application Programming Interface (API) allowing developers to add "interactive content" to Web documents (e.g. simple animations, page adornments, basic games, etc.). Applets execute within a Java-compatible browser (e.g. Netscape Navigator) by copying code from the server to client. From a language standpoint, Java's core feature set is based on C++. Sun's Java literature states that Java is basically "C++, with extensions from Objective C for more dynamic method resolution".

Another technology that provides similar function to JAVA is provided by Microsoft and ActiveX Technologies, to give developers and Web designers wherewithal to build dynamic content for the Internet and personal computers. ActiveX includes tools for developing animation, 3-D virtual reality, video and other multimedia content. The tools use Internet standards, work on multiple platforms, and are being supported by over 100 companies. The group's building blocks are called ActiveX Controls, small, fast components that enable developers to embed parts of software in hypertext markup language (HTML) pages. ActiveX Controls work with a variety of programming languages including Microsoft Visual C++, Borland Delphi, Microsoft Visual Basic programming system and, in the future, Microsoft's development tool for Java, code named "Jakarta." ActiveX Technologies also includes ActiveX Server Framework, allowing developers to create server applications. One of ordinary skill in the art readily recognizes that ActiveX could be substituted for JAVA without undue experimentation to practice the invention.

In accordance with a preferred embodiment, BackgroundFinder (BF) is implemented as an agent responsible for preparing an individual for an upcoming meeting by helping him/her retrieve relevant information about the meeting from various sources. BF receives input text in character form indicative of the target meeting. The input text is generated in accordance with a preferred embodiment by a calendar program that includes the time of the meeting. As the time of the meeting approaches, the calendar program is queried to obtain the text of the target event and that information is utilized as input to the agent. Then, the agent parses the input meeting text to extract its various components such as title, body, participants, location, time etc. The system also performs pattern matching to identify particular meeting fields in a meeting text. This information is utilized to query various sources of information on the web and obtain relevant stories about the current meeting to send back to the calendaring system. For example, if an individual has a meeting with Netscape and Microsoft to talk about their disputes, and would obtain this initial information from the calendaring system. It will then parse out the text to realize that the companies in the meeting are "Netscape" and "Microsoft" and the topic is "disputes." Then, the system queries the web for relevant information concerning the topic. Thus, in accordance with an objective of the invention, the system updates the calendaring system and eventually the user with the best information it can gather to prepare the user for the target meeting. In accordance with a preferred embodiment, the information is stored in a file that is obtained via selection from a link imbedded in the calendar system.

PROGRAM ORGANIZATION

A computer program in accordance with a preferred embodiment is organized in five distinct modules: BF.Main, BF.Parse, Background Finder.Error, BF.PatternMatching and BF.Search. There is also a frmMain which provides a user interface used only for debugging purposes. The executable programs in accordance with a preferred embodiment never execute with the user interface and should only return to the calendaring system through Microsoft's Winsock control. A preferred embodiment of the system executes in two different modes which can be specified under the command line sent to it by the calendaring system. When the system runs in simple mode, it executes a keyword query to submit to external search engines. When executed in complex mode, the system performs pattern matching before it forms a query to be sent to a search engine.

DATA STRUCTURES

The system in accordance with a preferred embodiment utilizes three user defined structures:

1. TMeetingRecord;

2. TPatternElement; and

3. TPatternRecord.

The user-defined structure, tMeetingRecord, is used to store all the pertinent information concerning a single meeting. This info includes userID, an original description of the meeting, the extracted list of keywords from the title and body of meeting etc. It is important to note that only one meeting record is created per instance of the system in accordance with a preferred embodiment. This is because each time the system is spawned to service an upcoming meeting, it is assigned a task to retrieve information for only one meeting. Therefore, the meeting record created corresponds to the current meeting examined. ParseMeetingText populates this meeting record and it is then passed around to provide information about the meeting to other functions.

If GoPattemMatch can bind any values to a particular meeting field, the corresponding entries in the meeting record is also updated. The structure of tMeetingRecord with each field described in parentheses is provided below in accordance with a preferred embodiment.

A.1.1.1.1.1 Public Type tMeetingRecord

sUserID As String (user id given by Munin)

sTitleOrig As String (original non stop listed title we need to keep around to send back to Munin)

sTitleKW As String (stoplisted title with only keywords)

sBodyKW As String (stoplisted body with only keywords)

sCompany() As String (companys identified in title or body through pattern matching)

sTopic() As String (topics identified in title or body through pattern matching)

sPeople() As String (people identified in title or body through pattern matching)

sWhen() As String (time identified in title or body through pattern matching)

sWhere() As String (location identified in title or body through pattern matching)

sLocation As String (location as passed in by Munin)

sTime As String (time as passed in by Munin)

sParticipants() As String (all participants engaged as passed in by Munin)

sMeetingText As String (the original meeting text w/o userid)

End Type

There are two other structures which are created to hold each individual pattern utilized in pattern matching. The record tAPatternRecord is an array containing all the components/elements of a pattern. The type tAPatternElement is an array of strings which represent an element in a pattern. Because there may be many "substitutes" for each element, we need an array of strings to keep track of what all the substitutes are. The structures of tAPatternElement and tAPatternRecord are presented below in accordance with a preferred embodiment.

Public Type tAPatternElement

elementArray() As String

End Type

Public Type tAPatternRecord

patternArray() As tAPatternElement

End Type

COMMON USER DEFINED CONSTANTS

Many constants are defined in each declaration section of the program which may need to be updated periodically as part of the process of maintaining the system in accordance with a preferred embodiment. The constants are accessible to allow dynamic configuration of the system to occur as updates for maintaining the code.

Included in the following tables are lists of constants from each module which I thought are most likely to be modified from time to time. However, there are also other constants used in the code not included in the following list. It does not mean that these non-included constants will never be changed. It means that they will change much less frequently.

For the Main Module (BF.Main):

    ______________________________________
                 PRESET
    CONSTANT     VALUE      USE
    ______________________________________
    MSGTOMUNIN.sub.-- TYPE
                 6          Define the message
                            number used to identiy
                            messages between BF
                            and Munin
    IP.sub.-- ADDRESS.sub.-- MUNIN
                 "10.2.100.48"
                            Define the IP address
                            of the machine in which
                            Munin and BF are
                            running on so they can
                            transfer data through UDP.
    PORT.sub.-- MUNIN
                 7777       Define the remote port in
                            which we are operating on.
    TIMEOUT.sub.-- AV
                 60         Define constants for setting
                            time out in inet controls
    TIMEOUT.sub.-- NP
                 60         Define constants for setting
                            time out in inet controls
    CMD.sub.-- SEPARATOR
                 "/"        Define delimiter to tell
                            which party of Munin's
                            command represents the
                            beginning of our input
                            meeting text.
    OUTPARAM.sub.-- SEPAR
                 "::"       Define delimiter for
    ATOR                    separating out different
                            portions of the output.
                            The separator is for
                            delimiting the msg type,
                            the user id, the meeting
                            title and the beginning of the
                            actual stories retrieved.
    ______________________________________

    ______________________________________
                  CURRENT
    CONSTANT      VALUE     USE
    ______________________________________
    PAST.sub.-- NDAYS
                  5         Define number of days you
                            want to look back for
                            AltaVista articles.
                            Doesn't really matter
                            now because we aren't really
                            doing a news search in
                            alta vista. We want all into.
    CONNECTOR.sub.-- AV.sub.-- URL
                  "+AND+"   Define how to connect
                            keywords. We want all our
                            keywords in the string so
                            for now use AND.
                            If you want to do an OR or
                            something, just change
                            connector.
    CONNECTOR.sub.-- NP.sub.-- URL
                  "+AND+"   Define how to connect
                            keywords. We want all
                            our keywords in the string
                            so for now use AND. If you
                            want to do an OR or
                            something, just
                            change connector.
    NUM.sub.-- NP.sub.-- STORIES
                  3         Define the number of
                            stories to return
                            back to Munin from
                            NewsPage.
    NUM.sub.-- AV.sub.-- STORIES
                  3         Define the number of stories
                            to return back to Munin
                            from AltaVista.
    ______________________________________

    ______________________________________
                    CURRENT
    CONSTANT        VALUE     USE
    ______________________________________
    PORTION.sub.-- SEPARATOR
                    "::"      Define the separator
                              between different
                              portions of the meeting
                              text sent in by Munin.
                              For example in
                              "09::Meet with Chad::
                              about life::Chad .vertline.
                              Denise::::::"
                              "::" is the
                              separator between
                              different parts
                              of the meeting text.
    PARTICIPANT.sub.-- SEPARATOR
                    ".vertline."
                              Define the separator
                              between each
                              participant in the
                              participant list
                              portion of the
                              original meeting
                              text.
                              Refer to example above.
    ______________________________________

    ______________________________________
    PAT  PAT
    GRP  #      PATTERN          EXAMPLE
    ______________________________________
    1    a      $PEOPLE$ of      Paul Maritz of Microsoft
                $COMPANY$
         b      $PEOPLE$ from    Bill Gates, Paul Allen and
                $COMPANY$        Paul Maritz from Microsoft
    2    a      $TOPIC.sub.-- UPPER$ meeting
                                 Push Technology Meeting
         b      $TOPIC.sub.-- UPPER$ mtg
                                 Push Technology Mtg
         c      $TOPIC.sub.-- UPPER$ demo
                                 Push Technology demo
         d      $TOPIC.sub.-- UPPER$
                                 Push Technology interview
                interview
         e      $TOPIC.sub.-- UPPER$
                                 Push Technology
                presentation     presentation
         f      $TOPIC.sub.-- UPPER$ visit
                                 Push Technology visit
         g      $TOPIC.sub.-- UPPER$ briefing
                                 Push Technology briefing
         h      $TOPIC.sub.-- UPPER$
                                 Push Technology
                discussion       discussion
         i      $TOPIC.sub.-- UPPER$
                                 Push Technology
                workshop         workshop
         j      $TOPIC.sub.-- UPPER$ prep
                                 Push Technology prop
         k      $TOPIC.sub.-- UPPER$ review
                                 Push Technology review
         l      $TOPIC.sub.-- UPPER$ lunch
                                 Push Technology lunch
         m      $TOPIC.sub.-- UPPER$ project
                                 Push Technology project
         n      $TOPIC.sub.-- UPPER$ projects
                                 Push Technology projects
    3    a      $COMPANY$ corporation
                                 Intel Corporation
         b      $COMPANY$ corp.  IBM Corp
         c      $COMPANY$ systems
                                 Cisco Systems
         d      $COMPANY$ limited
                                 IBM limited
         e      $COMPANY$ ltd    IBM ltd
    4    a      about $TOPIC.sub.-- ALL$
                                 About intelligent agents
                                 technology
         b      discuss $TOPIC.sub.-- ALL$
                                 Discuss intelligent agents
                                 technology
         c      show $TOPIC.sub.-- ALL$
                                 Show the client our
                                 intelligent agents
                                 technology
         d      re: $TOPIC.sub.-- ALL$
                                 re: intelligent agents
                                 technology
         e      review $TOPIC.sub.-- ALL$
                                 Review intelligent agents
                                 technology
         f      agenda           The agenda is as follows:
                                 cleanup
                                 clean up
                                 cleanup
         g      agenda: $TOPIC.sub.-- ALL$
                                 Agenda:
                                 demo client intelligent
                                 agents technology
                                 demo ecommerce
    6    a      w/$PEOPLE$ of    Meet w/Joe Carter of
                $COMPANY$        Andersen Consulting
         b      w/$PEOPLE$ from  Meet w/Joe Carter from
                $COMPANY$        Andersen Consulting
    6    a      w/$COMPANY$ per  Talk w/Intel per Jason
                $PEOPLE$         Foster
    8    a      At $LOCATION$    At LuLu's restaurant
         b      In $LOCATION$    in Santa Clara
    9    a      Per $PEOPLE$     per Susan Butler
    10   a      call w/$PEOPLE$  Conf call w/John Smith
         B      call with $PEOPLE$
                                 Conf call with John Smith
    11   A      prep for $TOPIC.sub.-- ALL$
                                 Prep for London meeting
         B      preparation for  Preparation for London
                $TOPIC.sub.-- ALL$
                                 meeting
    ______________________________________

    ______________________________________
    Procedure         Called
    Name     Type     By          Description
    ______________________________________
    Main     Public   None        This is the main function
    (BF.Main)
             Sub                  where the program first
                                  launches. It initializes BF
                                  with the appropriate
                                  parameters(e.g. Internet
                                  time-out, stoplist. . . )
                                  and calls
                                  GoBF to launch the main
                                  part of the program.
    ProcessCom
             Private  Main        This function parses the
    mandLine Sub                  command line. .It assumes
    (BF.Main)                     that the delimiter indicating
                                  the beginning of input from
                                  Munin is stored in the
                                  constant
                                  CMD.sub.-- SEPARATOR.
    CreateStopLi
             Private  Main        This function sets up a
    st       Function             stop list for future use
    (BF.Main)                     to parse out unwanted
                                  words from the meeting
                                  text.
                                  There are commas on each
                                  side of each word to enable
                                  straight checking.
    CreatePattern
             Public   Main        This procedure is called
    s        Sub                  once when BF is first
    (BF.Pattern                   initialized to create all
    Match)                        the potential patterns
                                  that portions of the
                                  meeting text can bind to. A
                                  pattern can contain however
                                  many elements as needed.
                                  There are
                                  two types of elements. The
                                  first type of elements are
                                  indicators. These are real.
                                  words which. delimit the
                                  potential of a meeting field
                                  (e.g. company) to follow.
                                  Most of these indicators are
                                  stop words as expected
                                  because.
                                  stop words are words
                                  usually common to all
                                  meeting text so it makes
                                  sense they form patterns.
                                  The second type of
                                  elements are
                                  special strings which
                                  represent placeholders.
                                  A placeholder is always
                                  in the form of $*$
                                  where * can
                                  be either PEOPLE,
                                  COMPANY,
                                  TOPIC.sub.-- UPPER,
                                  TIME,LOCATION or
                                  TOPIC.sub.-- ALL.
                                  A pattern can begin
                                  with either one of the
                                  two types of elements and
                                  can be however long,
                                  involving; however any
                                  number/type of elements.
                                  This procedure dynamically
                                  creates a new pattern
                                  record for each pattern
                                  in the table and it
                                  also dynamically creates
                                  new tApatternElements for
                                  each element within a
                                  pattern. In addition, there
                                  is the concept of being
                                  able to substitute
                                  indicators within a
                                  pattern. For example, the
                                  pattern $PEOPLE$ of
                                  $COMPANY$ is similar
                                  to the pattern
                                  $PEOPLE$ from
                                  $COMPANY$. "from" is a
                                  substitute for "to". Our
                                  structure should be able
                                  to express such `a
                                  need for substitution.
    GoBF     Public   Main        This is a wrapper
    (BF.Main)
             Sub                  procedurer that calls
                                  both the parsing
                                  and the searching
                                  subroutines of the
                                  BF. It is also
                                  responsible for
                                  sending data back
                                  to Munin.
    ParseMeetin
             Public   GoBackGroundF
                                  This function takes the
    gText    Function inder       initial meeting text and
    (BF.Parse)                    identifies the userID
                                  of the record as
                                  well as other parts of the
                                  meeting text including the
                                  title, body, participant
                                  list, location and time.
                                  In addition, we call a
                                  helper function
                                  ProcessStopList to
                                  eliminate all the
                                  unwanted words from
                                  the original meeting
                                  title and meeting body
                                  so that only keywords
                                  are left. The
                                  information parsed
                                  out is stored in
                                  the MeetingRecord
                                  structure.
                                  Note that this
                                  function does no
                                  error checking and for
                                  the most time assumes
                                  that the meeting
                                  text string is
                                  correctly formatted
                                  by Munin.
                                  The important variable is
                                  thisMeeting Record is the
                                  temp holder for all info
                                  regarding current meeting.
                                  It's eventually returned
                                  to caller.
    FormatDelim
             Private  ParseMeetingTe
                                  There are 4 ways
    itation           xt,         in which the delimiters
    (BF.Parse)        DetermineNum
                                  can be placed. We
                      Words,      take care of all these
                      GetAWordFrom
                                  cases by reducing them
                      String      down to Case 4 in which
                                  there are no delimiters
                                  around but only between
                                  fields in a string
                                  (e.g., A::B::C)
    DetermineNu
             Public   ParseMeeting
                                  This functions determines
    mWords   Function Text,
                      how many words there are in
    (BF.Parse)        ProcessStop a string (stInEvalString)
                      List        The function assumes that
                                  each word is separated by
                                  a designated separator as
                                  specified in stSeparator. The
                                  return type is an integer that
                                  indicates how many words
                                  have been found assuming
                                  each word
                                  in the string is separated by
                                  stSeparator. This function is
                                  always used along with
                                  GetAWordFromString
                                  and should be called
                                  before calling
                                  GetAWordFrom
                                  String.
    GetAWordFr
             Public   ParseMeeting
                                  This function extracts the ith
    omString Function Text,       word of the
    (BF .Parse)       ProcessStop string(stInEvalString)
                      List        assuming that each word in
                                  the string is separated by a
                                  designated
                                  separator contained in the
                                  variable stSeparator.
                                  In most cases, use this
                                  function with
                                  DetermineNumWords. The
                                  function returns the
                                  wanted word. This
                                  function checks
                                  to make sure that
                                  iLnWordNum is within
                                  bounds so that i
                                  is not greater that the
                                  total number of
                                  words in string or less
                                  than/equal to zero. If it
                                  is out of bounds, we return
                                  empty string to indicate we
                                  can't get anything. We try to
                                  make sure this doesn't
                                  happen by calling
                                  DetermineNumWords first.
    ParseAndCle
             Private  ParseMeetingTe
                                  This function first grabs
    anPhrase Function xt          the word and send it to
    (BF.Parse)                    CleanWord in order strip
                                  the stuff that nobody wants.
                                  There are things in
                                  parseWord that will kill
                                  the word, so we will need a
                                  method of looping through
                                  the body and rejecting
                                  words without killing
                                  the whole function
                                  i guess keep CleanWord and
                                  check a return value.
                                  ok, now I have a word so I
                                  need to send it down the
                                  parse chain. This chain goes
                                  goes
                                  ParseCleanphrase -->
                                  CleanWord -->
                                  EvaluateWord. If the word
                                  gets through the
                                  entire chain without
                                  being killed, it
                                  Will be added at the end
                                  to our keyword string.
                                  first would be the
                                  function that checks
                                  for "/" as a



                                  delimiter and extracts
                                  the parts of that.
                                  This I will call
                                  "StitchFace"
                                  (Denise is more
                                  normal and calls it'
                                  GetAWordFromString)
                                  if this finds words; then each
                                  of these will be sent, in turn,
                                  down the chain. If
                                  these get through the entire
                                  chain without being added or
                                  killed then they will be
                                  added rather than tossed.
    FindMin  Private  ParseAndCleanP This function takes in 6 input
    (BF.Parse)
             Function hrase       values and evaluates to see
                                  what the minimum non
                                  zero value is. It first
                                  creates an array
                                  as a holder so that
                                  we can sort the five
                                  input values in ascending
                                  order. Thus the minimum
                                  value will be the first
                                  non zero value element
                                  of the array. If we go
                                  through
                                  entire array without
                                  finding a non
                                  zero value, we know
                                  that there is an error and
                                  we exit the function.
    CleanWord
             Private  ParseAndCleanP This function tries
    (BF.Parse)
             Function hrase       to clean up a word
                                  in a meeting text.
                                  It first of all
                                  determines if the
                                  string is of a valid
                                  length. It then
                                  passes it through a
                                  series of tests to see it is
                                  clean and when needed, it
                                  will edit the word and strip
                                  unnecessary characters off
                                  of it. Such tests
                                  includes getting rid
                                  of file extensions,
                                  non chars, numbers etc.
    EvaluateWord
             Private  ParseAndCleanP
                                  This function tests to see if
             Function hrase       this word is in the stop list so
    (BF.Parse)                    it can determine whether to
                                  eliminate the word from the
                                  original meeting text.
                                  If a word is not in
                                  the stoplist, it
                                  should stay around as
                                  a keyword and this
                                  function exits
                                  beautifully with
                                  errors. However, if
                                  the words is a stopword,
                                  an error must
                                  be returned. We must
                                  properly delimit
                                  the input test
                                  string so we don't
                                  accidentally retrieve
                                  sub strings.
    GoPatternMa
             Public   GoBF        This procedure is called
    tch      Sub                  when our QueryMethod is
    (BF.Pattern                   set to complex query
    Match)                        meaning we do want to do all
                                  the pattern matching stuff.It
                                  which initializes some
                                  arrays and then invokes
                                  pattern matching on
                                  the title and the
                                  body.
    Matchpattern
             Public   GoPattern Match
                                  This procedure loops
    s        Sub                  through every pattern
    (BF.Pattern                   in the pattern
    Match)                        table and tries to identify
                                  different fields within a
                                  meeting text specified
                                  by sInEvalString. For
                                  debugging purposes it also
                                  tries to tabulate how
                                  many times a certain
                                  pattern was
                                  triggered and
                                  stores it in
                                  gTabulateMatches
                                  to see which pattern
                                  fired the most.
                                  gTabulateMatches is
                                  stored as a global because we
                                  want to be able to run a batch
                                  file of 40 or 50 test strings
                                  and still. be able to know how
                                  often a pattern was triggered.
    MatchApatte
             Private  MatchPatterns
                                  This function goes through
    m        Function             each element in the current
    (BF.Pattern                   pattern. It first evaluates to
    Match)                        determine whether element
                                  a placeholder or an indicator
                                  If it is a placeholder, then it
                                  will try to bind the
                                  placeholder with some value
                                  If it is an indicator, then we
                                  try to locate it. There is a
                                  trick however. Depending on
                                  whether we are at current
                                  element is the head of
                                  the pattern or
                                  not we want to take
                                  different actions.
                                  If we are at the
                                  head, we want to look
                                  for the indicator or
                                  the placeholder. If we
                                  can't find it, then we
                                  know that the current
                                  pattern doesn't exist and
                                  we quit. However, if it is
                                  not the head, then we
                                  continue looking, because
                                  there may still be a head
                                  somewhere. We retry in
                                  this case.
    etingField
             Private  MatchAPattern
                                  This function uses a
    (BF.Pattern
             Function             big switch statement
    Match)                        to first determine
                                  what kind of
                                  placeholder we are
                                  talking about
                                  and depending on what
                                  type of placeholder,
                                  We have specific
                                  requirements and
                                  different binding
                                  criteria as
                                  specified in the
                                  subsequent functions
                                  called such as
                                  BindNames, BindTime
                                  etc. If binding is
                                  successful we add it
                                  to our guessing record.
    BindNames
             Private  MatchMeetingFi
                                  In this function,
    (BF.Pattern
             Function eld         we try to match names
    Match)                        to the corresponding
                                  placeholder
                                  $PEOPLE$. Names are
                                  defined as any
                                  consecutive two
                                  words which are
                                  capitalized. We also
                                  what to retrieve
                                  a series of names
                                  which are connected
                                  by and, or &
                                  so we look until we
                                  don't see any of these
                                  3 separators anymore.
                                  Note that we don't
                                  want to bind
                                  single word names because it
                                  is probably
                                  too general anyway so we
                                  don't want to produce broad
                                  but irrelevant results. This
                                  function calls
                                  BindAFullName which binds
                                  one name so in a since
                                  BindNames collects all the
                                  results from BindAFullName
    BindAFullNa
             Private  BindNames   This function tries to bind a
    ine      Function             full name. If the $PEOPLE$
    (BF.Pattern                   placeholder is not the head of
    Match)                        the pattern, we know that it
                                  has to come right at the
                                  beginning of the test string
                                  because we've been deleting
                                  stuff off the head of the
                                  string all along.
                                  If it is the head, we search
                                  until we find something that
                                  looks like a full name. If we
                                  can't find it, then there's no
                                  such pattern in the text
                                  entirely and we quit entirely
                                  from this pattern. This
                                  should eventually return us
                                  to the net pattern in
                                  MatchPatterns.
    GetNextWor
             Private  BinAFull    This function grabs the next
    dAfterWhite
             Function Name,       word in a test string. It looks
    Space             BindTime,   for the next word after white
    (BF.Pattern       BindCompanyTo
                                  spaces, @ or /. The word is
    Match)            picLoc      defined to end when we
                                  encounter another one of
                                  these white spaces or
                                  separators.
    BindTime Private  MatchMeetingFi
                                  Get the immediate next word
    (BF.Pattern
             Function eld         and see if it looks like a time
    Match)                        pattern. If so we've found a
                                  time and so we want to add it
                                  to the record. We probably



                                  should add more time
                                  patterns. But people don't
                                  seem to like to enter the time
                                  in their titles these days
                                  especially since we. now have
                                  tools like Outlook.
    BindCompan
             Private  MatchMeetingFi
                                  This function finds a
    yTopicLoc
             Function eld         continuous capitalized string
    (BF.Pattern                   and binds it to stMatch
    Match)                        which is passed by reference
                                  from MatchMeetingField. A
                                  continous capitalized sting
                                  is a sequence of capitalized
                                  words which are not
                                  interrupted
                                  by things like, . etc. There's
                                  probably more stuff we can
                                  add to the list of
                                  interruptions.
    LocatePatter
             Private  MatchAPattern
                                  This function tries to locate
    nHead    Function             an element which is an
    (BF.Pattern.                  indicator. Note that this
    Match)                        indicator SHOULD BE AT
    THE HEAD of the pattern
                                  otherwise it would have gone
                                  to the function
                                  LocateIndicator instead.
                                  Therefore; we keep on
                                  grabbing the next word until
                                  either there's no word for us
                                  to grab (quit) or if we find
                                  one of the indicators we are
                                  looking for.
    ContainInArr
             Private  LocatePattern
                                  ` This filnction is really
    ay       Function Head,       simple. It loops through all
    (BF.Pattern       LocateIndicator
                                  the elements in the array
    Match)                        ` to find a matching string.
    Locatelndicat
             Private  MatchAPattern
                                  This function tries to locate
    or       Function             an element which is an
    (BF.Pattern                   indicator. Note that this
    Match)                        indicator is NOT at the head
                                  of the pattern otherwise it
                                  would have gone to
                                  LocatePatternHead instead.
                                  Because of this, if our
                                  pattern is to be satisfied, the
                                  next word we grab HAS to
                                  be the indicator or else we
                                  would have failed. Thus we
                                  only grab one word, test to
                                  see if it is a valid indicator
                                  and the return result.
    InitializeGue
             Private  MatchAPattern
                                  This function reinitializes our
    ssesRecord
             Sub                  temporary test structure
    (BF .Pattern                  because we have already
    Match)                        transferred the info to the
                                  permanent structure, we can
                                  reinitialize it so they each
                                  have one element
    AddToMeeti
             Private  MatchAPattern
                                  This function is only called
    ngRecord Sub                  when we know that the
    (BF.Patterii                  information stored in
    Match)                        tInCurrGuesses is valid
                                  meaning that it represents
                                  legitimate guesses of
                                  meeting fields ready to be
                                  stored in the: permanent
                                  record,InMeetingRecord.
                                  We check to make sure that
                                  we do not store duplicates
                                  and we also what to clean up
                                  what we want to store so that
                                  there's no uttered crap such
                                  as punctuations, etc. The
                                  reason why we don't clean up
                                  until now is to save time. We
                                  don't waste resources calling
                                  ParseAndCleanPhrase until
                                  we know for sure that we are
                                  going to add it permanently.
    NoDuplicate
             Private  AddToMeetingR
                                  This function loops through
    Entry    Function ecord       each element in the array to
    (BF.Pattern                   make sure that the test sting
    Match)                        aString is not the same as
                                  any of the strings already
                                  stored
                                  in the array. Slightly
                                  different from
                                  ContainInArray.
    SearchAltaVi
             Public   GoBackGroundF
                                  This function prepares a
    sta      Function inder       query to be submitted to
    (BF.Search)                   AltaVistaSearch engine. It
                                  submits it and then parses the
                                  returning result in the
                                  appropriate format
                                  containing the title, URL and
                                  body/summary of each story
                                  retrieved. The number of
                                  stories retrieved is specified
                                  by the constant
                                  NUM.sub.-- AV.sub.-- STORIES.
                                  Important variables include
                                  stURLAltaVista used to store
                                  query to submit
                                  stResultHTML used to stcre
                                  html from page specified by
                                  stURLAltaVista.
    ConstructAlt
             Private  SearchAltaVista
                                  This fiuiction constructs the
    aVistaURL
             Function             URL string for the alta vista
    (BF.Search)                   search engine using the
                                  advanced query search mode.
                                  It includes the keywords to
                                  be used, the language and
                                  how we want to rank the
                                  search. Depending on
                                  whether we want to use the
                                  results of our pattern
                                  matching unit, we construct
                                  our query differently.
    ConstructSi
             Private  ConstructAltaVi
                                  This function marches down
    mpleKeyWor
             Function staURl,     the list of keywords stored in
    d                 ConstructNewsP
                                  the stTitleKW or stBodyKW
    (BF.Search)       ageURL      fields of the input meeting
                                  record and links them up into
                                  one string with each keyword
                                  separated by a connector as
                                  determined by the input
                                  variable stInConnector.
                                  Returns this newly
                                  constructed string.
    ConstructCo
             Private  ConstructAltaVi
                                  This function constructs the
    mplexAVKe
             Function staURL      keywords to be send to the
    yWord                         AltaVista site. Unlike
    (BF. Search)                  ConstructSimpleKeyWord
                                  which simply takes all the
                                  keywords from the title to
                                  form the query, this function
                                  will look at the results of BF
                                  's pattern matching process
                                  and see if we are able to
                                  identify any specific
                                  company names or topics for
                                  constructing
                                  the queries. Query will
                                  include company and topic
                                  identified and default to
                                  simple query if we cannot
                                  identify either company or
                                  topic.
    JoinWithCon
             Private  ConstructCompl
                                  This function simply replaces
    nectors  Function exAVKey     the spacesbetween the words
    (BF.Search)       Word,       within the string with a
                      ConstructCompl
                                  connector which is specified
                      exNPKey     by the input.
                      Word,
                      RefineWith
                      Rank
    RefineWithD)
             Private  ConstructAltaVi
                                  This function constructs the
    ate (NOT Function staURL      date portion of the alta vista
    CALLED                        query and returns this portion
    AT THE                        of the URL as a string. It
    MOMENT)                       makes sure that alta vista
    (BF. Search)                  searches for articles within
                                  the past PAST.sub.-- NDAYS.
    RefineWithR
             Private  ConstructAltaVi
                                  This function constructs the
    ank      Function staURL      string needed to passed to
    (BF.Search)                   Altavista in order to rank an
                                  advanced query search. If
                                  we are constructing the
                                  simple query we will take in
                                  all the keywords from the
                                  title. For the complex query,
                                  we will take in words from
                                  company and topic, much the
                                  same way we formed the
                                  query in
                                  ConstructComplexAVKeyW
                                  ord.
    IdertifyBloc
             Public   SearchAltaVista,
                                  This function extracts the
    k        Function SearchNewsPage
                                  block within a string marked
    (BF.Parse                     by the beginning and the
                                  ending tag given as inputs
                                  string at a certain
                                  location(iStart). The block
                                  retrieved does not include the
                                  tags themselves. If the block
                                  cannot be identified with the
                                  specified delimiters, we
                                  return unsuccessful through
                                  the parameter
                                  iReturnSuccess passed to use



                                  by reference. The return type
                                  is the block retrieved.
    IsOpenURL
             Public   SearchAltaVista,
                                  This function determines
    Error    Function SearchNewsPage
                                  whether the error
    (BF.Error)                    encountered is that of a
                                  timeout error. It restores the
                                  mouse to default arrow and
                                  then returns true if it is a time
                                  out or false otherwise.
    SearchNews
             Public   GoBackGroundF
                                  This function prepares a
    Page     Function inder       query to be submitted to
    (BF.Search)       NewsPageSearch
                                  engine. It submits it and then
                                  parses the returning result in
                                  the appropriate format
                                  containing the title, URL and
                                  body/summary of each story
                                  retrieved. The number of
                                  stories retrieved is specified
                                  by the constant
                                  UM.sub.-- NP.sub.-- STORIES
    ConstructNe
             Private  SearchNewsPage
                                  This function constructs the
    wsPageURL
             Function             URL to send to the
    (BF.Search)       NewsPage site. It uses the
                                  information contained in the
                                  input meeting record to
                                  determine what keywords to
                                  use. Also depending whether
                                  we want simple or complex
                                  query, We call diffent
                                  functions to form stings.
    ConstructCo
             Private  ConstructNewsP
                                  This function constructs the
    mplexNPKey
             Function ageURL      keywords to be send to the
    Word              NewsPage site.
    (BF. Search)                  UnlikeConstructKeyWordStr
                                  ing which simply takes all
                                  the keywords from the title to
                                  form the query, this function
                                  will look at the results of BF
                                  's pattern matching process
                                  and see if we are able to
                                  identify any specific
                                  company names or topics for
                                  constructing
                                  the queries. Since newspage
                                  works best when we have a
                                  company name, we'll use
                                  only the company name and
                                  only if there is no company
                                  will we use topic.
    ConstructOv
             Private  GoBackGroundF
                                  This function takes in as
    erallResult
             Function inder       input an array of strings
    (BF .Main)                    (stInStories) and a
                                  MeetingRecord which stores
                                  the information for the
                                  current meeting. Each
                                  element in the array stores
                                  the stories retrieved from
                                  each information source.
                                  The function simply
                                  constructs the appropriate
                                  output to send to Munin
                                  including a return message
                                  type to let Munin know that
                                  it is the BF responding and
                                  also the original user.sub.-- id and
                                  meeting title so Munin
                                  knows which meeting BF is
                                  talking about.
    ConnectAnd
             Public   GoBackGroundF
                                  This function allows
    TransferTo
             Sub      inder       Background Finder to
    Munin                         connect to Munin and
    (BF.Main)                     eventually transport
                                  information to Munin. We
                                  will be using the UDP
                                  protocol instead of the TCP
                                  protocol so we have to set up
                                  the remote host and port
                                  correctly: We use a global
                                  string to store gResult
                                  Overall because although it
                                  is unnecessary with UDP, it is
                                  needed with TCP and if we
                                  ever switch back don't want
                                  to change code.
    DisconnectFr
             Public
    omMuninAn
             Sub
    Quit
    (BF.Main)
    ______________________________________