Search Images Maps Play YouTube News Gmail Drive More »
Sign in
Screen reader users: click this link for accessible mode. Accessible mode has the same essential features but works better with your reader.

Patents

  1. Advanced Patent Search
Publication numberUS20090006543 A1
Publication typeApplication
Application numberUS 12/176,984
Publication dateJan 1, 2009
Filing dateJul 21, 2008
Priority dateAug 20, 2001
Publication number12176984, 176984, US 2009/0006543 A1, US 2009/006543 A1, US 20090006543 A1, US 20090006543A1, US 2009006543 A1, US 2009006543A1, US-A1-20090006543, US-A1-2009006543, US2009/0006543A1, US2009/006543A1, US20090006543 A1, US20090006543A1, US2009006543 A1, US2009006543A1
InventorsMark H. Smit
Original AssigneeMasterobjects
Export CitationBiBTeX, EndNote, RefMan
External Links: USPTO, USPTO Assignment, Espacenet
System and method for asynchronous retrieval of information based on incremental user input
US 20090006543 A1
Abstract
A system and method for asynchronously retrieving information over a network based on incremental input. The system comprises a client part, a communication protocol, and a server part. The server part receives incremental text-based input from one or more objects in the client part, and asynchronously returns matching information to the client part depending on server-defined content channels that each query one or more underlying or connected content sources, such as databases or search engines, to return matches for the latest input and for the latest values and state of other content channels.
Images(38)
Previous page
Next page
Claims(20)
1. A system for asynchronous retrieval of information based on incremental user input, comprising:
a client object on a client computer and a server object on a server computer, wherein the client computer and the server computer are linked by any combination of wired or wireless networks so that they can exchange information;
wherein the client object is linked to an input element in a user interface that allows a user to enter textual information comprising characters and strings to create incremental user input comprising a mutating string of characters;
wherein the user input is transmitted by the client object to the server object while the user input is being formed by a specific user during a user session;
wherein the server object uses the user input received from the client object to query data available on the server computer and to return result strings matching the user input asynchronously from the server computer while the input is being formed on the client computer; and
wherein the client object displays the results in a display element in the user interface on the client computer.
2. The system of claim 1 wherein the server object does not return result strings matching prior user input received from the client object if the client object has sent newer user input to the server object before the server object was ready to return results matching the prior user input during the user session.
3. The system of claim 1 wherein the client object automatically sends an initial request to the server object upon activation of the software on the client computer wherein the server object returns initial results from the data available on the server computer matching the initial client request at the start of the user session before the user has entered any characters.
4. The system of claim 1 wherein the user input sent to the server object is combined in the client object with a second string containing a qualifier, wherein the qualifier string is used by the server object to query a subset of the data available to the server computer and to return the corresponding results to the client object.
5. The system of claim 1 wherein each of the matching result strings is accompanied by a key that identifies each result as it was retrieved from the data available on the server computer, wherein the key of selected results can be used for sorting and merging in the server computer and are transmitted back to the client object for use on the client system.
6. The system of claim 1 wherein the matching result strings are accompanied by one or more metadata strings retrieved from the data available on the server computer that are used by the user interface in the client system to display information corresponding to each individual result string.
7. The system of claim 1 wherein the client object accumulates the user input for an amount of time before sending the resulting string of characters to the server object as a single consolidated query string.
8. The system of claim 1 wherein the text input by the user is marked up with a graphical object that appears under the text to indicate to the user that the server object did not return matching results or that the input is invalid.
9. The system of claim 1 wherein the text input by the user is marked up with a graphical object that appears in front of the text characters entered by the user to indicate to the user that additional character input is expected.
10. The system of claim 1 wherein the server object provides one or more content channels retrieving configurable sets of data available on the server computer, wherein each content channel defines a logical data set to be retrieved from the data content available on the server system and the data to be returned as result strings with optional keys and metadata, and wherein the client object indicates to the server object which content channel is to be queried by the server object by transmitting the name of the content channel to the server object.
11. The system of claim 10 wherein the server object performs one or more queries on the data content available on the server computer based on the input received from the client object, incorporating the input into the content queries using a predefined content channel configuration specified on the server computer, wherein results from these content queries are combined and optionally merged into a single list that is returned to the client object.
12. The system of claim 11 wherein the server object automatically selects the content queries to be performed by the content channel based on one or more query selector configurations, each containing a pattern calculation that is applied against values retrieved from the attributes of a different server object.
13. The system of claim 1 wherein multiple client objects are each linked to user interface elements that appear as side-by-side columns with an associated input field, where each column displays results associated with a content channel that returns data that depends both on the input field and one or more of the columns next to it.
14. The system of claim 13 where the side-by-side columns can be scrolled out of view, and where the currently invisible columns are represented by clickable user interface elements that bring those columns back into view.
15. The system of claim 1 wherein the client object on the client computer accumulates the incremental user input for a calculated amount of time by measuring the amount it took the server computer to respond to prior user input received from the same client in order to throttle the number of transmissions going from that client object to the server system while the server system is busy or when the network connection between the client and the server is slow.
16. The system of claim 1 wherein the client object on the client computer detects when the user starts using the input element in the user interface, and wherein the client object automatically determines that the user's browser or device either can better communicate with the server computer or provides a more suitable user interface by one of opening a different embodiment of the client software that is automatically loaded into a separate browser frame, replaces the current page, or opening in a new page that takes over the configuration of the client object and provides a full-page input element and an associated display element displaying results.
17. The system of claim 1 wherein the client object on the client computer detects whether it is being accessed from a browser or device that does not support asynchronous communication, and wherein the client object scales back functionality by assuming the behavior of a common static input field and automatically reveals a Submit or Search button that allows the user to submit non-incremental input to the server object, and wherein the client object opens a popup, frame, or window in order to present the results that are received from the server object.
18. The system of claim 17 wherein the server system employs an indexer to read and index information available to the server system in connected databases or directories or as flat or XML-formatted files or HTML files and subsequently makes the information available for fast retrieval through one or more content channels without re-retrieving or querying the information in the content source or source files.
19. A system for entering text into input fields in a software application on a device controlled by an on-screen virtual keyboard that is operated by clicking on button symbols that represent individual keys using a stylus or a finger, comprising:
a client component on a device that allows users to input a text string into an input field using a stylus or finger by clicking on a virtual keyboard comprising a range of screen locations that display button symbols that each represent characters similar to those found on a traditional computer keyboard and a server component that is connected to the client component through a wired or wireless computer network;
wherein the first click on the input field opens the virtual keyboard that is displayed to the user in a layer superimposed over the application or in a separate application window that contains the virtual buttons for each possible input character; and
wherein each individual click on the buttons on the virtual keyboard appends, inserts, or deletes the corresponding character into or from the application input field, upon which the client component sends a query for data to the server component, and the server component, while the user is clicking on additional virtual keys on the virtual keyboard, returns matching content to the client object.
20. A method for entering text into input fields in a software application on a device controlled by an on-screen virtual keyboard that is operated by clicking on button symbols that represent individual keys using a stylus or a finger, comprising the steps of:
providing a client component on a device that allows users to input a text string into an input field using a stylus or finger by clicking on a virtual keyboard, the keyboard comprising a range of screen locations that display button symbols that each represent characters similar to those found on a traditional computer keyboard and a server component that is connected to the client component through a wired or wireless computer network;
wherein the first click on the input field opens the virtual keyboard that is displayed to the user in a layer superimposed over the application or in a separate application window that contains the virtual buttons for each possible input character; and
wherein each individual click on the buttons on the virtual keyboard appends, inserts, or deletes the corresponding character into or from the application input field, upon which the client component sends a query for data to the server component, and the server component, while the user is clicking on additional virtual keys on the virtual keyboard, returns matching content to the client object.
Description
    CLAIM OF PRIORITY
  • [0001]
    This application claims the benefit of priority to U.S. Provisional Application Ser. No. 60/951,850, entitled “SYSTEM AND METHOD FOR ASYNCHRONOUS RETRIEVAL OF INFORMATION BASED ON INCREMENTAL USER INPUT”, filed Jul. 25, 2007; this application is also a continuation-in-part of U.S. patent application Ser. No. 11/257,912, entitled “SYSTEM AND METHOD FOR UTILIZING ASYNCHRONOUS CLIENT SERVER COMMUNICATION OBJECTS”, filed Oct. 25, 2005, which is a continuation-in-part of U.S. patent application Ser. No. 09/933,493, entitled “SYSTEM AND METHOD FOR ASYNCHRONOUS CLIENT SERVER SESSION COMMUNICATION”, filed Aug. 20, 2001; each of which applications are herein incorporated by reference.
  • COPYRIGHT NOTICE
  • [0002]
    A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever.
  • FIELD OF INVENTION
  • [0003]
    The invention relates generally to client-server, and Internet applications, and particularly to applications where incremental user input is used to retrieve matching content from one or more server systems to dynamically and immediately update the user interface so that users receive immediate feedback based on the input.
  • BACKGROUND
  • [0004]
    Increasingly, the Internet is becoming a platform for business, consumer, and government applications that used to be deployed in so-called client-server environments, where computer software had to be installed on both a client system and on one or more server systems. Contrary to most client-server environments, Internet applications are entirely managed on the server. Apart from commonly available (and often pre-installed) Internet browser software such as Microsoft's Internet Explorer, Mozilla's Firefox, Apple's Safari, and browser software built into portable devices, no special software needs to be installed on each user's system. Also, because the Internet is based on widely published and accepted standards managed mostly by the Word Wide Web Consortium (W3C), applications that comply to these standards can be used virtually anywhere.
  • [0005]
    The advantages of Internet applications are many and are now widely published and generally accepted. Client-server applications are generally much more difficult and expensive to maintain, update, and access. They also scale poorly on the Internet. In addition, traditional client-server applications were often limited to specific client and server platforms, ranging from PC-DOS to Microsoft Windows, Apple Mac OS, Linux, UNIX, Digital OpenVMS, etc. This limited the availability of such applications, and increased the cost of supporting the widest possible user base. However, traditional client-server applications, through their dedicated support of (and optimization for) specific client and server systems, often excelled in performance and user-friendliness. Even today, moving to a web-based user interface often means a severe degradation of the user experience. Typical Internet applications are based on the so-called “Request-Response Loop”, where users only receive information from the server system after they submit a page or a form using a “Submit” button or after pressing the “Enter” key. This mechanism, in its simplicity perhaps one of the core reasons for the very success of the Internet, is inherently primitive compared to what users have become accustomed to in the client-server world, let alone the luxurious interfaces and quick feedback that is received in local applications running on modern GUI-based operating systems such as Microsoft Windows and Apple Mac OS.
  • SUMMARY
  • [0006]
    Embodiments of the present invention provide a solution around the limitations of the Request-Response Loop. By providing a generic, virtually direct, connection between individual inputs in user applications and server data that is entered, validated, searched, found, and retrieved, the technology makes it possible to provide immediate feedback based on text-based user input. In accordance with an embodiment, a system and method is provided for asynchronously retrieving information over a network based on incremental input. The system comprises a client part, a communication protocol, and a server part. The server part receives incremental text-based input from one or more objects in the client part, and asynchronously returns matching information to the client part depending on server-defined content channels that each query one or more underlying or connected content sources, such as databases or search engines, to return matches for the latest input and for the latest values and state of other content channels. Additional features and applications are also described herein.
  • BRIEF DESCRIPTION OF THE FIGURES
  • [0007]
    FIG. 1 shows an illustration of a system in accordance with an embodiment, and provides an overview of where said embodiment fits into a typical network infrastructure.
  • [0008]
    FIG. 2 shows an illustration of a system in accordance with an embodiment, notably the client part, the Communication protocol, the server part divided into a “server tier” and a “service tier”, and the content sources accessed by said embodiment.
  • [0009]
    FIG. 3 shows an illustration of a client system in accordance with an embodiment and the relationship of its objects to the server system.
  • [0010]
    FIG. 4 shows UML class diagrams of the basic data classes used in an embodiment.
  • [0011]
    FIG. 5 shows UML sequence diagrams of typical events that occur in a basic embodiment that uses a single content channel.
  • [0012]
    FIG. 6 shows UML sequence diagrams of typical events that occur in a complex embodiment that uses multiple dependent content channels.
  • [0013]
    FIG. 7 shows the XML structure of various communication packages used in a system in accordance with an embodiment.
  • [0014]
    FIG. 8 shows illustrations of various configuration files and a screenshot of the corresponding configuration application used in an embodiment.
  • [0015]
    FIG. 9 shows screenshots of the configuration pages used to configure an embodiment so it can connect to underlying content sources.
  • [0016]
    FIG. 10 shows a screenshot of the configuration page used to configure an embodiment so it can provide a content channel and an example of an XML-formatted definition, as it is stored in a corresponding configuration file.
  • [0017]
    FIG. 11 shows a table describing six basic client embodiments in accordance with an embodiment of the invention.
  • [0018]
    FIG. 12 shows two screenshots of web pages that incorporate client objects in accordance with an embodiment.
  • [0019]
    FIG. 13 shows various states of a basic input element used on the client part of an embodiment.
  • [0020]
    FIG. 14 shows illustrations of client user interface element implementations that use dependent content channels in accordance with an embodiment.
  • [0021]
    FIG. 15 shows illustrations of various client user interface elements styled for various end user applications in accordance with an embodiment.
  • [0022]
    FIG. 16 shows illustrations of client user interface elements that use two content channels to provide immediate user feedback upon user input in accordance with an embodiment.
  • [0023]
    FIG. 17 shows screenshots of various states of a complex user interface that uses various client user interface elements in accordance with an embodiment.
  • [0024]
    FIG. 18 shows screenshots of various states of an application that uses various client user interface elements that are linked to dependent content channels in accordance with an embodiment.
  • [0025]
    FIG. 19 shows screenshots of various states of a complex user interface that uses various client user interface elements in accordance with an embodiment.
  • [0026]
    FIG. 20 shows illustrations of the various states of a user interface used to perform multiple lookups in accordance with an embodiment.
  • [0027]
    FIG. 21 shows illustrations of the various states of a user interface used to perform multiple lookups in accordance with an embodiment.
  • [0028]
    FIG. 22 shows illustrations of a text input element implementing a client object to provide user feedback in accordance with an embodiment.
  • [0029]
    FIG. 23 shows a table and a flowchart clarifying the way in which an embodiment of the client implements query throttling.
  • [0030]
    FIG. 24 shows screenshots of embodiments of the present invention that allow of the use of varying technologies to communicate asynchronously between the client and the server.
  • [0031]
    FIG. 25 shows various examples of “full-page” embodiments of the client part of the present invention running on an iPhone.
  • [0032]
    FIG. 26 shows an illustration of a system in accordance with an embodiment, and shows how the QuestObjects Indexer fits into the architecture.
  • [0033]
    FIG. 27 shows illustrations of two business cases in which the present invention is used to provide “syndicated” access to content through fields on third-party websites.
  • DETAILED DESCRIPTION
  • [0034]
    In the detailed description below, various embodiments are described with reference to the QuestObjects system, created by the MasterObjects Company. As described herein, QuestObjects provides a system and method for managing client input, server queries, server responses and client output. One specific type of data that can be made available through the system from a single content source (or a combination of content sources) is defined as a content channel. One or more content channels are considered a QuestObjects Service. Additional glossary is provided in copending U.S. patent application Ser. No. 11/257,912, which is incorporated herein by reference. It will be evident that the technology described herein may be utilized in other embodiments, and with other systems, in addition to the QuestObjects system. As described herein, QuestObjects is a powerful yet easy-to-use and implement, ultra-thin, smart client/server technology that turns ordinary input fields in HTML pages and in native applications into supercharged mini-client/server environments referred to herein as QuestFields. Each QuestField provides large groups of simultaneous users connected over a network with near-instantaneous access to data stored anywhere on the network. QuestFields, and other products based on the QuestObjects technology, provide an “end-to-end” solution that can link virtually any client system with virtually any data server to provide the kind of data access, search, validation, retrieval and manipulation capabilities similar to capabilities that previously were only possible and feasible with local data.
  • QuestObjects System
  • [0035]
    The system underlying the QuestObjects technology provides a highly efficient means to retrieve data from remote content (databases, directories, search engines, web services, XML data, flat files, legacy systems, etc). As shown in FIG. 1, the remote content is typically stored on computers in a server room, accessed over a high-speed local area network, or accessed remotely using a web service or other predefined protocol, and is available to the business applications and to the QuestObjects system through a network connection. The QuestObjects system 100 can be installed on a server alongside existing business applications, and runs in an application server such as the open-source Apache Tomcat or commercial application server software such as IBM WebSphere, BEA WebLogic, and Microsoft ASP.Net server, all of which might also host other applications simultaneously. The application server(s) serve the dynamic content of web pages, the static portions of which is typically served from a static web server for scalability and performance reasons (such as Microsoft's Internet Information server or Apache HTTP server). Web and other applications accessing the server system contain one or more client parts, which are usually referred to as “QuestFields”. The client part and the server part typically communicate over the Internet, over either broadband or low-bandwidth connections even as slow as those provided through telephone modems and GPRS cell phones. The QuestObjects protocol connects the QuestObjects client (QuestField) and the QuestObjects server in a highly efficient manner that only transmits data over the network that is needed by the individual parts at any time. By using standard HTTP as one possible low-level protocol implementation, QuestFields can work in standard Internet environments and infrastructures including firewalls, proxies, and load balancers.
  • [0036]
    FIG. 2 illustrates the objects that implement an embodiment of the QuestObjects system 110. As shown in FIG. 2, the QuestObjects server uses a protocol adapter to communicate to QuestObjects clients. This adapter translates the request and response messages going over the network into a format appropriate for the network. For example, in most Internet applications the messages are transmitted over the HTTP(S) protocol and are formatted using XML. The QuestObjects server comprises a “server tier” and a “content-service tier”.
  • [0037]
    In accordance with an embodiment, the server Tier manages client sessions and requests. The server tier communicates with potentially large numbers of QuestObjects clients using, in one embodiment, an efficient XML-based protocol referred to as the QuestObjects Protocol (QOP). In accordance with this embodiment, the protocol uses HTTP or HTTPS over TCP/IP. By optionally maintaining a session for every active user, the QuestObjects server can greatly reduce network traffic by sending to each QuestObjects client only the data that is needed immediately by that specific client and that was not already communicated in a previous message to that client. The server tier optimizes performance by caching content after it is received from the content-service tier. Each query is checked by a query manager against this cache (entries in which typically expire after a limited amount oftime, depending on the time during which the content is considered current and defined in the content channel configuration described below). A QuestObjects client implementation can access one or more predefined content channels. For each content channel, the corresponding client information and results are maintained in a logical object referred to as a Quester. Quester objects are instantiated immediately after a client session is established and as the client session registers an interest in a content channel.
  • [0038]
    Content that is not yet available in the server tier cache is retrieved from the Content-Service Tier, which accesses one or more content sources, which in turn can be physically located outside the QuestObjects system. The QuestObjects server communicates with these back-end data stores (databases, directories, search engines, web services, files, etc) using their native protocols, such as SQL or LDAP, or any other standard or proprietary protocol using a generic API that supports plug-ins that can be programmed using standard programming languages such as Java or C#. Each type of content source is accessed through a corresponding abstracted object referred to as the “Content Access Module” (CAM). Each CAM is capable of communicating with an underlying content source using its native language, protocol, or format. In the QuestObjects server, predefined content channels determine the content (coming from one or more content sources) that is retrieved by the QuestObjects clients that register themselves for each content channel. It should be noted that in various embodiments, the content-service tier can be located on different computer systems, where the server tier and the content-service tier communicate over a fast network. The server tier can be installed on multiple (load-balanced) computer systems to provide improved scalability in session and request handling. The service tier can be distributed over multiple computer systems to provide dedicated services for distributed content sources, where each copy of the content-service tier embodiment serves one or more content channels defined on it.
  • [0039]
    In accordance with an embodiment there can also be a cache (or even a full in-memory copy of the data) in the content-service tier, although this level of caching is often provided by the content sources themselves. Embodiments of the content-service tier can also pre-fetch often-accessed results from the content source(s), in order to optimize the speed of QuestObjects client requests that can be anticipated, and possibly to fill the QuestObjects caches after a restart of the system. The contents of the caches can also be serialized and written to disk before a restart, so that the QuestObjects server can maintain its performance by re-loading its cache into memory after a restart.
  • [0040]
    FIG. 3 illustrates data objects in the QuestObjects client corresponding to the server-side Questers. In accordance with an embodiment 120, each client-side Quester maintains the client-side input (typically comprising user input, i.e. characters typed by a user, the state of user interface elements clicked, the selection state of the cursor, and optional qualifiers that are included with client requests), and transmits changes to the QuestObjects server as they occur, or delayed and coalesced if they occur in quick succession. For efficiency reasons, multiple client-side Questers can share a single session with the server, which is managed by the client-side Controller, and which is instantiated as a separate object, typically by the first client object that needs it. The Controller can remain alive even after the first client object is no longer needed, as might be the case in a multi-window application or in situations where a client object disappears because a tabbed pane is hidden or deactivated. Like the server, a QuestObjects client may also communicate through a protocol adapter, allowing it to connect to the QuestObjects server using the appropriate low-level communication protocol implementation (such as XML over HTTP over TCP/IP).
  • [0041]
    Embodiments of a QuestObjects client can implement a local cache of results that they have received from the server. In some embodiments, QuestObjects clients hold a copy of the latest result set received from the server, e.g. allowing users to scroll up and down through those results that have already been received without needing repeated round-trips to the QuestObjects server. Other embodiments of a QuestObjects client can also cache the results of prior queries in order to increase system performance even further, avoiding additional unnecessary repeated round-trips between the QuestObjects client and the QuestObjects server.
  • Core Data Objects
  • [0042]
    Embodiments of the present invention provide a highly efficient solution that can be considered completely generic because of the nature of requests and responses traveling through the system. FIG. 4 shows the basic objects that are involved in this method. In particular, FIG. 4A shows that a query 130 comprises user input (referred to as the inputBuffer and typed as a string of characters) with optional qualifier string (which is typically specified by the application designer or selected by the user using a third-party user interface element) and zero or more values derived from attributes of the same or other Questers. In the QuestObjects server, each Quester has a unique identifier (id). A query fired by one Quester can include any number of dependent values derived from properties identified in the dependencyValue object. The dependent Quester values are derived from (but not limited to) the attributes 132 shown in FIG. 4B.
  • [0043]
    The result object in FIG. 4A shows that results received from the content sources (or, if the exact same query was executed earlier by the same client or any other client, retrieved from the cache) also use a generic format. In accordance with an embodiment, each result comprises a string with an optional key that uniquely identifies the result in the underlying content source, optionally allowing the QuestObjects server to retrieve additional data from the content source when requested at a later time, and used to combine identical results that were received from multiple content queries executed in the content channel in the content-service tier of the system. The content source can also return optional metadata to the QuestObjects system, which is an array of zero or more strings.
  • [0044]
    In accordance with some embodiments, only information that is required by the various parts of the system needs to be communicated between these parts at any time. For example, if a QuestObjects client only needs to display the first 20 records from a result set (“results”), then only those 20 records will be transmitted to the QuestObjects client by the QuestObjects server, even if the QuestObjects server may have received many more records from the content source. If one Quester's query depends in part on the values held by attribute(s) of another Quester, then the values of that other Quester do not need to be communicated to the QuestObjects server by the QuestObjects client, because the server-side Quester manager maintains the values and data referenced by each Quester instance. A QuestObjects client can be considered a “view” on the information held in the server. Only input changes (such as characters typed, cursor selections, and list selections) need be communicated to the QuestObjects server, and only a limited subset of the results typically needs to be transmitted back to the QuestObjects client. The QuestObjects client can request additional “ranges” of results when and if they are needed.
  • [0045]
    In the content-service tier, each content channel defines the data that is queried and returned. In accordance with an embodiment each content channel does so using one or more querySelectors 134 (see FIG. 4C). Each query selector selects or skips a predefined content query by applying a selection pattern (typically in the form of a regular expression) to a specific Quester attribute for the same content channel or any other content channel. If the selectionPattern returns one or more values, then the corresponding content query is executed. The content query receives the corresponding values using a so-called groupToVariableMapping object that contains a key-value pair for each consecutive value derived from the query by the pattern.
  • [0046]
    The objects in FIG. 4 have been simplified for clarity. In accordance with some embodiments each object can have additional attributes that implement the functionality described herein. For example, each result object, or a complete result set, can carry with it an expiration time stamp, so that each part of the QuestObjects system can determine whether said result(s) are still valid, or whether they need to be re-fetched from the content source.
  • Request and Response Handling
  • [0047]
    Embodiments of the invention can provide asynchronous feedback based on server-side data and incremental client (typically, user) input. Information is exchanged between the QuestObjects client and the QuestObjects server. The following description describes the asynchronous nature of the consecutive messages (requests and responses) that are exchanged between the client and the server. In accordance with an embodiment individual messages can use XML (as further described in U.S. patent application Ser. No. 11/257,912). Those skilled in the art will understand that, through protocol adapters or other means, the format of the messages can be changed while remaining within the scope of the invention. Also, it will be evident that the embodiments described here are designed to offer a generic solution to make it possible to deploy multiple Questers with dependencies. In simpler embodiments of the invention, certain complexity can be omitted.
  • [0048]
    In accordance with an embodiment, certain communication messages can be omitted. For example, if only one client Quester uses only one server-side content channel, then no “registerQuester” and “questerRegistered” messages are needed as they could also be implied. In simplified implementations where no paging through results of a prior query or dependencies between multiple Questers are required, no session object (and related “startSession” and “sessionStarted” messages) is needed. Such limited protocol implementations, where the message formatting and transport are simplified while still communicating messages asynchronously conveying essentially the same meaning to achieve the same result to the world outside of the embodiment, still fall within the scope of the invention. Also, the messages described below have been simplified to better convey their meaning. For example, if a message is referred in the text below to as “query A”, then the message will likely hold a query id that is generated by the QuestObjects system and that represents the actual query object, the information of which is only transmitted to the QuestObjects server once. These implementation details do not change the meaning and essence of the information exchanged between the various parts of the system.
  • [0049]
    FIG. 5 shows a typical sequence of events as they flow through the QuestObjects system. In accordance with an embodiment, in its first request, the client Quester starts a session. It then registers one or more Questers, telling the server which content channels it would like to use. Each Quester may request dependencies on values corresponding to attributes of other Questers. Once this initialization phase is finished, the QuestObjects client can start performing queries and receive results. The consecutive queries usually happen upon user input, but an initial query based on a default value and/or qualifier can also be performed automatically at the end of the initialization phase, and clients can also be used to receive “pushed” updates using a request-response exchange at regular or irregular intervals from the QuestObjects server.
  • [0050]
    As shown in sequence diagram 140 of FIG. 5A, the information required by the QuestObjects server during the initialization phase can be combined into one message to the QuestObjects server by the client, upon receipt of which the QuestObjects server performs the corresponding actions and returns a single message. Note that any of the steps can fail, in which case the server returns an error message. In most situations, however, the initialization phase is distributed over time, wherein multiple consecutive messages are exchanged between client and server. This is shown 144 in FIGS. 5B and 148 in FIG. 5C. In the latter case, multiple client objects can be instantiated independently of each other. Thus, a Quester can request a dependency on another Quester that was instantiated before it. And a complex dynamic user interface may add and remove Questers and corresponding dependencies as the user navigates through an application, wherein all Questers that are instantiated and destroyed over time share the single session with the QuestObjects server.
  • [0051]
    Although a QuestObjects client can request dependencies from the QuestObjects server (as depicted in these figures using the requestDependency message) based on pre-configured dependent user interface elements, the QuestObjects server may also return a list of possible dependent content channel names to the QuestObjects client (with each questerRegistered message). In the latter case, a QuestObjects client can dynamically build its user interface by instantiating client objects based on the available dependencies. Some dependent content channels may have a “used as filter” flag, which signifies to the QuestObjects client that a dependency can be used as a filter in the client user interface (which is further described below with regard to FIG. 19B and FIG. 19C).
  • [0052]
    As shown in figures FIG. 5A and FIG. 5C, the QuestObjects server can query the underlying content source (through the content channel corresponding to the Quester that was registered, wherein the content channel can query one or more predefined content queries) upon receiving a query or rangeRequest message from the QuestObjects client. FIG. 5C shows that the content source is not re-accessed if the same query was performed already. Instead, the content is retrieved from the QuestObjects server cache.
  • [0053]
    FIG. 6 shows the events 150-160 that can occur in an embodiment that handles multiple subsequent client actions in a QuestObjects session, as well as the sequence of events that happens for multiple dependent Questers where the change event of an attribute in one Quester triggers a new query in one or more dependent Questers.
  • [0054]
    In FIG. 6A, a first query A is transmitted to the server, which in turn queries the underlying content source. Before information is returned from the content source, a new query B is transmitted from the client to the server, which also sends this query to the content source for retrieval of the appropriate data. At this point, the results for query A are no longer deemed of importance to the client Quester. In accordance with an embodiment, depending on the capabilities of the connected content source, the content query A can be interrupted or canceled. In typical embodiments, however, query A will still be allowed to finish on the content source, ensuring that the corresponding results will still appear in the QuestObjects cache, which increases the throughput for other QuestObjects clients that happen to perform the same query A at a later time, or for the same QuestObjects client if it re-requests the same query, as might be the case in a user interface after a user types the backspace key to return to the previous input string. In FIG. 6A, the result for query A is returned to the QuestObjects server by the content source, but no immediate results message is sent to the client Quester because it is no longer the information that the client is waiting for.
  • [0055]
    Once the results for query B are received from the content source, the client is informed that the results for query A were skipped and the results for query B are returned to the client. As is the case with most messages, depending on the particular embodiment, these messages can be combined into one communication package (shown in the circled area of FIG. 6A) or transmitted as separate communication packages as shown in FIG. 6B. The latter is typical of implementations that use TCP/IP, where each consecutive HTTP request from a QuestObjects client to QuestObjects server is expected to return a response.
  • [0056]
    The end of the first event sequence as shown in FIG. 6A depicts what happens if the same client session re-requests query A. At this point, the server already has the results for query A in its cache, so it can quickly return a results message to the client. If another QuestObjects client (for example, another user) requests the same query A before the corresponding results have expired, then the QuestObjects server can also return those results from its cache.
  • [0057]
    No system has unlimited capabilities. With this in mind, embodiments of the QuestObjects system are designed to provide the best possible throughput while minimizing the load on its various parts. In many cases, the real bottleneck in the system is not the system itself, but the performance and capabilities of the connected content source(s). Databases, search engines, web services, etc, typically can only handle a limited number of simultaneous queries. Each query can also take up to seconds before it returns results. So, if the QuestObjects system fired a content query for every single request received from every QuestObjects client, this would cause performance problems. An embodiment of the QuestObjects system addresses this by not firing content queries unless they are really needed, and by limiting and managing the number of simultaneous queries that can be fired against a specific content source. Another solution to slow-performing content sources can be provided by an embodiment in which data from the content source is pre-read and indexed by the QuestObjects system so that no further communication with the content source is needed (as further described below with regard to FIG. 26).
  • [0058]
    FIG. 6C shows an embodiment that addresses high-load situations, where the QuestObjects server receives a query A from a QuestObjects client (which is accepted by the content-service tier and fired against the content source). At the moment when a subsequent query B is received from the (same or different) client, however, the load on the content source is too high. Rather than firing query B against the content source, it is queued in the server-side Quester. At the moment where the content source is ready to accept a new query, the QuestObjects server determines whether query B is still the latest query. If it is no longer the latest query (as is depicted in FIG. 6C), query B is not fired against the content source. Instead, query C is fired, and eventually returns its results to the client. As a result, at the end of the sequence diagram in FIG. 6C, the QuestObjects server will have the results for query A and query C in its cache, but only the results for query C will have been transmitted to the QuestObjects client.
  • [0059]
    As illustrated in the example of FIG. 6B, the three or four resulting “sessionStarted”, “nop” and “results” messages shown in FIG. 6C can also be returned to the QuestObjects client as separate communication packages, depending on the low-level protocol implementation.
  • [0060]
    Similarly to the scenario in which a QuestObjects client does not always need to receive the entire result set from the QuestObjects server, the QuestObjects server does not always need the entire result set from a content source. Embodiments of the QuestObjects server can apply “paging” through results in a content source, using the native protocol of the content source. In some instances a content source can return its results in batches, perhaps because retrieving the entire result set from such a content source would otherwise take too long, leaving the QuestObjects client “in the cold”, even though part of the result set could have already been available.
  • [0061]
    FIG. 6D shows how this can be performed in accordance with an embodiment. Even though a QuestObjects client requests “all” results for a query A, the content source starts by returning the first 25 results, which are immediately communicated back to the QuestObjects client by the QuestObjects server. The results message holds a “more available” flag, which causes the QuestObjects client to send a new request (“query A [count]”) to the QuestObjects server.
  • [0062]
    Assuming that the QuestObjects client only needs batches of, say 25 results or less at any time, the QuestObjects server does not return the subsequent additional results as they come back from the content source. Instead, the results from the content source are cached in the server, and are subsequently transmitted to the QuestObjects client upon receiving a “rangeRequest A” message.
  • [0063]
    FIG. 6E shows the information that is exchanged between the QuestObjects server and the QuestObjects client in order to implement two dependent Questers. Each Quester registers itself for a content channel that has a predefined dependency on the content channel of the other Quester. Once this information is exchanged between the QuestObjects client and the QuestObjects server, the QuestObjects client can request new results for Quester 2 whenever the value of the dependent attribute in Quester 1 changes. In FIG. 6E, query 2 is transmitted as soon as a character is appended to the inputBuffer of Quester 1. The server can combine the values (in this case, the input buffers) of the two Questers to fire the underlying content queries in the content source(s). After the results for both Questers have been received, they are returned to the QuestObjects client.
  • [0064]
    As described in previous examples, dependent Questers can use paging through ranges, and incremental fetching of information. Low-level protocol embodiments can combine or separate messages into one or more communication packages, as long as the sequence of information exchanged remains. FIG. 7 illustrate this with multiple Quester dependencies, and shows how four subsequent messages can be exchanged to set up these dependencies. The startSession 170 and sessionStarted 172 messages of FIG. 7A and FIG. 7B are typically exchanged as soon as the QuestObjects client objects are instantiated. In embodiments working in a web browser, this can be right after the page loads, or even while the page is loading. To reduce the load on the QuestObjects server, this exchange can also be deferred until a user first accesses one of the user interface elements linked to one of the Quester.
  • [0065]
    It will be evident to those skilled in the art that sessions can be identified in various ways depending on the client and server embodiments. For example, in a web browser implementation, the session information can be transmitted as part of each subsequent request and response or as part of the URLs, where the session information is held in memory on the QuestObjects client. A QuestObjects client can also persist the session information by storing it in a “Cookie”, or by using a different persistence mechanism such as using a “Local Shared Object” in Adobe Flash. Also, as described previously, in simple implementations where no paging or dependencies are needed no session need be maintained either.
  • [0066]
    FIG. 7C and FIG. 7D show how the QuestObjects client and the QuestObjects server exchange information 174, 176 about multiple dependencies by exchanging a single request package and a single response package containing multiple registerQuester, questerRegistered, requestDependency, and dependencyGranted messages, as would be required in application embodiments like the design implementation described below in FIG. 18.
  • Configuration
  • [0067]
    In accordance with an embodiment, the QuestObjects server application can be configured using XML-formatted configuration files stored in a directory on the file system referred to as the “QuestObjects configuration folder”. FIG. 8 shows an example of the files 182 stored in such a configuration directory. The QuestObjects server automatically reconfigures itself after these files are modified. It is possible to maintain multiple instances of the QuestObjects server running on the same or on multiple machines by simply replicating the configuration directory, i.e. copying the files.
  • [0068]
    In accordance with an embodiment, the “cams” directory contains configurations that tell the QuestObjects server how to communicate with the various content sources it is to access. This directory contains a named file for each Content Access Module instance (CAM). The CAM configuration parameters depend on the type of content source. For example, a JDBC CAM for SQL databases contains the database user name and password used to log on to the database, the JDBC (Java Database Connectivity) driver name and connect string, the maximum number of simultaneous connections (the session pool), the maximum and minimum number of idle sessions, the maximum session pool waiting time, and an SQL query definition that is used to test the availability of the database. Other types of Content Access Modules require different configuration attributes depending on the type. For example, a file CAM may require the file format (such as Tab-delimited, or Microsoft Excel) and an LDAP CAM may require a list of server URLs for failover purposes. The purpose of a CAM is to abstract the various kinds of content sources available to the QuestObjects system. The rest of the QuestObjects system does not need to be aware of the differences between the various content source types. Optionally, each CAM instance also defines cache settings for the results to be cached in the content-service tier cache, and holds information on pre-fetching of popular queries from the content source.
  • [0069]
    In accordance with an embodiment, the “channels” directory contains a configuration file for each content channel that is defined in the system. The “content-service” file shown in FIG. 8A contains a configuration containing technical settings for the content-service tier of the QuestObjects server. This can include the logging level and information about statistics that are collected during the use of the QuestObjects system, which in turn can aid system administrators in fine-tuning and troubleshooting. The content-service tier statistics are used as a basis for license verification (e.g., a QuestObjects server may only be licensed only for X number of queries per time frame, or a content channel may be limited to a certain number of unique records), as a source for usage billing and advertising “hit counts”, to deduct the most popular queries, etc. Optionally, the content-service configuration file contains technical settings that configure the content-service tier in-memory cache.
  • [0070]
    The “content-queries” directory contains configuration files corresponding to all content queries defined in the QuestObjects server. This configuration is described in detail for FIG. 9B below.
  • [0071]
    In accordance with an embodiment, the “qo-server.license” file shown in FIG. 8A contains an encrypted license file that restricts the QuestObjects server software to only a limited set of features and/or uses. For example, the QuestObjects server might be configured to only allow specific (numbers of) CAMs, content channels, content query definitions, queries per day, restrict access to the QuestObjects server to non-SSL versus SSL, restrict access to the QuestObjects server from a limited number of Internet domains, etc. The license file can also include information identifying the licensee.
  • [0072]
    The example “server.xml” file shown in FIG. 8A contains technical settings for one QuestObjects server software instance. Multiple instances of a QuestObjects server can be run off the same configuration directory, wherein each instance has its own configuration file and can thus have its own system usage settings (e.g. relating to memory and thread use by that server instance on the computer hardware on which it runs). The server configuration file can also include settings relating to logging level, session management (such as the maximum number of simultaneous sessions), request management (such as the maximum number of requests that is handled at the same time and the size of the various request queues), caching settings (such as the maximum amount of memory to be used for the cache), and server tier statistics collection configuration.
  • [0073]
    When launched, the QuestObjects server software reads configuration information from the corresponding configuration directory shown in FIG. 8A. Changes to the QuestObjects server configuration can also be made while the QuestObjects server is running. One embodiment allows configuration changes using the JMX standard (Java Management Extensions), allowing configuration of the QuestObjects server software from third-party applications and management tools.
  • [0074]
    In accordance with some embodiments, a bundled QuestObjects server management application can be provided that allows dynamic (re-) configuration of the QuestObjects system using a web browser interface 184, as is shown in FIG. 8B. This browser-based configuration tool dynamically configures the QuestObjects server through JMX calls. Users can access the application from a web browser by typing the corresponding URL and authenticating. Users can also make configuration changes depending on their assigned role(s). For example, the role “qo-view” only allows users to view the configuration. Role “qo-admin” allows a system administrator to shut down and start up the QuestObjects server, manage other server processes, and manage technical settings such as memory and cache configuration. Role “qo-config” allows users to configure the QuestObjects server's logical configuration settings, such as the content channels, CAMs, and content queries.
  • [0075]
    The configuration application is accessed by clicking on “server Configuration” at the top of the screenshot in FIG. 8B. Any standards-compliant web browser can be used to configure the QuestObjects server. Users navigate through the various configuration options by clicking on menu items shown on the left of the screenshot. The various configuration attributes for each configuration are displayed on the right. Infrequently used and complex settings can be hidden in a separate “Expert Settings” window. The “server Info” link at the top of the screen opens a window that displays information about the QuestObjects server instance, including the version number of the software, the number of active sessions, or the number of queries handled.
  • [0076]
    In accordance with an embodiment, configuration changes can be made in a “sandbox”, which allows multiple attributes to be modified, added, removed, etc, without becoming active immediately and thus without interfering with the correct operation of the QuestObjects server. After making any configuration changes, an “Activate Changes . . . ” button allows the system administrator to activate the changes and a “Revert Changes . . . ” button undoes the latest changes that were made in the sandbox. Before the activation of changes happens, the QuestObjects server verifies their validity. A running QuestObjects server application will thus not be harmed by mistakes made in the configuration application, or in any other application that changes the configuration through JMX.
  • [0077]
    FIG. 9 shows an example 190 of how CAMs and content queries are configured in accordance with an embodiment. Each CAM instance is labeled a “content source” and is configured using configuration attributes that depend on the type of content source as described earlier. FIG. 9A shows the state of the “content sources” screen after configuring a content source using the SQL CAM, and one using the LDAP CAM (Lightweight Directory Access Protocol). After clicking on the “Connections” button, a new screen appears that allows the user to configure the CAM instance. New content sources are added by entering a unique Id, selecting the content source type, and clicking on the “plus symbol”. Content sources are removed by clicking on the “minus” symbol.
  • [0078]
    FIG. 9B shows an example screen 194 that appears after clicking on the “content queries” button for an SQL content source. In accordance with an embodiment each content query is identified by a unique Id, and contains query information in the content source's native query format: in this example, SQL. Query values (including any Quester and dependent Quester attribute values) are mapped to variable names in the content channel definition described for FIG. 10A below using the groupToVariable mapping described earlier. In content query definitions for the SQL CAM, the variable names are included as “bind variables” inside the SQL statements. The SQL dialect used depends on the underlying SQL database and is not dictated by the QuestObjects system.
  • [0079]
    Content query definitions for other types of content sources can use different yet similar ways to place content channel-defined variable values into the native content queries sent to the content source, based on the variable name defined by the groupToVariable mapping.
  • [0080]
    FIG. 10 shows a screenshot of the configuration screen 200 for a content channel that performs zero, one, or two content queries depending on two query selectors. FIG. 10B shows an example of the XML elements 204 needed for one query selector, as it would appear in a content channel configuration file. In the content channel configuration screen in FIG. 10A, the administrator can define the minimum length of the inputBuffer that is required before any content query is fired (and thus before any results are returned to the QuestObjects client). Also, the total number of results fetched by the content channel can be limited to a specified maximum. Associated content queries can use this limit to stop fetching results after the maximum has been retrieved from the content source.
  • [0081]
    In accordance with an embodiment, a content channel contains one or more query selectors, each one linked to one of the content queries defined earlier. A content channel does not need to know about the type of content source that is queried by the content query. The content channel can therefore combine results from a potentially unlimited number of content sources. Also, by specifying multiple query selectors that select a content query from one content source, multiple consecutive (or simultaneous, if supported by the content source type and the capabilities of the associated CAM) queries can be fired against the same content source upon a single QuestObjects client action or dependency trigger. One example use for this would be looking-up persons in a database by matching the inputBuffer with both the “lastName” and the “firstName” columns in a relational database.
  • [0082]
    In accordance with some embodiments, the QuestObjects server can perform all matching queries simultaneously (i.e., the various content queries are performed at the same time, wherein the content channel merges the results once all of the content queries have returned results). In accordance with other embodiments, content queries can be performed synchronously (i.e., subsequent content queries will only be performed after the prior content queries have finished). If a content channel is configured to only return a limited (maximum) number of results, then subsequent content queries do not necessarily have to be performed. If the QuestObjects server has already received a sufficient number of results from one or more prior queries, it can skip the subsequent content queries, even if they are matched by the query selector. This behavior can be configured in the content channel.
  • [0083]
    A system administrator can define each query selector by first selecting one of the predefined content queries (contentQueryId). Then, one or more selection criteria are specified, as further described below.
  • [0084]
    For each selection criterion, the Quester attribute and the content channel name identifying the Quester are selected. This identifies the value against which the selector applies its selectionPattern. In accordance with an embodiment, the selection pattern uses standard Regular Expression syntax, as is commonly supported in various programming languages, such as provided by the java.util.regex package in the Java language. The result of applying the pattern against the value either does not return a value (in which case the content query is skipped, i.e. not performed), or it returns one or more values. These returned values are mapped to the variable names that were optionally included in the selected content query.
  • [0085]
    In the example of FIG. 10A, the content query “companyByName” is performed if the inputBuffer from the content channel itself matches the “(\w+)” pattern. This pattern returns a single variable value if the inputBuffer contains one or more non-white-space characters. So, if the QuestObjects client transmits a query containing one or more characters, then the content query “companyByName” will be performed.
  • [0086]
    The second querySelector in the screenshot example performs the content query “companyBySymbol”, but only if the Quester's qualifier holds the value “INCLUDE_TICKER_IN_SEARCH”. This example is useful in applications where users can type either a company name or a ticker symbol into a QuestField to find matching results. The user can select whether companies should also be found by ticker symbol by selecting a checkbox that results in qualifier value “INCLUDE_TICKER_IN_SEARCH”.
  • [0087]
    In accordance with an embodiment, a pattern match (regular expression) may return a value, but not every group identified in the pattern must necessarily return a value. For this reason, each groupToVariableMapping allows the administrator to define an optional defaultValue that will be applied against the content query instead.
  • [0088]
    In accordance with some embodiments, metadata values associated with a result are returned in a fixed order, wherein the QuestObjects client identifies individual metadata values in a result as entries in an ordered array using an index ([0], [1], etc). In this instance, the QuestObjects server does not need to send any information about the metadata back to the client, apart from the ordered metadata values themselves. In other embodiments, each metadata value that is returned by a content channel is associated with an id that is sent to the client Quester in the questerRegistered message. Once the ids of the ordered metadata values are known by the client, subsequent results (answers to queries from that client from the server) do not need to include the metadata ids. The client derives individual metadata values from the order of the ids as it was defined and received in the questerRegistered message.
  • Result Types
  • [0089]
    In accordance with some embodiments, results that are returned to a QuestField client have a “result type” that determines how the result is handled in the client software. Results of type “normal” are typically displayed as part of an ordered list in the user interface, and will be associated with zero or more metadata values.
  • [0090]
    Other result types do not typically return content from the content engine, so their value and key have different meaning, and the metadata also has a special meaning (or is omitted). QuestField client embodiments that support the special result types usually have additional “result layouts” that are used to display the special types of results received from the server.
  • [0091]
    Results of type “query suggestion” are typically displayed at the top of the results list, wherein the value corresponds to the suggested query (and suggesting to the user an alternate query that might return better results). Some QuestField user interface embodiments show these query suggestions in a separate popup list or tooltip. When a user selects a “query suggestion” (e.g., by clicking on it with the mouse), a QuestField embodiment can copy the value into the input element and perform that query in order to retrieve and display the associated results.
  • [0092]
    Results of type “information” can be displayed at the end of a results list, to tell the user something about the results that were returned (e.g. “Only 25 results were returned although more information might exist. To receive more results, please rephrase your query.”).
  • [0093]
    Results of type “indexing” indicate that the server cannot yet return a full set of “normal” results because the underlying content source is being indexed. When the QuestObjects server returns a result of type “indexing”, corresponding metadata values can indicate the percentage of the content that has already been indexed, the amount of time indexing has already taken, and the estimated time remaining.
  • [0094]
    Results of type “error” indicate that an error has occurred during the execution of a query, or possibly one of multiple queries in a content channel. Different QuestField clients can handle these results differently: for example, they might display an error line as part of the result list, or group errors into a single error message displayed to the user.
  • [0095]
    In accordance with an embodiment that uses an XML-based communications protocol, the optional type element indicates the type of the result record. It is an integer value that defaults to 500 for “normal” result records (in that case, the type element is omitted in the XML). Negative numbers are reserved for future use. The type can be used for the following purposes:
  • [0096]
    In the QuestObjects server, results from content queries performed in a content channel are merged by type, wherein lower types always precede higher types. Lower result types therefore always appear higher in the list than higher result types. Results of content queries on the server are expected to be pre-sorted on their type number and their value. If a content query does not sort results, then this must be configured on the QuestObjects server. In that case, the results will be sorted by the QuestObjects server before they are merged with the results from other content queries in the content channel.
  • [0097]
    As described above, QuestField clients can handle, display, and format results differently depending on their type. In accordance with an embodiment, the following type ranges are reserved. Built-in plain list layouts for all negative type numbers are provided as part of the system. Any third-party, customer-specific and custom list layouts do not need to handle these result types, although they may optionally override individual ranges.
  • Negative Result Type Numbers:
  • [0098]
    −100 This number is reserved for errors that occur in queries performed by Content Access Modules (such as SQL and LDAP). When the content access module receives an error, a single result is returned to the client with type −100, with the following values:
  • [0099]
    key: The native error number as it was returned by the content source;
  • [0100]
    value: The native error text as it was returned by the content source;
  • [0101]
    metadata: null;
  • [0102]
    expires: Typically, the “expires” attribute for the range will contain the time that corresponds to the moment of the error: If a one-time error happens, the query will be re-executed immediately if the client requests this. If an error is tied in to the query (i.e., invalid query), then the expiration may be omitted or long so that the query will not be re-tried and the error will remain in the QuestObjects server cache. System-provided QuestField result list layouts will display an error symbol and a generic text “The query could not be executed by the content engine.” to the user (in the local QuestField-configuration language), and may optionally display the value and metadata in a technical “about box” for troubleshooting purposes. Depending on the type of the error, the Content Access Module may also send an error “−499” to the QuestFields client so it goes into offline mode (see chapter 3.5).
  • [0103]
    −90 This type number is reserved for situations in which the Content Access Module cannot reach the content source, i.e. the content source is unavailable.
  • [0104]
    key: An optional CAM-specific error number;
  • [0105]
    value: An empty string, or a string that is meaningful to end users. If empty, QuestField clients will display a generic text “The content source is currently unavailable.” to the user (in the local QuestField-configuration language). If the Content Access Module returns a value that is non-empty, e.g. “We are performing scheduled maintenance. The weather information server will be available again at 9 AM EST.”, then QuestFields append the value to the generic unavailability text;
  • [0106]
    metadata: null;
  • [0107]
    expires: This is the time at which the server is expected to be available again. QuestField clients should respect this time and wait for at least this long before retrying a connection to the server, unless some results in the result list were valid (it is possible that a content channel contains results from one content query but missed results from content queries corresponding to content sources that are unavailable). System-provided QuestField result list layouts will display the text. The QuestField client may optionally display the value and key in a technical “about box” for troubleshooting purposes. The QuestField client may also use the “expires” time to display a message “The content source is expected to be available again at xx:xx.”.
  • [0108]
    −89 through −80 This type number range is reserved for “QuestObjects server temporarily busy, try again later” situations.
  • [0109]
    −86 This type number is used for situations in which the QuestObjects server is too busy to handle a request.
  • [0110]
    key: An optional number that identifies the specific reason why the server is busy;
  • [0111]
    value: An optional technical description “why” the server is busy for troubleshooting purposes, e.g. “The request queue is full.”;
  • [0112]
    metadata: null;
  • [0113]
    expires: Typically, the “expires” attribute for the range will be the time that corresponds to the earliest moment at which the server suggests next doing a query. A QuestFields client should not re-query until this moment is reached. System-provided QuestField result list layouts will display a generic text “The QuestObjects Server is too busy to handle your query. Please try again later.” to the user (in the local QuestField-configuration language). The QuestField client may optionally display the value and key in a technical “about box” for troubleshooting purposes.
  • [0114]
    −83 This type number is used for situations in which the content engine is busy indexing information.
  • [0115]
    key: If available: The percentage complete (0-100, integer). Otherwise: null;
  • [0116]
    value: The meaningful name of the index being created. For example, “masterobjects.com” for a Content Access Module that is indexing documents or web pages in that domain. A CAM should always return something. If no meaningful name is available, then the QuestObjects server will return the CAM instance name;
  • [0117]
    metadata: null;
  • [0118]
    expires: Typically, the “expires” attribute for the range will be the time that corresponds to the current moment so that the next query shows the current percentage, if available. If indexing has an expected end time, then “expires” should be the expected end time.
  • [0119]
    System-provided QuestField result list layouts will display a generic text “Currently being indexed: value” to the user (in the local QuestField-configuration language, with the value appended), and may optionally display a progress bar if the key is non-null.
  • [0120]
    −29 through −20 This type number range is reserved for QuestObjects server-generated “query suggestions”. These results are typically stripped off the visual results list, and displayed in a separate user interface element such as plainly formatted suggestions at the top of the list or a “tooltip”. Selecting a value from this result in the client causes it to become a new query.
  • [0121]
    −26 The QuestObjects server suggests a different spelling for what the user has typed (e.g., for the previous client query value/input buffer because it is not recognized as valid). The value is typically shown as a plainly formatted result in the normal list element.
  • [0122]
    key: null;
  • [0123]
    value: The improved query value;
  • [0124]
    meta0: null;
  • [0125]
    expires: Typically, no expiration applies so the “expires” attribute is omitted.
  • [0126]
    −23 The QuestObjects server suggests a related query (that is, the query word might have been correct or valid, but there are related subjects that the user might be interested in). Depending on the QuestFields client, this value is not displayed amongst the regular results, but in a tooltip or in a separate pane or tab.
  • [0127]
    key: null;
  • [0128]
    value: The related query value;
  • [0129]
    meta0: null;
  • [0130]
    expires: Typically, no expiration applies so the “expires” attribute is omitted.
  • [0131]
    −9 through 0 This type number range is reserved for plainly-formatted texts that are to be displayed in the result list. QuestFields clients use plain formatting that displays the value only, regardless of the list layout that was chosen in the client.
  • [0132]
    key: null;
  • [0133]
    value: The value to be displayed;
  • [0134]
    metadata: null;
  • [0135]
    expires: A content source may optionally return an expiration time.
  • [0136]
    Positive Result Type Numbers
  • [0137]
    Positive type numbers typically correspond to valid results, wherein the type determines the sorting order: Lower numbers appear before higher numbers. QuestField clients will use the list layout and metadata formatting as defined by the “listLayout” attribute configured on the client.
  • [0138]
    Reserved for content results that are sorted before normal results.
  • [0139]
    Reserved for normal results.
  • [0140]
    101+ Reserved for results that are sorted after normal results.
  • Client Embodiments
  • [0141]
    In accordance with various embodiments, the client part of the QuestObjects system can be embedded into a variety of different web-based applications. The number of user interfaces that can take advantage of the invention is virtually unlimited. Every application that deals with incremental client-generated character input and returns matching content over a network (or locally, i.e. with client and server running on one device) can be implemented using the various embodiments of the present invention to increase performance and user-friendliness, and significantly decreasing application development cost.
  • [0142]
    Common embodiments of the invention wrap the client objects of the QuestObjects system into user elements that are referred to as “QuestFields”. Many types of QuestFields are envisioned, six basic types of which are described below. These QuestField types differ in complexity, but have in common that they can enhance any web browser or handheld wireless device application that is used to enter, find, retrieve and/or manipulate information stored in remote databases.
  • [0143]
    FIG. 11 shows a table 210 that compares the six basic QuestField types. From these basic types, complex QuestFields can be derived that combine the properties of multiple QuestField types.
  • AutoLookup QuestField
  • [0144]
    The AutoLookup is one of the simplest types of QuestField. Upon user input (or after a dependent QuestField is modified), the QuestField does a “direct lookup” in the underlying content source where the data returned has a one-to-one relationship with the user input.
  • [0145]
    Examples include a City QuestField that automatically displays the city for a specific Zip code, a Bank Number QuestField that verifies the validity of an account number, a Translation QuestField that automatically looks up the translation of text that the user has entered, a Stock Quote QuestField that returns a stock quote for a specific ticker symbol, or a Calculator QuestField that returns the result of a specific calculation performed on the user's input.
  • AutoComplete QuestField (AutoSuggest QuestField)
  • [0146]
    An AutoComplete QuestField assists the user during data entry by looking up multiple possible matches directly based on the user's character-by-character input. While the user types, the “best match” for the input is autocompleted into the input field. An optional popup list can display alternate choices or suggestions to the user. The user input typically has a one-to-many relationship with the data that is returned by the content source, and the number of records returned is usually known but can be limited by the server.
  • [0147]
    Examples include a PeopleFinder QuestField that looks up persons in a directory, a Product QuestField that helps the user find products, or an Account QuestField that helps the user in finding and entering customer account numbers.
  • [0148]
    AutoSuggest QuestFields are almost identical to AutoComplete QuestFields, except that they do not provide in-field auto-completion for the currently selected result record. In some QuestField embodiments, this is simply configured by setting an “autoComplete” attribute to “false”.
  • AutoSearch QuestField
  • [0149]
    An AutoSearch QuestField interprets the user input as a discrete search query that can be in any query format supported by the underlying search engine(s). The input is not usually autocompleted in the input field because of the nature of the input, although some AutoSearch QuestFields will suggest queries from a word-index or from a user query history list. Similar to the AutoComplete QuestField, search results are immediately displayed in a formatted popup list. The number of results returned from the server is typically unknown and limited by the search engine. Results in the AutoSearch QuestField popup list are usually filtered and ranked before they are displayed.
  • [0150]
    Examples include a Site Search QuestField that enables users to find pages on a website based on full text Boolean searches, or a Document Search QuestField that allows users to retrieve documents or files based on full text as well as other criteria. A publishing company, for example, can use AutoSearch QuestFields to allow users to quickly and efficiently search newspaper and magazine archives.
  • Relational QuestField
  • [0151]
    A Relational QuestField provides a complex user interface comprising multiple entry fields adapted for a specific use. A Relational QuestField simultaneously accesses multiple content channels and allows users to enter multiple values or click on results to “navigate” through relational content. Relational QuestFields provide a sophisticated user interface that typically feels like a “browser” or “navigator” because it can use multiple columns, tree lists, or even three-dimensional ways to display the results.
  • [0152]
    Examples include an Address QuestField that can be used to enter full addresses (street, city, state, zip, etc), a Thesaurus QuestField that allows users to navigate through taxonomy of terms, and a File Browser QuestField that behaves similar to, for example, Microsoft Windows Explorer or the Apple Mac OS Finder, yet operates on remote file structures. Relational QuestField embodiments are also ideally suited in multi-media library software and “jukebox software” such as, for example, Apple iTunes or Microsoft Media Player, where the content and library reside on a remote server. The same is true for music stores and other ecommerce sites in which Relational QuestFields provide a greatly improved way to navigate the remotes databases over the prior art.
  • FreeForm QuestField
  • [0153]
    A FreeForm QuestField is a text area that allows users to enter blocks of text of any size. Rather than treating the entire input as a query, a FreeForm QuestField intelligently interprets the user input as it is typed, providing the user with wide range of “on the fly” text editing enhancements.
  • [0154]
    Examples include a SpellCheck QuestField that checks and corrects the user's spelling or grammar based on remote dictionaries while the user is typing, or an AutoSave QuestField that automatically creates a server-side backup while the text is being entered.
  • Background QuestField
  • [0155]
    A Background QuestField does not have its own user interface. Instead, it is a QuestField that can be invoked to run in the background of an application, invisibly accessing a QuestObjects service. For example, a Background QuestField could be a real-time stock price lookup function available to stored procedures in a relational database.
  • [0156]
    FIG. 12 shows two examples of Internet applications based on HTML pages containing an AutoComplete QuestField. In particular, FIG. 12A shows a web page 220 loaded into a Microsoft Internet Explorer browser application running on a Windows XP operating system, wherein the user has placed the cursor into a QuestField that is used for searching second-hand cars. As the user starts typing, matching information appears nearly instantaneously, as shown in FIG. 13D.
  • [0157]
    FIG. 12B shows a similar application 224 optimized for the small screen format of a mobile phone or portable device (for example, an Apple iPhone or another type of phone device), as it looks after the user enters “Ferrari 3” using the phone's on-screen keyboard and then dismissing the keyboard. During keyboard entry, the vertical area occupied by the QuestField's result list is minimized. The bottom of the result list in an AutoComplete QuestField displays the number of available records, even while the user is typing. When the phone is rotated into “landscape view”, using JavaScript functions and the “onresize” handler, the QuestField can adopt itself to the new screen width and screen height.
  • [0158]
    QuestFields are especially suited to enhance finding information on small wireless devices such as cell phones and PDAs. The QuestObjects protocol (QOP) minimizes network traffic and maximizes the speed at which users receive feedback upon their input. Therefore, perceived performance is excellent even when using slow network connections such as GPRS.
  • [0159]
    FIG. 13 shows various states 230 of the basic input element that plays a part in many QuestObjects client (QuestField) embodiments. FIG. 13A shows the input element before the user has typed any characters. For branding reasons, and to remind users that the input field is dynamic rather than static as was the case in the prior art, some QuestField embodiments can display a watermark, such as a QuestObjects “Q” symbol or trademark, or other symbol, inside of the input area.
  • [0160]
    At the stage represented in FIG. 13A, in accordance with most embodiments, the QuestFields will not have yet connected to the QuestObjects server (i.e., it will not yet have established a session with the server). However, if the QuestField has an initial (typically, pre-configured by the application or website designer) query (such as an inputBuffer value, a qualifier value, or a value held in a dependent Quester), then the QuestField can automatically connect to the server as shown in FIG. 13B. If the QuestField does not have an initial value, then it can connect to the QuestObjects server upon the first user action (such as typing a character). The first character typed does not necessarily fire a query (i.e., the client Quester does not necessarily send a query message to the server after typing a single character). The number of characters that must be typed before a query is submitted is implementation-configurable. This is to further minimize the load on the server, and to avoid performing unnecessary or less useful queries, as often is the case if the user only types a single character.
  • [0161]
    During the connection phase, a session is established. This can be indicated by an animated communication symbol inside of the QuestField (or, in some embodiments, elsewhere on the screen, such as in the header, margin, or footer of the window containing the QuestField). Of course, this symbol generally does not appear if a different QuestField has already established a session with the server through the central client Controller.
  • [0162]
    FIG. 13C shows the state of an AutoComplete QuestField embodiment configured to access a “Second Hand Cars” content channel after a user has typed three characters (“Fer”). A rotating user interface element indicates that a query is being performed (in this case, it has the shape of two arrow symbols that rotate in a circle). For a brief time after the user types the characters, this user element may appear static (i.e., non-rotating). This is because a QuestField reduces network traffic and server load by accumulating user input for a configurable amount of time. To improve the user feedback even further, the (initially static) user interface element can appear subtly by zooming into view, or by fading into view (say, from 100% transparent to opaque).
  • [0163]
    FIG. 13D shows the same QuestField after it has received results from the QuestObjects server. The corresponding drop-down list can be configured to open (appear) automatically after results are found. In some implementations, this behavior can also be switched off by the user.
  • [0164]
    A QuestField can be configured to provide in-field “auto-completion”, using various text colors to indicate whether a single unique record was found (in which case a checkmark may appear after the input, as shown in FIG. 18A) or whether more records are available (as is the case in FIG. 13D). If the user closes the drop-down list, or in other situations, configurations, or applications where no results list is displayed, arrows inside of the QuestField can indicate whether previous and/or next results are available, allowing the user to select the previous and next results using the Up and Down arrow keys on the keyboard, as shown in FIG. 13E.
  • [0165]
    As a user types new text, it typically appears in a lighter-than-usual color (e.g., gray instead of black) until at least one matching result is received from the server. This ensures that the user can always recognize whether the current value in the input field was accepted or not.
  • [0166]
    When this QuestField embodiment encounters a non-recoverable error, it displays a “red triangle” as shown in FIG. 13F. The QuestField remains disabled until the web page is reloaded. Non-recoverable errors usually indicate a faulty configuration of the QuestField in the web page, such as a wrong server URL or a non-existent QuestObjects content channel id. Clicking on the triangle symbol reveals an “information pane” in the user interface that displays information about the error, such as the error number and a descriptive text.
  • [0167]
    When the QuestField embodiment encounters a recoverable error, it displays a Pause symbol at the right of the entry field as shown in FIG. 13G. The field was placed in off-line mode, so that it temporarily behaves like it is disabled. To reduce server load in error situations, no more communication with the QuestObjects server will take place until the web page is reloaded, or until the user clicks on the Pause symbol to reconnect. During off-line mode, the information pane shows an error message.
  • [0168]
    As shown in FIG. 13H, in accordance with an embodiment the Pause symbol changes to a Play symbol when the user holds the mouse over it, allowing the user to retry the action that just went wrong. If the error occurs again, the QuestField will re-enter off-line mode and display the Pause symbol again. In some embodiments, the pause/play metaphor can be substituted by a simple yellow “warning triangle”, with a warning text and a button that the user can click to try and re-establish a session.
  • [0169]
    A content channel can postpone a query (coalesce the input) until at least a certain number of characters is entered into the client Quester. Some QuestField embodiments may indicate this to the user by displaying an underline symbol that stretches in front of the characters typed, as shown in FIG. 13I. The length of this underline is calculated to match the number of missing characters, which is configurable by the application designer.
  • [0170]
    If a QuestField query does not return any matching results, then in some QuestField embodiments the system draws a “red wiggly underline” under the input, indicating that the input is invalid (or perhaps, in some applications, misspelled). This is shown in FIG. 13J. This provides an indication to the user that he or she can backspace or clear the field to try a different query, and saves the user aggravation and time compared to techniques that otherwise rely on the request-response loop to display a page that said “No results found, please try again”.
  • [0171]
    Certain QuestField embodiments may display an “erase” symbol after the input element contains data (in this case, typed or pasted text). Users can click this symbol (shown in FIG. 13D, FIG. 13E, FIG. 131, and FIG. 13J) to erase the entry field and to place the cursor at the beginning so that a new character can be typed.
  • [0172]
    Some QuestField embodiments allow the user to de-activate the dynamic lookup and autocomplete behavior. After a user disables the QuestField, a grayed-out “power symbol” is displayed in place of the various other state elements. When a QuestField is disabled, it will no longer communicate with the QuestObjects server. A disabled QuestField effectively functions like a regular entry field. To re-enable the field, the user can click the Power symbol or check the appropriate checkbox in the information pane.
  • [0173]
    All of the basic QuestField states and behaviors described above are also used in more complex QuestObjects client embodiments, examples of which are described below.
  • [0174]
    FIG. 14 shows two QuestFields that implement Quester dependencies. The QuestField 234 in FIG. 14A comprises two AutoLookup QuestFields, one of which is used to check the accuracy of an ISBN number typed by a user. The second QuestField, upon reception of the appropriate key by the first QuestField, will immediately display an image of the corresponding book after its content channel returns the matching image URL for that key.
  • [0175]
    FIG. 14B shows a Relational QuestField embodiment 238 derived from two AutoSuggest QuestFields that both depend on the same input buffer. As the user types an entry into the input element at the top of this “ProductFinder” QuestField, the top QuestField displays matching products (“270 Producten”, Dutch for “270 Products”) and the bottom QuestField displays matching special offers (“3 Aanbiedingen”, Dutch for “3 Special Offers”).
  • [0176]
    As described previously, a client Quester does not always receive an entire result set from the QuestObjects server. Additionally, the QuestObjects server does not necessarily receive the entire available result set from the content source(s). In such cases, the client Quester may receive partial results as they “trickle in” from the server. This is typically envisioned to the user by rotating user interface elements next to (or below) the corresponding result lists 240, as is shown in FIG. 14C. Rather than saying “270 Producten” and “3 Aanbiedingen”, this screenshot shows that the QuestField can omit the number of results (which in this case is still unavailable for both Questers) and display a set of rotating arrows next to each content channel name.
  • [0177]
    QuestField result lists can be customized to virtually any “look and feel”, using various techniques including CSS, Adobe Flash, or any other technology available on the QuestObjects client embodiment. Instead of “special offers”, a dependent QuestField can just as easily display matching advertisements implemented using any means available to the browser. QuestFields are therefore ideally suited for advertising-driven information publishing, where they provide a much better means for user-targeted advertising than the prior art that relied on advertising updates only after the entire page was reloaded.
  • [0178]
    A QuestField can also display advertising or sponsoring information in its margins or footer, as is the case in FIG. 14B and FIG. 14C, where the QuestObjects logo and a “powered by QuestObjects” text can be received from the server, and could be the result of a content channel that returns multiple items or texts to be displayed at the footer, in some envisioned embodiments as a “slide show” or as a “scrolling ticker tape”, as “vertically scrolling credits”, or a combination of these. In the example shown, the text returned (“mogelijk gemaakt door”) is in the Dutch language. A content channel is capable of returning the appropriate data by using the language identifier as a qualifier in the query.
  • [0179]
    FIG. 15 shows various examples of visual QuestField styling and custom result list layouts. FIG. 15A shows an AutoComplete QuestField 244 that is used in an embodiment referred to as “PeopleFinder”. The results list displays names in bold, phone numbers in regular font, and an email symbol allowing users to quickly send an email to the corresponding person.
  • [0180]
    FIG. 15B shows the same QuestField 246 using a different CSS style sheet. This style sheet (reconfigured by changing a “skinName” property) uses non-rounded borders, orange color, and different-looking drop-down and submits button symbols, and different colors for typed and auto-completed text. Different QuestField embodiments can also auto-detect the local operating system and adjust their look and feel so they match the native look of each user's system (e.g., using “Aqua” widgets on an Apple Mac OS, or using “Aero” widgets on a Microsoft Windows Vista OS).
  • [0181]
    FIG. 15C shows an AutoComplete QuestField 248 that uses another CSS style sheet (this time, using a dark gray color for the drop-down button) and a customized list layout spanning multiple lines per result, a “lock symbol” that appears for each result depending on a metadata value received from the QuestObjects server, and an additional HTML-formatted footer below the QuestField result list.
  • [0182]
    FIG. 15D shows an AutoComplete QuestField 250 with a list layout optimized for finding websites from a server-stored index of website titles.
  • [0183]
    FIG. 16 shows different embodiments of the AutoComplete QuestFields that are combined in the client application to provide dual lookup capabilities to the user. In particular,
  • [0184]
    FIG. 16A shows two QuestFields 252 with dependencies to allow users to type either (part of) a last name, first name, or both to find persons in a directory. As last name information is entered into one QuestField, the other QuestField automatically displays a list of all matching first names that exist in the directory. FIG. 16B shows a similar example 264 of two dependent AutoComplete QuestFields, in this case using “City, State” and “Zip Code” to allow users to quickly enter or find the proper matching data records. FIG. 16C shows a similar example 266 of two dependent AutoComplete QuestFields, in this case using “Artist” and “CD Title” to allow users to quickly enter or find the proper matching data records.
  • [0185]
    FIG. 17 shows an embodiment 280 in which various states of a complex Relational QuestField user interface design that is used to navigate a large thesaurus database. After the user types “No” into the input field and clicking on the triangle as shown in FIG. 17A, a two-paned user interface 284 appears (FIG. 17B). The left column shows lookup results similar to the AutoComplete and AutoSuggest examples shown earlier. The right column shows four dependent result lists corresponding to four Questers that retrieve dependent data on the currently selected result on the left. With “North Carolina” selected, the “UF” list displays all “used for” terms from the thesaurus. The “BT” list displays all “broader terms” from the thesaurus. The “NT” list displays all “narrower terms” from the thesaurus. And the “RT” list displays all “related terms” from the thesaurus.
  • [0186]
    FIG. 17C shows a screen shot 288 of the state of the user interface after the user “drags” the result “United States of America” from the right-side list into the list on the left. Once the entry is dropped in place (as shown 292 in FIG. 17D), all Questers that depend on the “currently selected term” immediately retrieve new matching values from the QuestObjects server. It will be evident to those skilled in the art that users are often likely to click on previously visited records, such as re-clicking on term “North Carolina” in FIG. 17B. The embodiments described herein make this process efficient and quick, even if the content source (in this case, thesaurus database) contains a huge number of records, if the user is accessing the QuestObjects server remotely, when the speed of the network is slow, and when the thesaurus is being accessed by many simultaneous users.
  • [0187]
    FIG. 17E shows that the user can drag 296 the term “Alaska” to the input field, replacing the previous value of the input buffer, “North Carolina”. Immediately, the dependent QuestFields look up the corresponding matches. In this example, while the user selects the “Sounds” tab in the user interface 298 (FIG. 17F), another dependent Quester will perform a lookup for all states that “sound like” the currently selected term.
  • [0188]
    FIG. 18 shows three screenshots 302 of an application that combines four dependent QuestFields to find car parts in an SQL database, using four indexed database columns “Architecture”, “VPPS”, “FNA”, and “Part”.
  • [0189]
    As shown in FIG. 18A, upon entering “OPEL” into the Architecture QuestField, it is automatically completed (the check mark signifies that one unique match exists). The other three QuestFields have automatically performed their dependent queries and have come up with result lists, as indicated by the green “down arrow” symbols and the auto-completed “first available” matches. FIG. 18B shows how the user can select one of the resulting FNA codes by simply selecting it from the corresponding QuestField's results list. Then, after only typing three digits of the part number in FIG. 18C, only one unique VPPS code remains, and the number of available parts, out of a potential total database size of millions, is easily found and entered. Multi dependent QuestField applications such as the embodiment shown here can replace complex multi-HTML page applications, and offer a paradigm shift for the entry, search, and retrieval of remote data.
  • [0190]
    Although in this user interface design the dependent QuestFields are arranged vertically, those skilled in the art will understand that different embodiments may position them in any order, or even place them inside of other complex user interface elements such as tabbed pages, complex grids, etc.
  • [0191]
    FIG. 19 shows three user interface designs 310 that further illustrate the power of dependent QuestFields. In accordance with an embodiment, the four dependent Questers and the content channels used by the four AutoComplete QuestFields used in FIG. 18 can be supplemented by a fifth dependent Quester accessing a content channel “Car Brand & Type”, a sixth Quester used to filter on “Price Range”, and a seventh Quester to filter on “Build Year”. A single complex Relational QuestField is created that offers an easy-to-use, multi-column interactive search and retrieval interface.
  • [0192]
    FIG. 19A shows a Relational QuestField that uses multiple columns, each column comprising an input field and a result list. The first three columns are currently visible, but additional columns exist to the right, as is indicated by the scroll bar element at the bottom of the QuestField, and the “Car Brand & Type” and “Part Name & Number” links. Users can use the scroll bar to reveal the columns to the right, or they can simply click on the links at the bottom to jump to a specific column. Although in this user interface design these “column links” are displayed inside of the scrollbar at the bottom, those skilled in the art will understand that different embodiments may place the scrollbar at the top and may display the links as more traditional “bread crumbs” towards the top of the screen.
  • [0193]
    FIG. 19B shows the state of the user interface after the user has clicked on “Car Brand & Type” in FIG. 19A, or after scrolling to the right. A new column “Car Brand & Type” appeared, and the left “Architecture” column has disappeared from view. In its place, a new “Architecture” link is displayed on the left side of the scroll bar. Clicking on this link will scroll the QuestField back to the left. Note that, in this example, the user has already typed “OPEL”, causing the Architecture content channel to perform a query that returned one record, “OPEL Z-CAR EPSILON . . . ”. This has already caused all of the dependent Quester content channels to re-query their content channel, filtering the number of results displayed in the result lists on the right.
  • [0194]
    Since in the above example the user has created a query in the Architecture Quester, its “erase button symbol” has appeared in the corresponding input field in FIG. 19A. Because the input field is scrolled out of view in FIG. 19B and in FIG. 19C, the erase button symbol is displayed next to the “Architecture” column link in the scrollbar at the bottom.
  • [0195]
    In the top right hand corner of FIG. 19B, note the “Filter” checkbox that has appeared for the “Car Brand & Type” Quester. This shows that any column can have one or more additional “filter channels” that a user can activate to further narrow down the search. In FIG. 19C, the QuestField is scrolled all the way to the right, and the “Filter” checkbox for the “Car Brand & Type” column is checked. These causes the additional QuestFields “Price range” and “Build year” to appear. Note that such dependent user interface elements may be hard-coded in the QuestField. However, the QuestField can also determine dynamically which additional “Filter” QuestFields are to be displayed. To this end, the QuestObjects server returns a list of available “Filter” content channels to the client Quester as part of its questerRegistered message. In one embodiment, the content channel definition on the QuestObjects server has an additional Boolean flag in the querySelector that indicates whether the dependent query definition is to be used as a filter. By clicking on the “erase button symbol” that appears next to the filter Questers, all filters can be reset to their default state. Also, by removing the checkmark from the “Filter” checkbox, the filter Questers are cleared and hidden from view.
  • [0196]
    An advantage of the dependent QuestField and Relational QuestField embodiments described above, is that users can start their search or “find process” by entering search values and making selections in any of the dependent Questers, and in any order. For example, if a user already knows (part of) a product or component number, then he or she can enter it immediately. This provides an advantage over prior art systems that typically offered a “top-down” approach to finding information. In many contemporary ecommerce sites, it is still very difficult to find a specific product, unless the user knows the exact name or the exact (and full!) corresponding part or product number. With Relational QuestFields, this is no longer necessary.
  • [0197]
    FIG. 20 and FIG. 21 show screen shots 322-334 of two AutoSearch QuestField embodiments. AutoSearch QuestFields typically have an additional user interface element that allows users to make search selections and to view “recent queries”. Contrary to the AutoComplete QuestFields and AutoSuggest QuestFields described in the previous examples, the results received from the content sources (typically, from third-party or open-source search engines) are generally not alphabetically sorted. Instead, the content source typically ranks results according to relevance. In accordance with an embodiment the QuestObjects content channel can optionally merge results received from multiple content queries. Rather than doing this by alphabet, this can be performed using the rank held in a specified metadata entry.
  • [0198]
    FIG. 20A, FIG. 20B, and FIG. 21A show that users can click the QuestObjects symbol in an AutoSearch QuestField to reveal a popup menu that shows recent searches (which can be re-performed by simply clicking on them), a “Clear Recent Searches” option, and optional qualifiers that enable the user to determine the content queries that are performed by the associated content channel. The “About this QuestField” menu option opens the information pane, just like the “i” tab button does at the bottom of most QuestField result list embodiments, and just like what happens when the user clicks on the regular (i.e., non popup menu) “Q” watermark that appears when a QuestField loads (as shown in FIG. 13A).
  • [0199]
    FIG. 20B and FIG. 21B show the state of the AutoSearch QuestField after the user has typed a search query. As with other QuestField types, a rotating symbol indicates that the search is being performed. Note that most search engines allow users to include search operators in their query, such as Boolean operators including “and” or “or”, as is shown in FIG. 20B. The QuestObjects system simply passes the input string to the content source (in this case, search engine), but the QuestObjects client may perform highlighting and special handling of reserved words used as search operators.
  • [0200]
    The input field of an AutoSearch QuestField does not typically perform in-field auto-completion on the search results. However, the input field can optionally provide auto-completion or suggestions for the last typed word. This requires the use of a second content channel that is defined to query the full-text index that is also used by the search engine of the content source. Although not shown in FIG. 20 and FIG. 21, the corresponding auto-complete suggestions are displayed similar to URL-suggestions given in web browsers and similar to the way in which a FreeForm QuestField embodiment pops up spelling suggestions as shown in FIG. 22B. The content channel used for such “search suggestions” typically filter “stop words” and search operators (such as “and” and “or”) before returning results, so that an AutoSearch QuestField only provides suggestions for the actual search terms typed by the user, not for the operators such as “and” and “or”.
  • [0201]
    As is shown in FIG. 20C, a QuestField result list may display images that correspond to the search results. The QuestObjects server typically returns URLs to these images to the QuestField as metadata strings in the result set. These URLs can be absolute URIs to the images or other related content, or can also be file names or paths to images relative to a base URL known to the QuestField client software. By including only the path or file names, the size of communication packages received from the server is limited, and the QuestObjects server cache will occupy less memory. A content source may also provide limited HTML formatting, “escaping”, or “tagging” of search words inside of each result text. A customized result list layout can apply formatting to highlight those words to the user. In FIG. 20C and in FIG. 21C, occurrences of the search term(s) in each result are displayed using bold font formatting.
  • [0202]
    FIG. 22 shows an embodiment 340 in which a FreeForm QuestField is used to provide on-the-fly spell checking and lookups based on a content source containing a server-based dictionary. FIG. 22A shows a text field containing multiple lines of text ending in the misspelled word “servre”. Upon a right click, the QuestField provides spelling suggestion based on the result of a content query that is performed by the “dictionary” content channel associated with the QuestField. As shown in FIG. 22A, the QuestField can indicate that the query is being performed using a rotating symbol in the popup menu that appears in the user interface. In low load situations, the QuestField can display the suggestions immediately since they will have already been received from the QuestObjects server before the user has had a chance to right-click on the misspelled word.
  • [0203]
    FIG. 22B shows how the spelling suggestions are presented to the user. It will be evident to those skilled in the art that such a popup menu or context menu may contain additional menu lines revealing additional application and/or QuestField options that are relevant for the current application context.
  • [0204]
    FIG. 22C and FIG. 22D illustrate how the system responds when the user right-clicks on a word that is spelled correctly. In this instance, the FreeForm QuestField looks up the word in the server-side dictionary, and quickly displays the corresponding dictionary information while the user is either pressing the mouse button or after a single right-click.
  • [0205]
    FIG. 22E shows one way in which the FreeForm QuestField can be configured. In accordance with some embodiments, a “QuestObjects Q symbol” button is included in the margin or footer of the QuestField or in the window containing the QuestField. The user can click this “button” to reveal options relating to the QuestField. In this example, the user can enable and disable three different options. Those skilled in the art will recognize that FreeForm QuestFields are capable of additional functions that enhance entry of free-form text. For example, it is possible to “push” context-sensitive pop-ups to the QuestField that are displayed automatically as the user is entering information. These pop-ups might provide suggestions, show advertising, provide links to related information, etc.
  • [0206]
    Some devices, such as the Sony Playstation 3 (PS3), or early versions of the Apple iPhone, have limited keyboard input methods that do not allow input fields on web pages to intercept or “catch” individual keystrokes entered by the user. These devices do not call the “on KeyDown” or “on KeyUp” event handlers behind input fields, because keyboard entry is instead taken over by a separate “virtual keyboard” that appears on-screen, allows a user to enter a string, and then only calls the underlying web page and input field after the entire string was edited. On these types of devices, a QuestField can intercept the click (or finger press) on the input field by overlaying a transparent “button”. Instead of the regular built-in keyboard or virtual keyboard of these devices, the QuestField can open its own virtual keyboard in a separate HTML layer or in a separate HTML window. This virtual keyboard has a button corresponding to every key, as well as function keys such as backspace and a “dismiss” button that hides the virtual keyboard layer or closes the keyboard window. While the user clicks each button on the QuestField's virtual keyboard to enter incremental characters, the “click” event on each virtual key is handled so that the corresponding character is appended to or inserted into the HTML input field. From the perspective of the user, the QuestField's “popup keyboard” replaces the built-in key input mechanism, allowing the QuestField to respond to individual keys (incremental key input) rather than only responding after the user has finished entering the string. So even in those devices that do not typically allow trapping keystrokes, users can input strings using consecutive character input or using consecutive clicks (or finger presses or stylus taps), while the QuestField performs incremental queries, asynchronously receives results from the server, and displays matching results to the user as the string is being edited by the user using the virtual keyboard.
  • Character Input Throttling
  • [0207]
    In accordance with an embodiment, the system can be configured to more readily manage requests, retrieve and optionally cache content, and send back to the client object only the information that is needed by the user at any time. An efficient network protocol between the client and the server can be used to exchange the information in an efficient manner, to maximize responsiveness of the system to the user, while minimizing the load on content sources and to minimize network traffic. In addition to these critical parts of the system, additional functions can be implemented in the client software, as to minimize the number of requests going from the client to the server object.
  • [0208]
    To improve overall performance and scalability, in accordance with an embodiment QuestFields limit the number of queries sent to the QuestObjects server for an individual user. As described previously with regard to FIG. 13C, the client software accumulates user input for a certain amount of time. This is managed in two client-side “tiers”: the Questlets (the user interface elements inside of the QuestField), and the Questers (the non-visual objects that communicate with the server).
  • [0209]
    In accordance with an embodiment, data “accumulation” can be controlled by the Quester objects. Questers determine the delay that occurs after receiving a query request and before that query is sent to the server via the communications controller. Whenever a new query request (typically, a character or word typed or pasted into a QuestField by the user) is received by a Quester, any prior queries still being delayed are superseded in favor of the new query. In this manner a Quester can accumulate multiple query requests, triggered by user input, before the final query actually goes to the server. The size of this delay determines query frequency in response to user events, and therefore affects both responsiveness of the user interface and traffic to the server. Depending on the server response speed and the network latency, a Quester can send a new query before receiving a result from a previous one. Questers determine high-load (slow server) situations based on the size of the pending query “queue”.
  • [0210]
    Queries triggered by a dependency from another Questlet are not subject to the same minimum delay. In accordance with an embodiment a dependency query delay is determined by the Quester that triggers it; all dependent Questers send their queries immediately after this delay. If the triggering Quester receives a new query request, then the new query request immediately supersedes any delayed queries being accumulated in dependent Questers.
  • [0211]
    Longer delays can also be suggested by a Questlet. For some user interface events, a Questlet can suggest a longer-than usual delay (but never a shorter delay than the one calculated by the Quester). A Questlet will typically do this in two situations: (1) when the user hits “backspace”; and (2) when the user types other commands that suggest that the user is still editing the field, such as “cut and paste” and “delete”. This indicates that further editing of the query string is likely, so the accumulation period is extended accordingly.
  • [0212]
    FIG. 23 shows the various variables 344 involved in calculation of the accumulation delay in accordance with an embodiment. The accumulation delay is calculated by Questers in the following manner. Normally, a default delay (defaultAccumulation) is used, which is determined by average typing speed on the target device (averageTypingSpeed). This delay is shortened when the length of the query string (queryLength) is longer. However, there is always a minimum delay based on the average network latency (averageLatency), with the exception of dependency queries mentioned above.
  • [0213]
    FIG. 23B shows a flowchart 348 illustrating the process performed by the system to determine the accumulation. If and when there are queries in the queue already, the delay is determined by the number of pending queries (pendingQueryCount) and an estimated query time (queryTime), which is approximately the time it takes between a query request and the receipt of results. This query time can be initially determined from the average network latency (averageLatency) and re-calculated every time results are received. It has an assumed minimum (minimumQueueTime), and can be determined from the time between sending the query and receiving the corresponding results (calculatedTimeTakenByQuery). In addition, the query time cannot decrease from its previous value by more than the default accumulation time (defaultAccumulation). This limitation is imposed to limit the impact of queries that are relatively fast due to cached results.
  • [0214]
    If the result for the last remaining pending query is received, then any accumulated query can be sent immediately, rather than waiting for the remainder of the delay. If a Questlet suggests a slow query delay (slowQueryDelay), then that will be used assuming it is longer than the minimum.
  • RESTful Protocol Implementations
  • [0215]
    In accordance with some embodiments, the communications protocol does not need to transfer user session information to the server with each request coming from the client. Instead of the client first starting a session on the server, and the server keeping that session available to the same client, the server does not maintain a session for each client. This “session-less” relationship between the client and the server is sometimes referred to as a “RESTful” (“Representational state transfer”) relationship. Representational state transfer is a style of software architecture that can be used for distributed hypermedia systems such as the World Wide Web, and the Hypertext Transfer Protocol (HTTP) specification.
  • [0216]
    In accordance with RESTful embodiments, the client object does not pre-register information about how the server object should respond to subsequent requests. Instead, the client system packages each request into a full communication packet that contains all of the necessary information for the server object to do its work. The server object does not remember information it learned in prior communication from the same client, and does not combine the input requests that it received from a client in a prior communication exchanges with the incremental input it receives from the same client object in subsequent communication. In RESTful embodiments, individual requests sent from the client to the server are typically more complex (especially in multi-Quester situations with dependencies). Although one advantage of RESTful embodiments lies in the fact that subsequent requests from the same client may be communicated to (and handled by) different server instances running on different computers (thus increasing scalability), scalability can be negatively affected because the subsequent requests from the same client can likely be handled by the server from its cached data, which will not necessarily be present on other servers. As such, the performance benefits of using a RESTful protocol depend on the use case and on the content.
  • [0217]
    Although in RESTful implementations there is no such thing as a “session” being exchanged between the client system and the server system these implementations can still recognize a “user session”, the information of which is then maintained fully on the client system, wherein each request from the client object communicated to the server object represents the full information needed for the server object to respond.
  • Full-Page QuestFields
  • [0218]
    In accordance with some embodiments, the system can use third-party technologies to implement the client object and the communications controller object on the client computer to communicate over the network with the server computer, in addition to different low-level communications protocol implementations. In embodiments that package the information requests and responses in XML (Extensible Markup Language) and transmit them over HTTP (HyperText Transfer Protocol), the client object can be implemented using technologies that provide ready-made “XML over HTTP” functionality to the client object on the client computer.
  • [0219]
    In embodiments that use a browser-based client, the client object can be implemented, for example, in the ActionScript language, which is then compiled to run in an Adobe Flash Player software installed in the user's browser. The Adobe Flash Player provides an XML object that can be called by the client object to send and receive XML-formatted information packets to implement a communications protocol. One advantage of using Adobe Flash over other client technologies is that the Adobe Flash Player software allows the client object to communicate with server objects that are hosted in a different Internet domain (or sub domain) from the web page that contains the client software embedding the client object.
  • [0220]
    Modern browsers offer an alternate means to asynchronously communicate and exchange information between the browser and the server, implemented as the so-called “XMLHTTPRequest Object” available in the browser and callable through JavaScript in the web page. Applications that implement this technique are typically referred to as “AJAX” applications (Asynchronous JavaScript and XML). Browser-based embodiments that use AJAX to communicate with the server do not need the Adobe Flash Player to communicate with the QuestObjects server: the client object (or just the client object's communications controller component) can be implemented in JavaScript and can use the XMLHTTPRequest method to communicate with the server object.
  • [0221]
    A disadvantage of AJAX is that, for Internet security reasons, a client object residing in a web page loaded by the user's browser cannot communicate directly with any server object that is hosted on a different domain or sub domain. (Through the use of “browser hacks” such as frames or dynamic addition of <script> tags to the web page, embodiments can get around this limitation. However, this is not considered safe because future browser versions can close such “loopholes”. The workarounds often have unacceptable negative performance penalties).
  • [0222]
    An alternative means to deploy embodiments where the client object is hosted on a different (sub) domain than the server object, is to install a so-called “proxy” on the client object's domain. The client object then communicates with the proxy (on the same domain) that forwards the client's communication packages to the server object. The server's responses are sent to the proxy, and are then forwarded to the client object by the proxy. Proxies like this can easily be configured in popular web servers such as Apache, and forwarding proxy functionality is often also offered by load balancing hardware and software.
  • [0223]
    FIG. 24 shows screen shots 350, 360 of alternate embodiments of the present invention. FIG. 24A shows a “ProductFinder QuestField” embodiment that is embedded onto an ecommerce website. The QuestField uses a hybrid implementation that automatically detects the most suitable technology to be used to communicate with the QuestObjects server. Depending on the user's browser or device, the client object will communicate with the QuestObjects server using either Adobe Flash or AJAX technology. Automatic detection can be performed through a JavaScript function that checks the user's environment and then tells the client software which technology to use. Different embodiments may also support just one client technology. FIG. 24B shows a screenshot of a web page specifically designed to use AJAX rather than Adobe Flash. Other embodiments can use other means to communicate asynchronously between the client computer and the server computer, e.g. through the use of Microsoft Corporation's Silverlight technology.
  • [0224]
    Although many embodiments are designed to run within a web browser, QuestField clients can also be implemented for dedicated runtime environments that allow users to use them outside of the traditional web browser, or as an integrated part of pre-compiled client-server applications that run on the user's client operating system. For example, Adobe's AIR environment allows the creation of “web applications” that, through an integrated runtime software environment, appear to run as standalone applications in the user's operating system. Similarly, “Dashboard widgets” in Apple's Mac OS and “Sidebar Gadgets” in Microsoft's Windows Vista OS can be used to implement QuestField clients. A QuestField can also be embedded into a toolbar of third-party applications. Background QuestFields can also be used as “plug-ins” to link non-QuestField search and retrieval interfaces (such as Microsoft's Instant Search or Apple's Spotlight) to remote QuestObjects services, so that users of these third-party search and retrieval interfaces will find and return QuestField search results in addition to the other content they index and return.
  • [0225]
    If no cross-domain communications capabilities (and no proxies) are available to allow asynchronous client-to-server-and-back communication from within a browser or from a mobile device, then some embodiments can open the client part in a new web page opened in a new window or in a frame or iframe in the page, wherein the new window or frame is loaded from the same (sub)domain that hosts the server part, or from a (sub)domain that has a proxy to the server object. Such an embodiment is referred to as a “full page QuestField”.
  • [0226]
    FIG. 25 shows embodiments 370, 372 of the client that can be run on a mobile device that allows XMLHTTP communications (AJAX) with the QuestObjects server embodiment. Full-page QuestFields are of particular benefit on devices with small screens (such as the iPhone). Although the web page shown in FIG. 24B works on an iPhone, the user interface (notably the way in which the result list is dropped down) does not work very well because it is not adjusted to the small size of the client device, and results might therefore appear off-screen, too large, or too small. In accordance with an embodiment of the client, the QuestField of FIG. 24A or FIG. 24B can detect that it is being accessed from such a small mobile device. This detection can occur when the user first puts the cursor into the entry field (or first clicks on a placeholder that is displayed in the same position as the input field to represent the QuestField). As soon as this happens, the full-page QuestField is displayed on the mobile device, as shown on the left side of FIG. 25A. The user can immediately start typing to activate the QuestField and to perform a query, as shown on the right of FIG. 25A.
  • [0227]
    In accordance with an embodiment, a QuestField is configured in the web page that contains it. When used in tandem with such a QuestField-enhanced third-party web page, the full-page QuestField will automatically configure itself to allow the user to access information just as if it were being accessed from the original page (e.g. the ecommerce page of FIG. 24A). The full-page QuestField that opens when an iPhone user clicks on the field will automatically go to the same content channel and have the same other features as the QuestField on the “parent page”, which the full-page QuestField may replace if it is opened in the same browser page (in the “_self” target). In a typical web browser, the full-page QuestField can receive its configuration from the “parent window” as arguments that appear after a question mark in the URL of the full-page QuestField. In some implementations, the full-page QuestField will use a reference to the parent page as it is defined by a frame's “window.parent” attribute or a window's “window.opener” attribute.
  • [0228]
    Although it fills the entire web page, a full-page QuestField can still resize and adjust itself when the user resizes it, or when the user rotates the page, as is possible on the iPhone. This is shown in FIG. 25B, where the user has rotated the phone into “landscape mode” and the QuestField shows results, as well as an “information bubble” that shows the total number of results received from the server. Because the QuestField itself is no longer visible in order to show the user the maximum number of results, the “Q-symbol” that is normally displayed inside the input field (FIG. 13A) is now displayed in the information bubble, and has become a button that the user can press to reveal the QuestField's input element and the keyboard again, to modify the current query or to start a new query. The “X” on the right of the information bubble allows the user to hide the information bubble entirely. In this example, the user can click at the top of the iPhone window to scroll back to the top of the page that has the input element.
  • [0229]
    A full-page QuestField embodiment can also be used to provide a scaled-back search interface for those browsers or devices that do not allow asynchronous communication (i.e. browsers or devices that do not support Flash, AJAX, or similar technologies to run). When the user of such a device or browser enters a QuestField embodiment that supports this, he or she is presented with a full page QuestField interface (either in the current page, a frame, or in a new window or popup) that provides a form with a simple static search field similar to “standard” search fields that do not offer feedback while typing as they are commonplace on the Internet. Like other static search fields, the user must then press a Submit or Search button to activate the QuestField search. Results are then displayed in a similar manner to the way results are displayed by typical search engines including Google and Yahoo. However, because it takes over the configuration of the QuestField on the parent page that it replaces, a full-page QuestField will use the same list layout that was configured in the parent page, and can also provide standard “Next” and “Previous” buttons that allow users to page through the results returned by the QuestObjects server.
  • Content Indexing
  • [0230]
    In accordance with various embodiments, the information used by the system is typically stored in files or databases. Users find their information through custom web applications, database applications, and search engines. Leveraging existing application infrastructures, QuestFields can access the existing “content engines” to allow users to find and retrieve information at high speed. Through Content Access Modules, QuestFields communicate with multiple databases and search engines, and can also read information from files and legacy systems. QuestFields manage the information retrieval process so that information appears faster than in traditional applications, without creating a large burden on the content sources, yet without copying the information before retrieval.
  • [0231]
    Some currently available databases or search engines are incapable of returning the right information, or are not powerful enough to return sufficiently fast answers to the QuestObjects server; and some content is stored in flat files which cannot be retrieved through a database or search engine. For these situations, QuestObjects server embodiments can include an indexing feature that reads information and indexes it for retrieval by QuestField users. There is no need to change anything in the existing database or files; regardless of how information is stored, with the QuestFields Indexer information can be made available to users through the present invention. The indexer can work in the background as new versions of data are detected so that users enjoy 24/7 uptime. Once indexed, information can be found without accessing the content source or content engine, so that QuestFields can provide answers while users are typing. With the indexer and built-in retrieval engine, QuestField users can even find information from non-indexed sources.
  • [0232]
    The QuestObjects Indexer is optional for fast content sources that have their own indexes, such as most SQL databases and LDAP directories, but is of more use with non-indexed content sources such as files. The QuestObjects Indexer can run as an integral part of the QuestObjects server, and will automatically index content that it receives from the so-called Generic File Plugin (the Content Access Module that is capable of reading flat files). The QuestObjects Indexer can also run as a stand-alone application, allowing the data to be indexed on a different machine without burdening the QuestObjects server. The QuestObjects Indexer can also work with so-called “crawler” software that tells the indexer which files to index. This is typically used to index information stored on websites, either on the Internet or in intranet environments. The crawler tells the QuestObjects Indexer which files to index. The QuestObjects Indexer can support multiple file types including plain text, HTML, Microsoft Word, Microsoft Excel, Microsoft PowerPoint, PDF, etc.
  • [0233]
    FIG. 26 shows how an embodiment 380 in which the QuestObjects Indexer fits into the QuestObjects server software architecture. As described previously with regard to FIG. 1, the upper component of this drawing depicts the client tier of the embodiment; the bottom of the diagram depicts the various content sources. The QuestObjects Indexer accesses information through the QuestObjects server's Content Access Modules as previously described. The various other parts of the QuestObjects server, as they were described earlier, are depicted in the center of this image. The QuestObjects Indexer can be configured to index information from any CAM that is capable of returning full datasets. The content engine must be able to return all the information that a user wants to search for through a QuestField. Inherently, this is true for information stored in files, but also for information stored in database tables or in directories that can return specified content through a pre-defined query. For example, using SQL, the entire contents of a table can be read using the statement “SELECT * FROM TABLE”.
  • [0234]
    For faster performance, the QuestObjects server can store the indexes in memory when it starts up, and whenever the QuestObjects Indexer has finished indexing a new data set. However, the indexes can also be stored on disk, and can also be used from disk without reading them entirely into server memory. The QuestObjects Indexer can thus be used to index information from all the content sources depicted at the bottom of FIG. 26 (except the “Search Engine” content source, which usually applies its own indexing and retrieval algorithms). The same is true for most information that is accessible through web services, unless the web service allows all content to be returned to the QuestObjects server at once.
  • Indexed Retrieval
  • [0235]
    Once information has been indexed by the QuestObjects Indexer, it can be made available for retrieval by QuestFields through one or more content channels. In accordance with an embodiment, each indexed data set is configured as a “content query”, and thus a single content channel can query and combine results from multiple indexes, and combine those with results received from other content sources and corresponding content queries included in the content channel.
  • [0236]
    In accordance with an embodiment, the QuestObjects Indexer can apply additional algorithms to the text information it indexes in order to improve the recall of information by QuestField users. In some QuestField applications, information is found after the user types one or more characters. The content channel then performs one or more content queries (or retrieval from the indexes created by the QuestObjects Indexer) and returns any information records that contain words that “start with” the characters that the user typed. However, sometimes the characters that the users type to find information are not at the start of a word. Without the QuestObjects Indexer, the QuestObjects server leaves it to the attached content engine(s) to sort out how to best retrieve record based on user input. However, with the QuestObjects Indexer, the QuestObjects server can apply this search intelligence.
  • [0237]
    Embodiments of the present invention incorporate additional methods to allow users to find information using different search strings than just the start of a word. These embodiments allow this by adding various options that can be configure, including for example camelWords, splitNumbers, minimumSplit, separatorList, stripList, stripZeros, and queryType, as described below. A simplistic approach to increase the recall of information by users would be to do a “mid search” on all the data available to the server, wherein all records are returned that have text that contains the typed characters anywhere in a word. However, with large data sets, this would return way too many results, and would include results that the user did not intend to find. Also, with large data sets, performing a “mid” search is much more processor intensive than retrieving records by matching user input against one or more indexes.
  • [0238]
    When the “camelCase” attribute is set to true, this attribute causes the QuestObjects server to recognize parts of words that start with an uppercase character after a lowercase character (“Camel Case”). For example, the server will allow users to type “mac” in order to find “iMac” or to type “objects” to find “MasterObjects”. The indexer allows this by adding parts of words to the index that start with a capital letter and that are preceded by a lowercase character.
  • [0239]
    The “splitNumbers” attribute, when set to true, causes the QuestObjects server to recognize numbers and alphanumeric sequences that are part of a longer string, such as a product type. For example, users are able to type “400” in order to find a product containing the text “LG LW-T400A”. The “minimumSplit” attribute is used in conjunction with the “splitNumbers” attribute to determine the minimum number of digits or alphanumeric characters that will cause the QuestObjects server to add a word to its index when the string is split using the splitNumbers attribute. If splitting the string results in “words” that are less than minimumSplit, then those words are not included in the retrieval index. So if minimumSplit is set to 2, “LG LW-T400A4GT” would not be retrieved by typing just “a”, but it would be retrieved by typing “gt”.
  • [0240]
    The “separatorList” is an optional attribute containing a non-separated list of characters that are recognized as word separators, that is, they index the words that follow them: If a dash (-) is included in this list, the QuestObjects server will allow users to type “T40” in order to find “LG LW-T400A”, even if a dash is included in the stripList attribute (described below). An example value for this attribute would be: “-/&_”.
  • [0241]
    The “stripList” is an optional attribute containing a non-separated list of characters that are automatically stripped from user queries, and from text in the word index. For example, after including a dash (-) and a slash (/) in the comma-separated list, the QuestObjects server allows users to find “LG LW-T400” by typing “LWT”, “LW-T”, or “LW/T”. An example value for this attribute would be: “−/.\\,”.
  • [0242]
    The “stripZeros” attribute, when set to true, causes the QuestObjects server to create extra words in the index for numbers that have leading zeros. Users are able to find results containing a number without having to type the leading zeros, so a result containing “000123” can be found by typing “123”.
  • [0243]
    The “queryType” attribute has three possible values: 2, 4, or 6. It determines the type of query that is executed against the index. The default value (2) provides a Prefix query. This means that all words are found that start with, or are equal to, the words in the actual query. This can cause a significant amount of temporary memory usage during a query when using a large (200+MB) index. The second value (4) provides a Boolean query. Only words that are equal to the words in the query will be found. While the amount of temporary memory required is not problematic with this setting, it might not provide all the results that the user expects. The third possible value (6) provides a hybrid approach: The QuestObjects server will first perform a Boolean query. If the number of results is lower than the maximum set for the channel, a Prefix query is done for all words that are 3 characters or longer. If the maximum is still not reached a Prefix query is done for all words of 2 characters and longer, etc. until all words are used in a Prefix query. Using this third setting only makes sense in combination with setting the maxSearchClauses attribute in the Content Access Module configuration. If searches exceed the search clauses limit, a result is appended to the results list to inform the user. For example: “Results limited to exact matches for xx, yy, zz.”. Users can then add characters to the words in their query. Because of the possible multiple searches, it takes longer to get a result. However the temporary memory requirement is controllable with the maxSearchClauses attribute and the results are what the user expects.
  • Syndication QuestFields
  • [0244]
    In accordance with an embodiment, the client part (referred to as the “QuestField”) can be used to retrieve content from QuestObjects servers that are hosted on Internet domains which are different from the web page itself. This enables content owners and providers to offer “Syndication QuestFields” to customers and associates, wherein these customers and associates place a QuestField on their own website(s) or portal(s) in order to allow their users and visitors to retrieve content from the content provider, as if the content were owned and hosted by the third-party.
  • [0245]
    For example, a newspaper publisher that wants to draw visitors to its site or content can allow associates to place a “News Search” QuestField on their websites, which will in turn, access a content channel configured on the QuestObjects server owned by the newspaper publisher. FIG. 27 shows how an embodiment 382, 386 of such a system works: a Content Owner or Publisher (who hosts and publishes its information from the hypothetic domain name “publisher.com”) has a database of information that is made available through configured content channels in a QuestObjects server hosted on its domain. Third-party “Associates” can subscribe to the information and make it available to users of their own web pages by embedding a QuestField to their page(s), or by providing a button that opens up a full-page QuestField as described earlier.
  • [0246]
    As another example, an Internet hosting provider can offer a service that automatically indexes the content (including web pages, documents, as well as information published through web services) of customer websites, and then allow its customers to place QuestFields on the web pages on their own sites in order to allow visitors to search their site content. FIG. 27B show how this works. The hosting company or service provider crawls, indexes, or imports third-party content and stores the resulting indexes so they can be accessed through a QuestObjects server owned by the hosting company or service provider. Each “content set” is made available through a content channel (“Search A” and “Search B” in FIG. 27B). The third parties who own the websites and their content can subsequently place a QuestField on their web page(s) so that their users and visitors can find their content through a QuestField. This model works both for “Website Search” functionality as for other types of retrieval, wherein the third parties make the content available to the hosting company. For example, a product catalogue owner (or product seller) can upload the complete database of product records to hosting company or service provider who indexes the products and makes them available through a QuestObjects content channel. The owner of the catalogue can then place a QuestField on its web page(s) to allow visitors to quickly find their products in the QuestFields results list.
  • [0247]
    The QuestFields system provides significant business values. For example, a third party that wants to make its information searchable/findable does not need to install any software. The content owner only needs to add a bit of QuestField code to its web page(s) in order to make the content easily findable. The hosting company or service provider can charge for its “QuestObjects Service”. It is also possible for the provider to generate revenue by inserting advertising in the search results or displaying advertising in the QuestField (hosted by its “customer”). By making their information searchable and findable on third-party websites, content publishers can draw more visitors to their content and increase the value of their brand name. Note that the results that appear in the QuestField (on the third party “associate” websites) can include links to the publisher website and to specific (potentially valuable or paid) information made available to the publisher. A QuestField can display results that force a user to login to the publisher's website on a paid subscription basis.
  • [0248]
    As described previously, Syndicated QuestFields do not necessarily need to be part of the third-party web page(s) that are loaded in a web browser. A Syndicated QuestField can also be implemented as a “widget” or “gadget” that users run in a third-party runtime environment such as Adobe AIR, Apple Spotlight, or Microsoft Sidebar. A Syndicated QuestField embodiment can also be provided as a special pre-compiled application that is installed on the users' native operating system(s).
  • [0249]
    Some aspects of the present invention may be conveniently implemented using a conventional general purpose or a specialized digital computer, microprocessor, or electronic circuitry programmed according to the teachings of the present disclosure. Appropriate software coding can readily be prepared by skilled programmers and circuit designers based on the teachings of the present disclosure, as will be apparent to those skilled in the art.
  • [0250]
    In some embodiments, the present invention includes a computer program product which is a storage medium (media) having instructions stored thereon/in which can be used to program a computer to perform any of the processes of the present invention. The storage medium can include, but is not limited to, any type of disk including floppy disks, optical discs, DVD, CD-ROMs, microdrive, and magneto-optical disks, ROMs, RAMs, EPROMs, EEPROMs, DRAMs, VRAMs, flash memory devices, magnetic or optical cards, nanosystems (including molecular memory ICs), or any type of media or device suitable for storing instructions and/or data.
  • [0251]
    The foregoing description of the present invention has been provided for the purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise forms disclosed. Many modifications and variations will be apparent to the practitioner skilled in the art. The embodiments were chosen and described in order to best explain the principles of the invention and its practical application, thereby enabling others skilled in the art to understand the invention for various embodiments and with various modifications that are suited to the particular use contemplated. It is intended that the scope of the invention be defined by the following claims and their equivalence.
Patent Citations
Cited PatentFiling datePublication dateApplicantTitle
US4255796 *Feb 14, 1978Mar 10, 1981Bell Telephone Laboratories, IncorporatedAssociative information retrieval continuously guided by search status feedback
US4330845 *Dec 31, 1979May 18, 1982International Business Machines CorporationGuess-ahead feature for a keyboard-display terminal data input system
US4339806 *Nov 15, 1979Jul 13, 1982Kunio YoshidaElectronic dictionary and language interpreter with faculties of examining a full-length word based on a partial word entered and of displaying the total word and a translation corresponding thereto
US4438505 *Feb 8, 1980Mar 20, 1984Sharp Kabushiki KaishaElectronic dictionary and language interpreter with auto-search key for deriving a full-length word and its associated translation word based on a partial word entered
US4823310 *Aug 10, 1987Apr 18, 1989Wang Laboratories, Inc.Device for enabling concurrent access of indexed sequential data files
US5357431 *Jan 25, 1993Oct 18, 1994Fujitsu LimitedCharacter string retrieval system using index and unit for making the index
US5572672 *Jul 12, 1995Nov 5, 1996International Business Machines CorporationMethod and apparatus for monitoring data processing system resources in real-time
US5748512 *Feb 28, 1995May 5, 1998Microsoft CorporationAdjusting keyboard
US5754771 *Feb 12, 1996May 19, 1998Sybase, Inc.Maximum receive capacity specifying query processing client/server system replying up to the capacity and sending the remainder upon subsequent request
US5778381 *Aug 4, 1995Jul 7, 1998Aircraft Technical PublishersComputer aided maintenance and repair information system for equipment subject to regulatory compliance
US5790793 *Apr 4, 1995Aug 4, 1998Higley; ThomasMethod and system to create, transmit, receive and process information, including an address to further information
US5802292 *Apr 28, 1995Sep 1, 1998Digital Equipment CorporationMethod for predictive prefetching of information over a communications network
US5805911 *Feb 1, 1995Sep 8, 1998Microsoft CorporationWord prediction system
US5845300 *Jun 5, 1996Dec 1, 1998Microsoft CorporationMethod and apparatus for suggesting completions for a partially entered data item based on previously-entered, associated data items
US5964836 *Sep 11, 1997Oct 12, 1999International Business Machines CorporationApparatus, methods and computer program products for managing web-page-embedded sessions with a host-based application
US5978800 *Mar 13, 1998Nov 2, 1999Dainippon Screen Mfg. Co., Ltd.Method of searching data for a given character string
US6006225 *Sep 1, 1998Dec 21, 1999Amazon.ComRefining search queries by the suggestion of correlated terms from prior searches
US6065048 *Oct 29, 1997May 16, 2000Netdelivery CorporationMethod and system to create, transmit, receive and process information, including an address to further information
US6208339 *Jun 19, 1998Mar 27, 2001International Business Machines CorporationUser-interactive data entry display system with entry fields having distinctive and changeable autocomplete
US6271840 *Sep 24, 1998Aug 7, 2001James Lee FinsethGraphical search engine visual index
US6278992 *Feb 17, 1999Aug 21, 2001John Andrew CurtisSearch engine using indexing method for storing and retrieving data
US6292806 *Nov 16, 1999Sep 18, 2001Aircraft Technical PublishersComputer aided maintenance and repair information system for equipment subject to regulatory compliance
US6434547 *Oct 28, 1999Aug 13, 2002Qenm.ComData capture and verification system
US6453312 *Oct 14, 1998Sep 17, 2002Unisys CorporationSystem and method for developing a selectably-expandable concept-based search
US6460071 *Nov 21, 1997Oct 1, 2002International Business Machines CorporationSystem and method for managing client application state in a stateless web browser environment
US6496833 *Nov 1, 1999Dec 17, 2002Sun Microsystems, Inc.System and method for generating code for query object interfacing
US6539421 *Sep 24, 1999Mar 25, 2003America Online, Inc.Messaging application user interface
US6564213 *Apr 18, 2000May 13, 2003Amazon.Com, Inc.Search query autocompletion
US6571282 *Aug 31, 1999May 27, 2003Accenture LlpBlock-based communication in a communication services patterns environment
US6598051 *Sep 19, 2000Jul 22, 2003Altavista CompanyWeb page connectivity server
US6629092 *Oct 13, 1999Sep 30, 2003Andrew BerkeSearch engine
US6631512 *Jan 15, 1999Oct 7, 2003Gillis E OnyeaborMethod and system for database-driven, scalable web page development, deployment-download, and execution
US6665838 *Jul 30, 1999Dec 16, 2003International Business Machines CorporationWeb page thumbnails and user configured complementary information provided from a server
US6704906 *Mar 27, 1999Mar 9, 2004Movaris, Inc.Self-directed routable electronic form system and method
US6718015 *Dec 16, 1998Apr 6, 2004International Business Machines CorporationRemote web page reader
US6732090 *Dec 5, 2001May 4, 2004Xerox CorporationMeta-document management system with user definable personalities
US6778979 *Dec 5, 2001Aug 17, 2004Xerox CorporationSystem for automatically generating queries
US6789120 *Oct 26, 2000Sep 7, 2004Samsung Electronics Co., Ltd.Real-time audio/video communication method for use on the internet and device therefor
US6801190 *May 26, 2000Oct 5, 2004America Online IncorporatedKeyboard system with automatic correction
US6820075 *Dec 5, 2001Nov 16, 2004Xerox CorporationDocument-centric system with auto-completion
US6829607 *Apr 24, 2000Dec 7, 2004Microsoft CorporationSystem and method for facilitating user input by automatically providing dynamically generated completion information
US6839705 *Feb 10, 1998Jan 4, 2005Gateway, Inc.Method for delivering and caching preprocessed search results to improve performance of background information searches on a convergence device
US6879691 *May 11, 2001Apr 12, 2005Bluetie, Inc.Information autocompletion system
US6915279 *Mar 11, 2002Jul 5, 2005Mastercard International IncorporatedSystem and method for conducting secure payment transactions
US6922810 *Mar 7, 2000Jul 26, 2005Microsoft CorporationGrammar-based automatic data completion and suggestion for user input
US6928425 *Dec 5, 2001Aug 9, 2005Xerox CorporationSystem for propagating enrichment between documents
US6961750 *May 18, 2000Nov 1, 2005Microsoft Corp.Server-side control objects for processing client-side user interface elements
US6990653 *May 18, 2000Jan 24, 2006Microsoft CorporationServer-side code generation from a dynamic web page content file
US6993723 *Apr 17, 2000Jan 31, 2006Accenture LlpListing activities in a graphical user interface in a collaborative work tool Architecture
US7000179 *Feb 22, 2002Feb 14, 2006Movaris, Inc.Method and apparatus for programmatic learned routing in an electronic form system
US7003446 *Dec 17, 2004Feb 21, 2006Microsoft CorporationGrammar-based automatic data completion and suggestion for user input
US7013312 *Jun 21, 2001Mar 14, 2006International Business Machines CorporationWeb-based strategic client planning system for end-user creation of queries, reports and database updates
US7032030 *Mar 10, 2000Apr 18, 2006John David CodignottoMessage publishing system and method
US7073121 *Nov 26, 2002Jul 4, 2006International Business Machines CorporationWeb page thumbnails and user configured complementary information provided from a server
US7117432 *Dec 5, 2001Oct 3, 2006Xerox CorporationMeta-document management system with transit triggered enrichment
US7133862 *Dec 5, 2001Nov 7, 2006Xerox CorporationSystem with user directed enrichment and import/export control
US7149970 *Jun 23, 2000Dec 12, 2006Microsoft CorporationMethod and system for filtering and selecting from a candidate list generated by a stochastic input method
US7167875 *Sep 15, 2003Jan 23, 2007International Business Machines CorporationWeb page thumbnails and user configured complementary information provided from a server
US7181497 *Jan 22, 2003Feb 20, 2007America Online, Inc.Messaging application user interface for auto-completing address text and modifying the auto-completion behavior
US7185271 *Aug 20, 2002Feb 27, 2007Hewlett-Packard Development Company, L.P.Methods and systems for implementing auto-complete in a web page
US7251775 *Nov 8, 2000Jul 31, 2007Nokia CorporationSystem and method for visual history presentation and management
US7284191 *Dec 5, 2001Oct 16, 2007Xerox CorporationMeta-document management system with document identifiers
US7321918 *Oct 14, 2004Jan 22, 2008Microsoft CorporationServer-side control objects for processing client-side user interface elements
US7346667 *Jul 31, 2001Mar 18, 2008Ubs AgSystem for delivering dynamic content
US7389307 *Aug 9, 2001Jun 17, 2008Lycos, Inc.Returning databases as search results
US7500223 *Jan 2, 2004Mar 3, 2009International Business Machines CorporationAutomatically creating JavaScript objects to invoke methods on server-side Java beans
US7512654 *Nov 15, 2004Mar 31, 2009Microsoft CorporationSystem and method for facilitating user input by providing dynamically generated completion information
US7559018 *Sep 10, 2003Jul 7, 2009Sas Institute Inc.Computer-implemented system and method for data collection
US7587385 *Aug 30, 2005Sep 8, 2009Sap AgAutocompletion for unordered lists
US7647349 *Nov 22, 2005Jan 12, 2010Xerox CorporationSystem with user directed enrichment and import/export control
US7657423 *Oct 31, 2003Feb 2, 2010Google Inc.Automatic completion of fragments of text
US7685144 *Dec 29, 2005Mar 23, 2010Google Inc.Dynamically autocompleting a data entry
US7698127 *Oct 1, 2004Apr 13, 2010Microsoft CorporationGrammar-based automatic data completion and suggestion for user input
US7769757 *Sep 10, 2007Aug 3, 2010Xerox CorporationSystem for automatically generating queries
US7793228 *Oct 13, 2006Sep 7, 2010Apple Inc.Method, system, and graphical user interface for text entry with partial word display
US7836044 *Jun 22, 2004Nov 16, 2010Google Inc.Anticipated query generation and processing in a search engine
US7840894 *Mar 30, 2006Nov 23, 2010International Business Machines CorporationWeb page thumbnails and user configured complementary information provided from a server
US7856432 *Oct 26, 2004Dec 21, 2010Sap AgSystems and methods for searching and displaying search hits in hierarchies
US7890516 *May 30, 2008Feb 15, 2011Microsoft CorporationRecommending queries when searching against keywords
US7900228 *May 2, 2005Mar 1, 2011Vulcan Inc.Maintaining a graphical user interface state that is based on a selected piece of content
US7941525 *Mar 18, 2007May 10, 2011ClickTale, Ltd.Method and system for monitoring an activity of a user
US7941819 *Apr 27, 2009May 10, 2011Vulcan Inc.Time-based graphical user interface for multimedia content
US8099436 *Aug 24, 2010Jan 17, 2012Lasimer NY LLCMethods and systems for automated searching
US8112529 *Aug 20, 2001Feb 7, 2012Masterobjects, Inc.System and method for asynchronous client server session communication
US8131258 *Jun 4, 2009Mar 6, 2012Boku, Inc.Systems and methods to process transaction requests
US8135729 *Dec 18, 2010Mar 13, 2012Microsoft CorporationIncremental query refinement
US8281259 *Jul 19, 2010Oct 2, 2012Microsoft CorporationIntelligent backward resource navigation
US8505024 *Aug 31, 2006Aug 6, 2013Shaw Parsing LlcStoring state in a dynamic content routing network
US8700595 *Dec 15, 2011Apr 15, 2014Hyperthink, LlcMethods and systems for automated searching
US20010023447 *Dec 18, 2000Sep 20, 2001West Mark AlanLong latency or error prone links
US20020049756 *Aug 9, 2001Apr 25, 2002Microsoft CorporationSystem and method for searching multiple disparate search engines
US20020055981 *Aug 31, 2001May 9, 2002Frederic SpaeySystem and method for remotely browsing structured data
US20020069122 *Feb 21, 2001Jun 6, 2002Insun YunMethod and system for maximizing credit card purchasing power and minimizing interest costs over the internet
US20020078045 *Dec 14, 2000Jun 20, 2002Rabindranath DuttaSystem, method, and program for ranking search results using user category weighting
US20020078300 *Aug 16, 1999Jun 20, 2002Chanda DharapSemantics-based caching policy to minimize latency
US20020087514 *Jan 31, 2002Jul 4, 2002Openwave Systems Inc.Method and apparatus for displaying a record from a structured database with minimum keystrokes
US20020103797 *Dec 28, 2000Aug 1, 2002Surendra GoelDisplaying search results
US20020116457 *Feb 21, 2002Aug 22, 2002John EshlemanSystems and methods for managing distributed database resources
US20020184343 *Jul 31, 2001Dec 5, 2002Stephen AshcroftSystem for delivering dynamic content
US20020188603 *Jun 6, 2001Dec 12, 2002Baird Bruce R.Methods and systems for user activated automated searching
US20030018644 *Jun 21, 2001Jan 23, 2003International Business Machines CorporationWeb-based strategic client planning system for end-user creation of queries, reports and database updates
US20030033287 *Dec 5, 2001Feb 13, 2003Xerox CorporationMeta-document management system with user definable personalities
US20030033288 *Dec 5, 2001Feb 13, 2003Xerox CorporationDocument-centric system with auto-completion and auto-correction
US20030033324 *Aug 9, 2001Feb 13, 2003Golding Andrew R.Returning databases as search results
US20030041058 *Dec 28, 2001Feb 27, 2003Fujitsu LimitedQueries-and-responses processing method, queries-and-responses processing program, queries-and-responses processing program recording medium, and queries-and-responses processing apparatus
US20030050959 *Mar 26, 2002Mar 13, 2003Yaroslav FaybishenkoSystem and method for distributed real-time search
US20030061200 *Dec 5, 2001Mar 27, 2003Xerox CorporationSystem with user directed enrichment and import/export control
US20030061201 *Dec 5, 2001Mar 27, 2003Xerox CorporationSystem for propagating enrichment between documents
US20030069877 *Dec 5, 2001Apr 10, 2003Xerox CorporationSystem for automatically generating queries
US20030071850 *Oct 12, 2001Apr 17, 2003Microsoft CorporationIn-place adaptive handwriting input method and system
US20030079179 *Nov 26, 2002Apr 24, 2003Brown Michael WayneWeb page thumbnails and user configured complementary information provided from a server
US20030110443 *Feb 22, 2002Jun 12, 2003Steve YankovichMethod and apparatus for programmatic learned routing in an electronic form system
US20030120554 *Mar 11, 2002Jun 26, 2003Edward HoganSystem and method for conducting secure payment transactions
US20030146939 *Sep 24, 2001Aug 7, 2003John PetropoulosMethods and apparatus for mouse-over preview of contextually relevant information
US20040064471 *Sep 15, 2003Apr 1, 2004Brown Michael WayneWeb page thumbnails and user configured complementary information provided from a server
US20040093562 *Aug 25, 2003May 13, 2004Diorio Donato S.System and method for a hierarchical browser
US20040139396 *Jun 4, 2003Jul 15, 2004Gelernter David H.Stream-based information management system
US20040141011 *Jan 7, 2004Jul 22, 2004Smethers Paul A.Graphical user interface features of a browser in a hand-held wireless communication device
US20040142720 *Jan 7, 2004Jul 22, 2004Smethers Paul A.Graphical user interface features of a browser in a hand-held wireless communication device
US20040143564 *Sep 3, 2003Jul 22, 2004William GrossMethods and systems for Web-based incremental searches
US20040143591 *Aug 5, 2003Jul 22, 2004Onyeabor Gillis E.Method and system for database-driven, scalable web page development, deployment, download, and execution
US20040199867 *Dec 16, 2003Oct 7, 2004Cci Europe A.S.Content management system for managing publishing content objects
US20040205448 *Dec 5, 2001Oct 14, 2004Grefenstette Gregory T.Meta-document management system with document identifiers
US20050022114 *Dec 5, 2001Jan 27, 2005Xerox CorporationMeta-document management system with personality identifiers
US20050043939 *Oct 1, 2004Feb 24, 2005Microsoft CorporationGrammar-based automatic data completion and suggestion for user input
US20050043942 *Oct 1, 2004Feb 24, 2005Microsoft CorporationGrammar-based automatic data completion and suggestion for user input
US20050050164 *Oct 14, 2004Mar 3, 2005Burd Gary S.Server-side control objects for processing client-side user interface elements
US20050050547 *Aug 29, 2003Mar 3, 2005Whittle Derrick W.Method and apparatus for providing desktop application functionality in a client/server architecture
US20050055438 *Sep 10, 2003Mar 10, 2005Matti Michael C.Computer-implemented system and method for data collection
US20050102131 *Dec 17, 2004May 12, 2005Microsoft CorporationGrammar-based automatic data completion and suggestion for user input
US20050120005 *Oct 26, 2004Jun 2, 2005Guido TeschSystems and methods for searching and displaying search hits in hierarchies
US20050262065 *May 3, 2005Nov 24, 2005Barth Brian EMethod and apparatus for dynamic information connection engine
US20050283468 *Jun 22, 2004Dec 22, 2005Kamvar Sepandar DAnticipated query generation and processing in a search engine
US20060004843 *Jul 20, 2005Jan 5, 2006Microsoft CorporationSystem and method for automatically populating a dynamic resolution list
US20060015842 *Jan 2, 2004Jan 19, 2006Desantis RobertAutomatically creating JavaScript objects to invoke methods on server-side java beans
US20060026636 *May 2, 2005Feb 2, 2006Vulcan Inc.Maintaining a graphical user interface state that is based on a selected piece of content
US20060026638 *May 2, 2005Feb 2, 2006Vulcan Inc.Maintaining a graphical user interface state that is based on a selected type of content
US20060031880 *May 2, 2005Feb 9, 2006Vulcan Inc.Time-based graphical user interface for television program information
US20060041927 *May 2, 2005Feb 23, 2006Vulcan Inc.Maintaining a graphical user interface state that is based on a selected time
US20060080314 *Nov 22, 2005Apr 13, 2006Xerox CorporationSystem with user directed enrichment and import/export control
US20060095424 *Nov 29, 2005May 4, 2006John PetropoulosMethods and apparatus for mouse-over preview of contextually relevant information
US20060129929 *Dec 15, 2004Jun 15, 2006Microsoft CorporationSystem and method for automatically completing spreadsheet formulas
US20060143307 *Feb 16, 2006Jun 29, 2006John CodignottoMessage publishing system
US20060167872 *Jan 21, 2005Jul 27, 2006Prashant ParikhAutomatic dynamic contextual data entry completion system
US20060174198 *Mar 30, 2006Aug 3, 2006Brown Michael WWeb page thumbnails and user configured complementary information provided from a server
US20060242109 *Apr 25, 2005Oct 26, 2006Microsoft CorporationServer-deployed cache list management for presenting an auto-complete list
US20060248166 *Apr 29, 2005Nov 2, 2006Jovan MilosevicSystem and method for client side rendering of a web page
US20060265648 *Oct 21, 2005Nov 23, 2006Roope RainistoElectronic text input involving word completion functionality for predicting word candidates for partial word inputs
US20060265668 *May 23, 2005Nov 23, 2006Roope RainistoElectronic text input involving a virtual keyboard and word completion functionality on a touch-sensitive display screen
US20070033176 *Oct 16, 2006Feb 8, 2007Enns Robert PSearching and reusing information from previously executed control instructions in a data forwarding device
US20070050351 *May 8, 2006Mar 1, 2007Richard KasperskiAlternative search query prediction
US20070050352 *Aug 29, 2006Mar 1, 2007Nhn CorporationSystem and method for providing autocomplete query using automatic query transform
US20070050519 *Aug 31, 2006Mar 1, 2007Cano Charles EStoring state in a dynamic content routing network
US20070050728 *Aug 30, 2005Mar 1, 2007Sap AgAutocompletion for unordered lists
US20070061410 *Sep 15, 2005Mar 15, 2007Qwest Communications International Inc.Webpage search
US20070100890 *Oct 25, 2006May 3, 2007Kim Tae-IlSystem and method of providing autocomplete recommended word which interoperate with plurality of languages
US20070143262 *Dec 20, 2005Jun 21, 2007Richard KasperskiInteractive search engine
US20080005651 *Sep 10, 2007Jan 3, 2008Xerox CorporationSystem for automatically generating queries
US20080071561 *Feb 5, 2007Mar 20, 2008Royaltyshare, Inc.Web-based System Providing Royalty Processing and Reporting Services
US20080259022 *Oct 13, 2006Oct 23, 2008Philip Andrew MansfieldMethod, system, and graphical user interface for text entry with partial word display
US20090043741 *Aug 7, 2008Feb 12, 2009Dohyung KimAutocompletion and Automatic Input Method Correction for Partially Entered Search Query
US20090094145 *Feb 12, 2007Apr 9, 2009Nhn CorporationMethod and system for automatically completed general recommended word and advertisement recommended word
US20090119581 *Nov 5, 2007May 7, 2009Verizon Data Services Inc.Method and apparatus for providing auto-completion of information using strings
US20090216911 *Feb 21, 2008Aug 27, 2009Larry LongMethod and system for intuitive coding to enter text expansions
US20090249198 *Jul 31, 2008Oct 1, 2009Yahoo! Inc.Techniques for input recogniton and completion
US20100153880 *Mar 5, 2008Jun 17, 2010Kannuu Pty Ltd.Method system and apparatus for entering text on a computing device
US20100169341 *Dec 30, 2008Jul 1, 2010Ebay Inc.Predictive algorithm for search box auto-complete
US20100267362 *Jun 4, 2009Oct 21, 2010Boku, Inc.Systems and Methods to Process Transaction Requests
US20100280821 *Apr 30, 2009Nov 4, 2010Nokia CorporationText editing
US20110047137 *Aug 24, 2010Feb 24, 2011Baird Bruce RMethods and systems for automated searching
US20110106831 *Jan 5, 2011May 5, 2011Microsoft CorporationRecommending queries when searching against keywords
US20110173217 *Jan 12, 2010Jul 14, 2011Yahoo! Inc.Locality-sensitive search suggestions
US20110213822 *Mar 21, 2011Sep 1, 2011Clicktale Ltd.Method and system for monitoring an activity of a user
US20110320472 *May 10, 2011Dec 29, 2011International Business Machines CorporationComplex query handling
US20120089587 *Dec 15, 2011Apr 12, 2012Lasimer NY LLCMethods and systems for automated searching
US20120109836 *Jun 20, 2011May 3, 2012Google Inc.Content sharing interface for sharing content in social networks
US20120110052 *Jun 20, 2011May 3, 2012Google Inc.Social circles in social networks
US20120110064 *Jun 20, 2011May 3, 2012Google Inc.Content sharing interface for sharing content in social networks
US20120110088 *Jun 20, 2011May 3, 2012Google Inc.Visibility inspector in social networks
US20120110096 *Jun 20, 2011May 3, 2012Google Inc.Social circles in social networks
US20120110464 *Jun 20, 2011May 3, 2012Google Inc.Content sharing interface for sharing content in social networks
US20120110474 *Jun 20, 2011May 3, 2012Google Inc.Content sharing interface for sharing content in social networks
US20130132468 *Nov 21, 2012May 23, 2013Olurotimi AzeezDiscovering, organizing, accessing and sharing information in a cloud environment
US20140025631 *Jul 12, 2013Jan 23, 2014Charles E. CanoStoring State in a Dynamic Content Routing Network
US20140164999 *Feb 11, 2014Jun 12, 2014Lasimer NY LLCMethods and systems for automated searching
Non-Patent Citations
Reference
1 *Widjaja, Indra. "Communication Networks, Fundamental Concepts and Key Architectures"2004, McGraw-Hill, 2nd ed. pages 315-316 and 611-612
Referenced by
Citing PatentFiling datePublication dateApplicantTitle
US7882173 *Jun 30, 2008Feb 1, 2011International Business Machines CorporationInteractive remote command execution over a stateless client/server network protocol
US8086489 *Apr 26, 2006Dec 27, 2011Affle LimitedMethod and apparatus to provide information and consumer-acceptable advertising via data communications clients
US8126875 *May 8, 2009Feb 28, 2012Microsoft CorporationInstant answers and integrated results of a browser
US8145620 *May 9, 2008Mar 27, 2012Microsoft CorporationKeyword expression language for online search and advertising
US8230336Apr 22, 2009Jul 24, 2012Microsoft CorporationEfficient discovery, display, and autocompletion of links to wiki resources
US8259124 *Nov 6, 2008Sep 4, 2012Microsoft CorporationDynamic search result highlighting
US8306964Jul 20, 2010Nov 6, 2012Microsoft CorporationExtraction of rich search information from index servers via an alternative asynchronous data path
US8442995Jan 14, 2011May 14, 2013Microsoft CorporationSystems and methods for controlling subscribed access to data
US8452745 *Aug 30, 2006May 28, 2013Affle Holdings Pte. Ltd.Online search system, method and computer program
US8499000 *Oct 28, 2009Jul 30, 2013Novell, Inc.System and method for floating index navigation
US8527556 *Sep 27, 2010Sep 3, 2013Business Objects Software LimitedSystems and methods to update a content store associated with a search index
US8554810 *Nov 12, 2008Oct 8, 2013Canon Kabushiki KaishaInformation processing apparatus, information processing system, processing method thereof, and recording medium
US8572129Apr 19, 2010Oct 29, 2013Facebook, Inc.Automatically generating nodes and edges in an integrated social graph
US8612882 *Sep 14, 2010Dec 17, 2013Adobe Systems IncorporatedMethod and apparatus for creating collections using automatic suggestions
US8713100 *Dec 11, 2013Apr 29, 2014Michael L. HammHybrid asynchronous transmission process
US8732208Jul 23, 2012May 20, 2014Facebook, Inc.Structured search queries based on social-graph information
US8745018Jul 10, 2009Jun 3, 2014Google Inc.Search application and web browser interaction
US8745168 *Jul 10, 2009Jun 3, 2014Google Inc.Buffering user interaction data
US8751521Jul 23, 2012Jun 10, 2014Facebook, Inc.Personalized structured search queries for online social networks
US8782080Jul 23, 2012Jul 15, 2014Facebook, Inc.Detecting social graph elements for structured search queries
US8832365Apr 20, 2012Sep 9, 2014Kip Cr P1 LpSystem, method and computer program product for a self-describing tape that maintains metadata of a non-tape file system
US8868603Dec 31, 2012Oct 21, 2014Facebook, Inc.Ambiguous structured search queries on online social networks
US8869061 *Aug 29, 2003Oct 21, 2014Microsoft CorporationUser interface for searching an electronic document
US8918418Dec 31, 2012Dec 23, 2014Facebook, Inc.Default structured search queries on online social networks
US8949250Apr 22, 2014Feb 3, 2015Facebook, Inc.Generating recommended search queries on online social networks
US8959202 *Mar 18, 2009Feb 17, 2015Civolution B.V.Generating statistics of popular content
US8977827May 31, 2012Mar 10, 2015Kip Cr P1 LpSystem, method and computer program product for recovering stub files
US9002898May 7, 2012Apr 7, 2015Facebook, Inc.Automatically generating nodes and edges in an integrated social graph
US9021019 *Sep 14, 2012Apr 28, 2015Sap SeBusiness application platform with embedded business intelligence server
US9047364 *Jan 16, 2013Jun 2, 2015Facebook, Inc.Intelligent client capability-based results related to a character stream
US9053173 *Jan 28, 2013Jun 9, 2015Facebook, Inc.Intelligent results related to a portion of a search query
US9058401 *Aug 16, 2011Jun 16, 2015Fabebook, Inc.Aggregating plug-in requests for improved client performance
US9075867Jan 31, 2013Jul 7, 2015Facebook, Inc.Intelligent results using an assistant
US9075868Feb 13, 2013Jul 7, 2015Facebook, Inc.Intelligent results based on database queries
US9076014Apr 29, 2013Jul 7, 2015Microsoft Technology Licensing, LlcSystems and methods for controlling subscribed access to data
US9086775Jul 10, 2009Jul 21, 2015Google Inc.Minimizing software based keyboard
US9092485Oct 11, 2013Jul 28, 2015Facebook, Inc.Dynamic suggested search queries on online social networks
US9105068Nov 12, 2012Aug 11, 2015Facebook, Inc.Grammar model for structured search queries
US9118722Aug 9, 2012Aug 25, 2015Amazon Technologies, Inc.Peak traffic management
US9171064Jan 31, 2013Oct 27, 2015Facebook, Inc.Intelligent community based results related to a character stream
US9179195 *Dec 15, 2004Nov 3, 2015Microsoft Technology Licensing, LlcSearching electronic program guide data
US9223838Oct 11, 2013Dec 29, 2015Facebook, Inc.Sponsored search queries on online social networks
US9223879May 14, 2012Dec 29, 2015Facebook, Inc.Dynamically generating recommendations based on social graph information
US9223898May 8, 2013Dec 29, 2015Facebook, Inc.Filtering suggested structured queries on online social networks
US9245038Apr 11, 2014Jan 26, 2016Facebook, Inc.Structured search queries based on social-graph information
US9262482Oct 11, 2013Feb 16, 2016Facebook, Inc.Generating default search queries on online social networks
US9275101Oct 11, 2013Mar 1, 2016Facebook, Inc.Search queries with previews of search results on online social networks
US9275119Oct 11, 2013Mar 1, 2016Facebook, Inc.Sharing search queries on online social network
US9317614Jul 30, 2013Apr 19, 2016Facebook, Inc.Static rankings for search queries on online social networks
US9323776Jul 28, 2014Apr 26, 2016Kip Cr P1 LpSystem, method and computer program product for a self-describing tape that maintains metadata of a non-tape file system
US9323828 *May 10, 2011Apr 26, 2016International Business Machines CorporationComplex query handling
US9336300Jan 17, 2014May 10, 2016Facebook, Inc.Client-side search templates for online social networks
US9342623Oct 8, 2013May 17, 2016Facebook, Inc.Automatically generating nodes and edges in an integrated social graph
US9355059 *Sep 22, 2008May 31, 2016International Business Machines CorporationAutomating user's operations
US9361363Dec 31, 2012Jun 7, 2016Facebook, Inc.Modifying structured search queries on online social networks
US9367536May 3, 2013Jun 14, 2016Facebook, Inc.Using inverse operators for queries on online social networks
US9367607Dec 31, 2012Jun 14, 2016Facebook, Inc.Natural-language rendering of structured search queries
US9367625May 3, 2013Jun 14, 2016Facebook, Inc.Search query interactions on online social networks
US9367629Apr 22, 2014Jun 14, 2016Facebook, Inc.Grouping recommended search queries on online social networks
US9367880May 3, 2013Jun 14, 2016Facebook, Inc.Search intent for queries on online social networks
US9378283 *Apr 23, 2012Jun 28, 2016Excalibur Ip, LlcInstant search results with page previews
US9395884 *Sep 24, 2008Jul 19, 2016Sap SeMethod and system for navigating between pages
US9396272Apr 11, 2014Jul 19, 2016Facebook, Inc.Personalized structured search queries for online social networks
US9398104Dec 20, 2012Jul 19, 2016Facebook, Inc.Ranking test framework for search results on an online social network
US9460215Apr 22, 2014Oct 4, 2016Facebook, Inc.Ranking recommended search queries on online social networks
US9465848Apr 11, 2014Oct 11, 2016Facebook, Inc.Detecting social graph elements for structured search queries
US9471692Dec 29, 2015Oct 18, 2016Facebook, Inc.Search query interactions on online social networks
US9477760Feb 12, 2014Oct 25, 2016Facebook, Inc.Query construction on online social networks
US9483803Dec 29, 2015Nov 1, 2016Facebook, Inc.Search intent for queries on online social networks
US9495354Dec 29, 2015Nov 15, 2016Facebook, Inc.Using inverse operators for queries on online social networks
US9507876Oct 6, 2014Nov 29, 2016Facebook, Inc.Constructing queries using query filters on online social networks
US9514218Sep 18, 2014Dec 6, 2016Facebook, Inc.Ambiguous structured search queries on online social networks
US9514230Jul 30, 2013Dec 6, 2016Facebook, Inc.Rewriting search queries on online social networks
US9514477Jul 10, 2013Dec 6, 2016AVG Netherlands B.V.Systems and methods for providing user-specific content on an electronic device
US9563365Apr 30, 2012Feb 7, 2017Kip Cr P1 LpSystem and method for using a memory buffer to stream data from a tape to multiple clients
US9582552Jul 20, 2015Feb 28, 2017Facebook, Inc.Sharing search queries on online social networks
US9589011Jul 20, 2015Mar 7, 2017Facebook, Inc.Dynamic suggested search queries on online social networks
US9594850 *Oct 10, 2014Mar 14, 2017Sri InternationalMethod and system utilizing a personalized user model to develop a search request
US9594852Oct 28, 2015Mar 14, 2017Facebook, Inc.Filtering suggested structured queries on online social networks
US9600531 *Apr 10, 2013Mar 21, 2017Google Inc.Method and system for generating search shortcuts and inline auto-complete entries
US9602965Nov 6, 2015Mar 21, 2017Facebook, Inc.Location-based place determination using online social networks
US9633121Aug 1, 2014Apr 25, 2017Facebook, Inc.Personalizing default search queries on online social networks
US9646055Apr 3, 2014May 9, 2017Facebook, Inc.Blending search results on online social networks
US9665615Oct 24, 2012May 30, 2017Microsoft Technology Licensing, LlcSearch-as-you-type on a relational database
US9679024Dec 1, 2014Jun 13, 2017Facebook, Inc.Social-based spelling correction for online social networks
US9679078May 21, 2014Jun 13, 2017Facebook, Inc.Search client context on online social networks
US9679080Jun 26, 2015Jun 13, 2017Facebook, Inc.Grammar model for structured search queries
US9684695Jun 6, 2016Jun 20, 2017Facebook, Inc.Ranking test framework for search results on an online social network
US9690826Oct 17, 2016Jun 27, 2017Facebook, Inc.Using inverse operators for queries
US9690872Mar 17, 2016Jun 27, 2017Facebook, Inc.Modifying structured search queries on online social networks
US9697291Oct 17, 2016Jul 4, 2017Facbook, Inc.Search query interactions
US9703844Mar 14, 2013Jul 11, 2017Facebook, Inc.Search result snippets for structured search queries
US9703859Aug 27, 2014Jul 11, 2017Facebook, Inc.Keyword search queries on online social networks
US9703870Nov 5, 2014Jul 11, 2017Facebook, Inc.Social-based optimization of web crawling for online social networks
US20060130098 *Dec 15, 2004Jun 15, 2006Microsoft CorporationSearching electronic program guide data
US20080270379 *Aug 30, 2006Oct 30, 2008Affle LimitedOnline Search System, Method and Computer Program
US20090089368 *Sep 22, 2008Apr 2, 2009International Business Machines CorporationAutomating user's operations
US20090132498 *Nov 12, 2008May 21, 2009Canon Kabushiki KaishaInformation processing apparatus, information processing system, processing method thereof, and recording medium
US20090234824 *Oct 16, 2008Sep 17, 2009International Business Machines CorporationBrowser Use of Directory Listing for Predictive Type-Ahead
US20090282035 *May 9, 2008Nov 12, 2009Microsoft CorporationKeyword expression language for online search and advertising
US20090288035 *May 15, 2008Nov 19, 2009Microsoft CorporationScrollable views in a client/server application
US20090327468 *Jun 30, 2008Dec 31, 2009International Business Machines CorporationInteractive Remote Command Execution Over a Stateless Client/Server Network Protocol
US20100077343 *Sep 24, 2008Mar 25, 2010Thomas UhlMethod and system for navigating between pages
US20100094710 *Apr 26, 2006Apr 15, 2010Affle LimitedMethod and apparatus to provide information and consumer-acceptable advertising via data communications clients
US20100110099 *Nov 6, 2008May 6, 2010Microsoft CorporationDynamic search result highlighting
US20100205023 *Oct 8, 2009Aug 12, 2010Digiboo LlcSystem and method for distributing digital content
US20100275109 *Apr 22, 2009Oct 28, 2010Microsoft CorporationEfficient discovery, display, and autocompletion of links to wiki resources
US20100287170 *May 8, 2009Nov 11, 2010Microsoft CorporationInstant answers and integrated results of a browser
US20110029500 *Oct 28, 2009Feb 3, 2011Novell, Inc.System and method for floating index navigation
US20110066723 *Mar 18, 2009Mar 17, 2011Civolution B.V.Generating statistics of popular content
US20110154193 *Dec 21, 2009Jun 23, 2011Nokia CorporationMethod and Apparatus for Text Input
US20110320472 *May 10, 2011Dec 29, 2011International Business Machines CorporationComplex query handling
US20120078859 *Sep 27, 2010Mar 29, 2012Ganesh VaitheeswaranSystems and methods to update a content store associated with a search index
US20120311480 *Jan 24, 2011Dec 6, 2012Michael CohenType and select data input field
US20130024494 *Jun 13, 2011Jan 24, 2013Steven GuarrieriMethods and systems for platform optimized design
US20130046855 *Aug 16, 2011Feb 21, 2013Changhao JiangAggregating Plug-In Requests for Improved Client Performance
US20130046878 *Aug 15, 2011Feb 21, 2013Lukas FrycAsynchronous request interception for testing a request life-cycle
US20130067349 *Sep 12, 2011Mar 14, 2013Microsoft CorporationEfficiently providing data from a virtualized data source
US20130132376 *Jan 16, 2013May 23, 2013Facebook, Inc.Intelligent client capability-based results related to a character stream
US20130282749 *Apr 23, 2012Oct 24, 2013Yahoo! Inc.Instant search results with page previews
US20130282800 *Feb 3, 2011Oct 24, 2013Thomson LicensingSystem and method for video distribution over internet protocol networks
US20140019476 *Sep 16, 2013Jan 16, 2014Canon Kabushiki KaishaInformation processing apparatus, information processing system, processing method thereof, and recording medium
US20140082047 *Sep 14, 2012Mar 20, 2014Sap AgBusiness Application Platform With Embedded Business Intelligence Server
US20150033177 *Feb 25, 2013Jan 29, 2015Alcatel LucentSystem and method for inputting symbols
US20150046435 *Oct 10, 2014Feb 12, 2015Sri InternationalMethod and System Utilizing a Personalized User Model to Develop a Search Request
US20150134642 *May 30, 2013May 14, 2015Chomley Consulting Pty. LtdMethods, controllers and devices for assembling a word
US20150193393 *Sep 1, 2011Jul 9, 2015Scott R. VioletDynamic Display of Web Content
US20160034163 *Mar 6, 2014Feb 4, 2016Audi AgDevice associated with a vehicle and having a spelling system with a delete button and/or list selection button
EP2571232A4 *May 9, 2011Dec 16, 2015Ntt Docomo IncInformation processing device, information processing method, and program
EP2629209A1 *Feb 17, 2012Aug 21, 2013Research In Motion LimitedSystem and method of sharing previously-associated application data from a secure electronic device
WO2013015811A1 *Jul 28, 2011Jan 31, 2013LexisnexisSearch query generation using query segments and semantic suggestions
WO2014066186A1 *Oct 18, 2013May 1, 2014Microsoft CorporationSearch-as-you-type on a relational database
WO2015006049A1 *Jun 25, 2014Jan 15, 2015AVG Netherlands B.V.Systems and methods for providing user-specific content on an electronic device
Classifications
U.S. Classification709/203, 707/E17.108, 715/773
International ClassificationG06F15/16, G06F3/048
Cooperative ClassificationG06F3/04886, G06F3/0481, G06F17/30864, G06F15/16
European ClassificationG06F17/30W1
Legal Events
DateCodeEventDescription
Sep 17, 2008ASAssignment
Owner name: MASTEROBJECTS, INC., CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:SMIT, MARK H.;REEL/FRAME:021545/0333
Effective date: 20080818