Mutable application experience and user interface

A dynamic and interchangeable set of application behaviors is implemented upon the same underlying software engine. Downloadable data provider behavior descriptors configure the UI generation application dynamically on demand to meet needs that are unknown at ship time, or otherwise cannot be predicted in advance—inputs, formats, contents, and the optimal user interface or experience, all change over time. A data provider supplies the data source locations, data feeds, poll/pull intervals on feeds, parameter definitions, data binding definitions, lists, groups, UI templates, data transformation logic, resources, and UI templates to plug into the base application engine, which transforms the supplied data to create a UI experience tailored to match the appropriate events and available data over time. The base application engine is agnostic to both the data provider and the input data received.

BACKGROUND

Events and data for content and format are unable to be fully predicted in advance. Generally applications for processing data and the related user interfaces (UI) are developed as static engine code shipped with the product. Any changes to the application or UI must be made through the download and installation of updates to the static application code. In the case of applications for presenting information related to live events, for example, news events and sports, there is no ability to react to changing events and input data over time (e.g., in the sports metaphor, seasons, teams, leagues, players, scores, game events, etc.). There is further no ability to change the application to respond to changing external business conditions or rules (e.g., legal deals or prohibitions, etc.). Traditional patching mechanisms are infrequent, not dynamic enough, involve high overhead to develop the software update, and require procedures such as restarting the entire computer. A static, pre-constructed application thus offers users a sub-optimal experience or, in some cases, none at all.

SUMMARY

A dynamic and interchangeable set of application behaviors is implemented up on the same underlying software engine. Downloadable data provider behavior descriptors configure the UI generation application dynamically on demand to meet needs that are unknown at ship time, or otherwise cannot be predicted in advance. The list of inputs, their format and contents, and the optimal user interface or experience, all change over time. The data provider supplies the data source locations, data feeds, poll/pull intervals on feeds, parameter definitions, data binding definitions, lists, groups, data transformation logic, resources, and UI templates to plug into the base application engine, which transforms the supplied data to create a UI experience tailored to match the appropriate events and available data over time. The base application engine is agnostic to both the data provider and the input data received. The base application takes on an identity defined by the data provider, including appearance, functionality, and content.

This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter. Other features, details, utilities, and advantages of the claimed subject matter will be apparent from the following more particular written Detailed Description of various embodiments and implementations as further illustrated in the accompanying drawings and defined in the appended claims.

DETAILED DESCRIPTION

A dynamic application platform100for implementing an exemplary configuration of a mutable application experience is depicted inFIG. 1. The platform100is composed, in part, of a media processing device102in which several modules may operate to provide the mutable application experience. The media processing device102may be a personal computer configured to run a multi-media software package, for example, the Windows® XP Media Center Edition operating system (Microsoft Corporation, Redmond, Wash.). In such a configuration, the personal computer effectively operates to integrate full competing functionality within a complete home entertainment system.

The media processing device102may also include other components, for example: a personal video recorder (PVR) to capture live television show for future viewing or to record the future broadcast of a single program or series; a compact disc (CD) or digital video disc (DVD) drive for disc media playback; a media drive for integrated storage of and access to a users recorded content, e.g., television shows, music pictures, and home video; and an electronic program guide (EPG). Instead of a conventional personal computer, the media processing device102may be provided by an alternate hardware device capable of storing and distributing media content including, for example, a notebook or portable computer, a tablet computer, a workstation, a main frame computer, a server, an internet appliance, a handheld device, or combinations thereof. The media processing device102may also be a set-top box, primarily used for receiving and tuning cable or satellite television signals, but which may additionally be connected within a network to operate as a media processing device102.

The media processing device102may include a binding engine module104and a user experience engine module106. The binding engine module104may be considered the base or core application within the platform100. The binding engine104is agnostic to any particular type of data or source of data that it processes. The purpose of the binding engine104is to collect data of various types and forms from one or more data providers and bind the data to management objects. The management objects may then be used by the user experience engine106to create a particular application experience for a user through a UI output to a presentation device108. The presentation device108may be a television, a computer monitor, a display panel, or any other visual presentation device and may further include audio output devices such as speakers.

The data collected by the binding engine104may include any kind of data that may be formatted for presentation in a UI. For example, in one implementation the data may relate to live sporting events. The data received and processed by the binding engine104may be in the form of scores, game status, player statistics, team statistics, real-time player actions, audio clips, video clips, and any other data that may be formatted for presentation to a user. It should be apparent that the data received by and processed by the binding engine104need not be limited to sports data, but may comprise data related to any topic available for presentation, for example, data related to other live events, movies, and standard television shows.

The binding engine104may be connected to a network110, for example, the Internet, through which it accesses receives the various types of data for processing. The data may be generated by one or more data providers112,114, that are similarly connected to the network110. The data providers112,114may be alternate sources of similar data, e.g., competing sports networks, or they might provide data relating to wholly different subject matters that may be alternately displayed in the mutable application experience. Continuing with the sports theme as an exemplary implementation, the first data provider112may be the ESPN network, which provides information about sporting events that it is contemporaneously monitoring. A second data provider114may be, for example, Fox Sports Net, which may provide alternate sports information related to the events in its broadcasting schedule.

Additionally, a data transform package116may be transmitted or accessed across the network110by the binding engine104. The media processing device102may use the data transform package116to transform data received in various forms into a data that is manageable by the binding engine104. For example, the data from a first data provider112, e.g., ESPN, may be in a data format particularly developed by ESPN. The ESPN data may be formatted differently than similar data developed by a second data provider114, e.g., Fox Sports Net. In this case, the data transform package116provides the necessary instructions and functions to transform both the information received from the first data provider112and the information in the different format provided by the second data provider114into a common data format understood by the binding engine104.

For example, the information provided by the first data provider112may be coded in a first extensible mark-up language (XML) format while data from the second data provider114is provided in a second XML format. The data transform package116may contain an extensible style-sheet language transform (XSLT) to transform the data from its original format into a common format recognizable by the binding engine104. XSLT is an XML-based language used for the transformation of XML documents, e.g., to convert data between different XML schemas. The original document is not changed; rather, a new document is created based on the content of an existing one.

In an alternate implementation, the data transformation may be provided by a service accessible over the network. The data transform service may reformat the data received from the data providers112,114in a format that is readably usable and recognizable by the binding engine104. This implementation may be less desirable as receipt of the transformed data from a network service may reduce the bandwidth of the network connection. Generally, the processing speed of the media processing device102and standard software platforms installed thereon are more than adequate to handle such XML transforms.

In addition to the content-related data received from the data providers112,114, the media processing device102may further receive a library package118of UI elements from an external source over the network110. The UI elements may include UI templates, graphics, images, video clips, audio clips, and other resources for combination and presentation in the mutable UI. Many of the UI templates may incorporate the data as it is received and exposed in real time. The UI library package118may be developed by the data providers112,114or by any other developer of UIs for the media processing device102. The UI library package118may be received directly by the media processing device102where the UI elements are stored until accessed for linking with data exposed by the binding engine104. The UI elements are arranged into the desired layout of the UI by the user experience engine106for presentation with the incorporated data on the presentation device108.

Various exemplary components of a media processing device200are shown in greater detail inFIG. 2. As inFIG. 1, the primary components of the media processing device200include the binding engine202and the user experience engine204. An additional component of the binding engine202not previously discussed, may be a network monitor206. Receipt of the data transform package208and the provider data110are coordinated by the network monitor206. The network monitor206acts as a manager for various data feeds that may be received from various data providers. Data feeds may be received via any of several known push protocols (e.g., Really Simple Syndication (RSS)). Alternatively, the network monitor206may function as a timer to regularly pull data from known locations accessible via the network. For example, the data transform package208may be updated regularly, but is not a constant-feed data source as may be received from the data providers. Thus, the network monitor206may query the source location for the data transform package208on a regular schedule, for example, once a day in the middle of the night in order to minimize the effect on network bandwidth. If a request to the source location confirms that a new data transform package208is available, the network monitor206may initiate and coordinate download of the updated data transform package208.

The data transform package208may be understood as a set of rules or functions that are provided to the binding engine202in order to direct the transformation of the provider data210into a format that can be used by the binding engine202. In one exemplary implementation, the provider data210may be provided as groupings of tagged data values, for example, data values identified using extensible mark-up language (XML). The provider data210tagged in such an XML schema provides a simple mechanism for data providers to identify the type and nature of data values transmitted to the media processing device200. An exemplary XML schema for tagging provider data220in the context of sports related data is set forth below.

This schema may be specific to a particular data provider. In the context of the sports example, the transform data may consist of game scores, player statistics, identification of players presently in the game, player rosters, game statistics, news alerts, and other real-time alerts associated with a particular sporting event. As in the above example, XML schema data related to NFL football may be tagged with various data types. As expressed above, the data may include information about player positions (e.g., who is actually playing the position), player statistics (e.g., passing attempts and related yardage), and scoring at various stages of the game as well as a final score. The data may also include a variety of real-time alerts as indicated, for example, touchdown occurrences and the type of play used to score (e.g., rushing, passing, or punt return).

The data transformation engine212may be a separate standalone module or it may be a standard part of particular operating system, for example, the “.NET” platform from Microsoft Corporation. The data transform package208is input into the data transform engine212to provide a framework and instructions for processing the provider data210. The data transform engine212first processes the data transform package208to determine the appropriate data feed transforms for processing the provider data210. The data transform engine212may employ standard transform scheme for example, an extensible style-sheet language transform (XSLT) in order to provide data in a format useful to the binding engine202. In an alternate implementation, the binding engine202may unpack the instructions in the data transform package208, e.g., in the form of an XSLT document, and takes the incoming provider data210, e.g., in the form of an XML document, and supplies both as inputs to the data transform engine212, e.g., a .NET runtime engine. Once the data feed transforms214are understood, the data transform engine212can read the data feed descriptors216, for example, XML tags that identify specific data types in the provider data210, and then transform the data feed descriptors into a descriptor format used by the binding engine202.

The data transform engine212may further develop data object lists218to pass to the binding engine202. The data object lists218may be understood as linking instructions that tell the binding engine202how to bind230the provider data210to particular data management objects228in the binding engine202. Once the transformation of the provider data210within the data transform engine212is complete, the transformed data is loaded back into the binding engine202as indicated by the operational loading indicator220inFIG. 2. When the transformed data is loaded220into the binding engine202from the data transform engine212, it may be organized by a provider manager222according to the data object lists218. In one implementation, the data object lists218may organize the transformed data220according to the particular data provider source226a,226b,226n.

This type of organization by data provider may be desirable, for example, because different providers of similar information may provide different types or categories of information. Further, the associated display instructions and UI templates and resources may be particular to that data provider. Alternatively, the data from different data providers may be relevant to completely unrelated subject matter designed to provide a completely different application experience to a user. For example, one data provider may provide only information related to sporting events, while a second data provider may provide information related to the Academy Awards ceremony. In this scenario, one can understand that the ultimate UI experiences are likely to be significantly different.

As shown in the provider manager222inFIG. 2, in addition to separation and organization of the data into different data provider sources226a,226b,226n, a generic null data provider block224may be used. The null data provider block224may be selected by the binding engine202to provide a generic or default UI experience when the program is initialized. This allows the user to select between any of the other application experiences specific to the available data providers226a,226b,226nand provides an opportunity for the media processing devices to load the relevant data in a selected UI. The UI corresponding to the null data provider block224thus dynamically changes into a revised UI242experience corresponding to the chosen data provider. Note, however, the revised UI242does not result from the launch of a separate application. The revised UI242is prepared by the user experience engine204from alternate data and instructions exposed by the binding engine202and alternate UI templates236and resources238selected from the dynamic UI library234as further described below.

The binding engine202may also use the data object lists218to instantiate appropriate data management objects228that bind230with the transformed data in particular arrangements defined by the data management objects228. The data management objects228represent the primary functionality of the binding engine202and perform operations to collect and group together additional information related to a particular type of provider data210received from a data provider.

These binding operations may be better understood again in the context of a sports media example. Suppose, for example, that a data provider provides a data feed with the score of a NBA basketball game. The data feed may include the names of the teams, the quarter presently being played, and the score. Upon receipt of this data, the binding engine202will select an appropriate data management object228to bind with the data. For example, there may be a particular data object that is designed to manage NBA basketball games. The NBA game object may have further associated behaviors for the collection of additional related information. For example the NBA game object may use team ID information in the data to seek out additional information about the teams to bind with the NBA game object. This information could include things like the team rosters, game schedules, and win/loss record information. The NBA game object may look for this information within the other data in the present data feed or it may instruct the network monitor206to seek out additional information over the network in order to fulfill such data requests. The NBA game object may further consult an EPG guide on the media processing device200to provide information about any relating programming, for example, whether a broadcast network is presently carrying the game.

The NBA game object may further instantiate other related management objects228to seek additional information for possible presentation to a user. For example, the NBA game object may instantiate a NBA league object that seeks information at a league level rather than a game level in either the provider data210or through requests of the network monitor206. Such information could include the regular season schedule for the entire league or team standings. The NBA league object could further consult the EPG for a schedule of network broadcasts of any NBA game within a certain time frame. Any relevant data that the NBA league object finds may be bound to the NBA league object by the binding engine202. The NBA game object may further instantiate a player object which seeks data regarding individual players on the teams participating in the particular game, for example, player names, player statistics, and news items regarding particular players, and can bind such data within the object.

Alternatively, any new data found may not actually be bound, but rather looked up when needed by an object itself or by another object, e.g., a “collection manager” object managing a list of league objects. The link to the extra information may be provided by an object via runtime-accessible properties and methods, but the object itself may or may not cache or store that additional data.

Once the appropriate data management objects228are bound230with transform data specific to one of the particular data providers226a,226b,226n, the populated data management objects228and any UI instructions related to a particular data provider are exposed232to the user experience engine204. The user experience engine204queries the dynamic UI library234and requests the appropriate UI templates236for building a UI particular to the chosen data provider based upon the associated UI instructions232. The user experience engine204further requests any additional resources and images238, for example, music, pictures, logos, and other presentation information responsive to the UI instructions232.

Recall that the dynamic UI library234may be regularly updated with packages of new or changed templates236and new and alternative resources, images, or other presentation information238. The UI templates236may be authored by the data providers and may thus include identification information and function calls for associating specific UI templates236and resources238with the bound data objects232related the particular data provider. Thus, the UI242presented to the user may be dynamically changed and updated whenever desired. The user experience engine204then combines the data exposed by the data management objects228with the appropriate UI templates236and, in conjunction with the resources and images238, creates a UI242unique to the data provider for presentation to the user.

It should be understood that the provider data210may be constantly received at the media processing device200or requested by the network monitor206in order to provide real-time data for presentation within the UI242. This real-time aspect of presentation of data may be particularly important or desirable in the context of an application experience presenting sports related information. Data pertaining to live sporting events is constantly in flux and may be regularly updated. For example, scores constantly change; players are constantly substituted; game status changes as it progresses into new innings, periods, or quarters; and statistics related to individual teams, players, and even leagues change as each game progresses. Thus, the binding engine202constantly binds the data management objects228with update transformed data220from the data feeds and exposes232data management objects228bound with updated data to the user experience engine204. Similarly, the selected UI templates236may be regularly updated and output for presentation as part of the UI242.

FIG. 3depicts an exemplarily UI generation process for creating a mutable application experience on a media processing device, for example, as described with respect toFIGS. 1 and 2. The UI generation process300begins with a requesting operation302in which the network monitor requests provider data and monitors data feeds from data providers. In a receiving operation304, data is received or downloaded from a particular data provider for use in creating the application experience. As previously indicated, the data is transformed in a transformation operation306by a data transform engine in order to provide the data in a format that the binding engine can use. Once the data is transformed, it is bound with the data management objects in a binding operation308. The data management objects then proceed to build structures of associated data from additional available data, incoming data feeds, EPG schedules, and other data sources in building operation310. In addition, as previously indicated the building operation310may include the instantiation of additional related management objects that collect and provide additional related data for exposure and potential presentation to a user. Once the data management objects have linked with all available related data, the data management objects are exposed to the user experience engine in exposing operation312.

In parallel with the transformation and linking of provider data, the UI generation process300also includes receiving UI templates and related resources as part of a UI library package in receiving operation314. The UI templates and resources are stored in a dynamic UI library associated with the binding engine in storing operation316. The user experience engine then links the data from the data management objects with related and appropriate UI templates in order to construct a custom UI associated with the data in linking operation318.

In one exemplary implementation, the user experience engine may interrogate the data management objects in a search for particular designations for rendering a particular UI, e.g., a incorporating a UI template unique to a particular data provider as shown in query operation318. If a unique UI is specified, the user experience engine will select that specific UI template from the dynamic UI library in selecting operation320. Alternatively, if no specific UI template is requested, then the user experience engine may select a default template to handle the types of data exposed by the data management objects and arrange them for presentation as indicated in selecting operation322. Once the appropriate UI templates, associated resources, and images are selected, a UI is compiled and output for presentation on a presentation device in outputting operation324. The UI generation process300then iterates and returns to requesting operation302to monitor the data feeds and update the information that is ultimately presented to the user in outputting operation324.

FIGS. 4 and 5show one example of how the process ofFIG. 3may be implemented to create a mutable application experience for a user.FIG. 4depicts a first implementation400of a UI402presenting sport scores information. The UI402includes a pivot menu element404, a ticker element408, and an alert element410. The pivot menu element is a horizontal scrolling menu UI element. In this particular example, several professional sports leagues are available for selection to view related sport scores. In the example depicted, the NBA is selected406and the ticker408provides information about a basketball game between the Cleveland Cavaliers and the Detroit Pistons. The ticker shows that with 11 minutes and 17 seconds expired in the second quarter, the Cavaliers are besting the Pistons by a score of 24 to 21. Note that the information in the ticker408may be updated on a regular and frequent basis with information from a data feed as the score of the basketball game changes from minute to minute. In addition, an alert template410provides information identifying the best performing players in the game at any given moment. In this implementation, the alert template410is populated with the highest scoring player, his team, and the number of points scored; the player with the most rebounds, his team, and the number of rebounds made; and the player with the most assists, his team, and the number of assists made. Again this information may vary from moment to moment, and the alert template410and the UI402will be constantly updated to reflect any changes. In addition, one or more logos412may be presented within the UI402to identify a network partner or data provider providing the information. Again, such logos or other images are entirely mutable and may be changed based upon the data or UI instructions received.

FIG. 5depicts a second implementation500of UI502for presentation of professional sport scores and information. Again the UI502depicts a pivot menu504, a ticker508, and an alert510. As inFIG. 4the NBA is selected506on the pivot menu and the ticker508displays information about the Cavaliers and Pistons game. As noted in the ticker508, the game has progressed a little over a minute and the Cavaliers are now beating the Pistons 28-21. Thus, the data indicating the time lapse in the game as well as the scores has been updated via a data feed processed by the binding engine. In addition, the ticker508has also been updated in its presentation format as the period indication no longer says “2ND QTR” as inFIG. 4and now only says “2ND.”

Similarly, the alert510is based on a completely different template than the alert inFIG. 4. The alert510presents information regarding the most recent play in the game that has been provided in the data feed. In this case the last play alert510indicates the time the play was made, the team making the play, the player making the play, and the action performed, in this case a 2 point field goal by LeBron James. Notice the disparity in the time of the play as opposed to the time the ticker shows along with the present score. This disparity may be a normal occurrence with respect to data feeds from sporting events in which it is much easier to quickly update a score than it is to input data regarding actual occurrences within the game. As before, a graphic512such as a logo of the data provider may be presented as part of the UI502. Again, it is notable that the UI experience has been changed betweenFIGS. 4 and 5. However, the underlying applications creating the user experience, i.e., the binding engine and the user experience engine, are completely agnostic to the data received and the UI templates provided; their functions remain the same while the UI may be varied widely.

FIGS. 6 and 7provide another example of mutable application experiences that may be provided to a user. In these examples, application experiences may be understood as particular to different data providers. InFIG. 6, a first form of the application experience600for a first data provider is rendered in the UI602. At the top of the UI602is a pivot menu604, beneath which is program gallery606. The program gallery606generally provides the user a selection of programs for viewing. In this implementation of the UI602, the program gallery606is constructed using a series of game tickers in addition to more standard types of gallery objects such as the program identifier blocks630,632. The selected ticker608identifies a baseball game currently in progress. Instead of merely indicating the game is available for viewing, the tickers in the gallery606provide additional real-time information about the games in progress.

The selected ticker608identifies the teams playing in the team column610and the score of the game in the score column612. As this is a baseball game, the ticker608also includes an indicator614to indicate whether it is the top or bottom of a particular inning and an inning indicator616identifying the present inning. Additionally, the ticker608includes an out status indicator615, in this case indicating that there are two outs, and a on-base indicator618, in this case showing the runners presently at first base and third base. Clearly, such a gallery using a ticker with real-time information provides significantly more information about the status of a live event than merely indicating that the program is available to watch.

A second ticker620for a baseball game also indicates the teams, the score, the top or bottom of the inning, the inning number, the number of outs, and the base-running status. This game may also be available for viewing if the user so selects. This is the last of the baseball games for viewing in the program gallery606.

Another ticker622indicates that a basketball game is available for viewing, which is further indicated by the NBA heading in the pivot menu604. The basketball ticker622is based upon a different gallery UI template then the baseball games. The basketball ticker622includes a team name column624, a score column626, and period indication column628. No additional information about the basketball game is included in the basketball ticker622.

The UI further includes an alert item634providing headline information related to sports programming available. In addition to the alert634, there is a related link636that, upon selection, will access and present to the user additional information related to the alert634, for example, a full news story related to the headline in the alert634. A logo638indicating the particular data provider or network partner associated with the information in this application experience600may also be provided in the UI602.

In this particular implementation of the UI602and in conjunction with this particular data provider is an instructional UI640that teaches a user how to operate the pivot menu604and the program gallery606to make a program selection from the gallery606for viewing. An instructional message642may accompany the graphical image640to aid in explaining how to select a program from the gallery for viewing. This particular UI602additionally includes a marketing message644for presentation to a user.

In contrastFIG. 7provides an alternate application experience700in a modified UI702associated with a different data provider than the data provider inFIG. 6. The UI702similarly provides a pivot menu704with a program gallery706for selection of various sports programs for viewing. At the tope of the UI702is a pivot menu704, beneath which is program gallery706. In this implementation of the UI702, the program gallery706is constructed using a series of game tickers708in addition to more standard types of gallery objects such as the program identifier blocks730,732. As above, the selected ticker708identifies a baseball game currently in progress. Instead of merely indicating the game is available for viewing, the selected ticker708in the gallery706provides additional real-time information about the game in progress.

The selected ticker708identifies teams playing in the team column710and the score of the game in the score column712. As this is a baseball game, the ticker708includes an indicator714to indicate whether it is the top or bottom of a particular inning and an inning indicator716identifying the present inning. Additionally, the ticker708includes an out status indicator715, in this case indicating that there are two outs, and an on-base indicator718, in this case showing the runners presently at first and third.

A second ticker720for a baseball game also indicates the teams, the score, the top or bottom of the inning, the inning number, the number of outs, and the base-running status. This game may also be available for viewing if the user so selects. This is the last of the baseball games for viewing in the program gallery706. Another ticker722indicates that a basketball game is available for viewing, which is further indicated by the NBA heading in the pivot menu704. The basketball ticker722is based upon a different gallery UI template than the baseball games. The basketball ticker722includes a team name column724, a score column726, and period indication column728. In this respect the user application experience for the second data provider is similar to the experience provided by the first data provider as they may have both selected standard pivot menu and program gallery UI templates for implementation.

However, the remainder of the UI702inFIG. 7is somewhat different than the UI602inFIG. 6. For example, the alert734, although providing similar information to the alert inFIG. 6, is actually different textually, because the source of the data is different. The UI702still allows the user to select a link736to read more information corresponding to the alert734. A data provider or network partner logo738is also presented, but it is in a different location than the logo placement inFIG. 6and also indicates the source as a different provider. Finally, instead of providing a tutorial on program selection from the program gallery, the UI702presents a large graphic740branding this particular implementation of the user experience.

An exemplary hardware and operating system for implementing a mutable application experience as described above is represented inFIG. 8. The system includes a general purpose computing device in the form of a computer800, including a processing unit802, a system memory804, and a system bus818that operatively couples various system components, including the system memory804to the processing unit802. There may be only one or there may be more than one processing unit802, such that the processor of computer800comprises a single central processing unit (CPU), or a plurality of processing units, commonly referred to as a parallel processing environment. The computer800may be a conventional computer, a distributed computer, or any other type of computer; the invention is not so limited.

The system bus818may be any of several types of bus structures including a memory bus or memory controller, a peripheral bus, a switched fabric, point-to-point connections, and a local bus using any of a variety of bus architectures. The system memory804may also be referred to as simply the memory, and includes read only memory (ROM)806and random access memory (RAM)805. A basic input/output system (BIOS)808, containing the basic routines that help to transfer information between elements within the computer800, such as during start-up, is stored in ROM806. The computer800further includes a hard disk drive830for reading from and writing to a hard disk, not shown, a magnetic disk drive832for reading from or writing to a removable magnetic disk836, and an optical disk drive834for reading from or writing to a removable optical disk838such as a CD ROM or other optical media.

The hard disk drive830, magnetic disk drive832, and optical disk drive834are connected to the system bus818by a hard disk drive interface820, a magnetic disk drive interface822, and an optical disk drive interface824, respectively. The drives and their associated computer-readable media provide nonvolatile storage of computer-readable instructions, data structures, program modules and other data for the computer800. It should be appreciated by those skilled in the art that any type of computer-readable media that can store data that is accessible by a computer, for example, magnetic cassettes, flash memory cards, digital video disks, RAMs, and ROMs, may be used in the exemplary operating environment.

A number of program modules may be stored on the hard disk830, magnetic disk832, optical disk834, ROM806, or RAM805, including an operating system810, one or more application programs812, other program modules814, for example, the binding engine and the user experience engine, and program data816, for example, the data feeds from the data providers, the data transform packages, and the UI library packages.

A user may enter commands and information into the personal computer800through input devices such as a keyboard840and pointing device842, for example, a mouse. Other input devices (not shown) may include, for example, a microphone, a joystick, a game pad, a tablet, a touch screen device, a satellite dish, a scanner, a facsimile machine, and a video camera. These and other input devices are often connected to the processing unit802through a serial port interface826that is coupled to the system bus818, but may be connected by other interfaces, such as a parallel port, game port, or a universal serial bus (USB).

A monitor844or other type of display device is also connected to the system bus818via an interface, such as a video adapter846. In addition to the monitor844, computers typically include other peripheral output devices, such as a printer858and speakers (not shown). These and other output devices are often connected to the processing unit802through the serial port interface826that is coupled to the system bus818, but may be connected by other interfaces, such as a parallel port, game port, or a universal serial bus (USB). A media tuner module860may also be connected to the system bus818to tune audio and video programming (e.g., TV programming) for output through the video adapter846or other presentation output modules.

The computer800may operate in a networked environment using logical connections to one or more remote computers, such as remote computer854. These logical connections may be achieved by a communication device coupled to or integral with the computer800; the invention is not limited to a particular type of communications device. The remote computer854may be another computer, a server, a router, a network personal computer, a client, a peer device, or other common network node, and typically includes many or all of the elements described above relative to the computer800, although only a memory storage device856has been illustrated inFIG. 8. The logical connections depicted inFIG. 8include a local-area network (LAN)850and a wide-area network (WAN)852. Such networking environments are commonplace in office networks, enterprise-wide computer networks, intranets and the Internet, which are all types of networks.

When used in a LAN850environment, the computer800may be connected to the local network850through a network interface or adapter828, e.g., Ethernet, a wireless access point or router, or other communications interfaces. When used in a WAN852environment, the computer800typically includes a modem848, a network adapter, WiFi card, or any other type of communications device for establishing communications over the wide area network852. The modem848, which may be internal or external, is connected to the system bus818via the serial port interface826. In a networked environment, program modules depicted relative to the personal computer800, or portions thereof, may be stored in a remote memory storage device. It is appreciated that the network connections shown are exemplary and other means of and communications devices for establishing a communications link between the computers may be used.

The technology described herein may be implemented as logical operations and/or modules in one or more systems. The logical operations may be implemented as a sequence of processor-implemented steps executing in one or more computer systems and as interconnected machine or circuit modules within one or more computer systems. Likewise, the descriptions of various component modules may be provided in terms of operations executed or effected by the modules. The resulting implementation is a matter of choice, dependent on the performance requirements of the underlying system implementing the described technology. Accordingly, the logical operations making up the embodiments of the technology described herein are referred to variously as operations, steps, objects, or modules. Furthermore, it should be understood that logical operations may be performed in any order, unless explicitly claimed otherwise or a specific order is inherently necessitated by the claim language.