Branch Prediction for User Interfaces in Workflows

Abstract

Systems, methods, and other embodiments related to branch prediction in a workflow are described. In one embodiment, the method includes inputting a workflow and sequentially progressing the workflow in a flow sequence. In response to the flow sequence encountering a first decision element in the workflow, the first decision element having multiple branch paths, (i) performing prediction to predict a resulting path of the first decision element to predict, from a plurality of user interfaces, a first user interface that may be encountered later in the flow sequence as part of a first terminal element, and (ii) pre-constructing the predicted first user interface before encountering the first terminal element. In response to the flow sequence reaching the first terminal element, the method includes displaying the pre-constructed first user interface on a display device.

Description

Background Art

[0001] Background A workflow is a computerized structure that defines a series of actions to be executed sequentially and completed. Generally, a workflow can be created to correspond to a specific process or task. A workflow can be visually represented as a flowchart or tree structure that includes multiple branches of possible paths that can be traversed during execution until an end point is reached. A workflow includes decision elements that control the execution of the workflow and determine which branch path to take. Ultimately, the execution path lands on one of many possible workspace elements that initiate or execute an action.

[0002] User-defined workflows can be arbitrarily complex. The more elements a workflow has and the more complex the workflow is, the more time it takes to complete the workflow. The user and the computing device in execution require more time to sequentially traverse the workflow from the starting point to one of the multiple end points and execute the programmed actions of the workspace elements.

[0003] In prior art systems, the execution and execution time of a workflow were limited by decision elements and sequential execution along the path. The decision element waited for input data before any decision could be made and was then required to continue to the next action element along the path. For example, the decision element could be based on a specific field value on a given data record. Thus, the data record had to be retrieved via a network request and then the field value could be determined. Based on the result of the decision, the system would generate one or more separate user interfaces.

[0004] Therefore, any element within the path after the decision element could not be executed until the decision element was executed and sequential processing along the path reached that element. This resulted in a performance penalty for the system and the clients waiting on the system because the view model or view could not be constructed until data was retrieved from the data center. The processing of the workflow and subsequent display of the record values are time-critical in many high transaction environments such as call centers. Therefore, any reduction in processing time is an improvement in computer functionality. SUMMARY OF THE INVENTION MEANS FOR SOLVING THE PROBLEM

[0005] SUMMARY In one embodiment, a non-transitory computer-readable medium is disclosed, the non-transitory computer-readable medium including computer-executable instructions stored on the non-transitory computer-readable medium, the computer-executable instructions, when executed by at least a processor of a computer, causing the computer to:

[0006] Cause at least the processor to input a workflow into a memory and sequentially progress the workflow in a flow sequence, the workflow being composed of a plurality of execution paths, the plurality of execution paths including a plurality of decision elements for controlling access to different portions of the execution paths, the plurality of execution paths leading to a plurality of terminal elements associated with a plurality of user interfaces, and in response to the flow sequence encountering a first decision element within the workflow that includes a plurality of branch paths, (i) execute a prediction to predict a path resulting from the result of the first decision element and predict, from among the plurality of user interfaces, a first user interface that may be encountered later in the flow sequence as part of the first terminal element, and (ii) pre-construct the predicted first user interface before encountering the first terminal element.

[0007] In response to the flow sequence reaching a first terminal element, display a pre-constructed first user interface on a display device.

[0008] In response to the flow sequence reaching a second terminal element, discard the pre-constructed first user interface and generate a second user interface associated with the second terminal element.

[0009] In another embodiment, a computing system is disclosed, the computing system comprising at least one processor, at least one memory operably connected to the at least one memory, and a non-transitory computer-readable medium storing instructions, the instructions, when executed by at least the processor, causing the processor to perform the following.

[0010] Cause the at least one processor to input a workflow into the memory and sequentially progress the workflow in a flow sequence, the workflow being composed of a plurality of execution paths, the plurality of execution paths including a plurality of decision elements for controlling access to different portions of the execution paths, the plurality of execution paths leading to a plurality of terminal elements associated with a plurality of user interfaces, and in response to the flow sequence encountering a first decision element in the workflow that includes a plurality of branch paths, (i) perform a prediction to predict the path resulting from the result of the first decision element and predict a first user interface that may be encountered later in the flow sequence as part of the first terminal element from among the plurality of user interfaces, and (ii) pre-construct the predicted first user interface before encountering the first terminal element.

[0011] In response to the first decision element outputting a first result path leading to a predicted first user interface, a pre-constructed first user interface is displayed on a display device, and in response to the first decision element outputting a second result path not associated with the predicted first user interface, the pre-constructed first user interface is discarded and a second user interface associated with the second result path is generated.

[0012] In another embodiment, a computer-implemented method is disclosed that is executed by a computing device and a processor that executes instructions from memory, the method performing one or more combinations of functions executed by a computing system.

[0013] Brief Description of the Drawings The accompanying drawings, which are incorporated herein and constitute a part of this specification, illustrate various systems, methods, and other embodiments of the present disclosure. It will be understood that the element boundaries shown in the figures (e.g., boxes, groups of boxes, or other shapes) represent one embodiment of the boundaries. In some embodiments, one element can be implemented as multiple elements, or multiple elements can be implemented as one element. In some embodiments, an element shown as an internal component of another element may be implemented as an external component, and vice versa. Additionally, the elements may not be drawn to scale.

Brief Description of the Drawings

[0014]

Figure 1

Figure 2

Figure 3

Figure 4

[0015] Detailed Description A computer system and method are described herein that are configured to perform branch prediction in a running workflow and predict a resulting user interface from a plurality of possible user interfaces. The predicted user interface is then pre-constructed before the running workflow reaches that user interface. The system and method provide a faster response time and avoid time delays associated with a sequentially executed workflow that is sequentially dependent on and limited by decision elements. These decision elements require retrieving and loading data records to determine the results of the decision elements, after which execution proceeds along the sequential / serial processing path of the workflow to render the final user interface.

[0016] In one embodiment, the system and method remove the sequential dependency between data loading and the rendering of a customized user interface, and thus improve computer functionality over the prior art by predicting and pre-constructing the user interface in advance. Additionally, the prediction and pre-construction functions reduce processing time compared to sequential dependent processing, further improving computer functionality. As described above, in many high transaction volume environments such as call centers, the generation and display of record values by a computing system within a user interface is time critical. Thus, the reduction in processing time is an improvement in computer functionality (even if it is in milliseconds).

[0017] It should be understood that any action or function described or claimed in this specification cannot be performed by the human mind and cannot actually be done in the human mind. Any interpretation that any action or function can be performed in the human mind is not consistent with and contradicts this disclosure.

[0018] Referring to FIG. 1, an embodiment of a computing device 100 configured with a prediction system for performing branch prediction in a workflow to predict and pre-build a user interface is shown. The computing device 100 includes at least one processor 110, a memory 120, and a network interface for communicating with a remote device such as a data center database 130 and / or other remote computers (not shown). The prediction system includes a branch predictor 140 that executes on a workflow structure 150 input into the memory. As described herein, the branch predictor 140 utilizes historical data (e.g., decision element history 170) from previous paths taken at each decision element to remove sequential dependencies between data loading and rendering of the user interface. The prediction system is configured to learn and then predict an appropriate user interface that is likely to be rendered. The system then initiates pre-building of the user interface (e.g., pre-built UI 160) to reduce processing time.

[0019] In a software system having very complex and configurable logic, different user interfaces are generated and presented based on a complex data model. These data models are retrieved from a data center to generate the associated user interfaces. In one embodiment, the system and method predict the user interface that will be displayed before the data model is retrieved. Thus, the system can display the user interface more quickly when the workflow reaches the point in time when the user interface should be shown and rendered on the display. Previous technologies did not have a prediction function and simply executed sequentially according to the workflow until the operation ended in one of the possible user interface elements.

[0020] An embodiment of the operation of the prediction system of FIG. 1 will be described with reference to the exemplary workflow 200 shown in FIG. 2 and the exemplary method 300 shown in FIG. 3. First, the workflow 200 is composed of a set of exemplary elements and how the sequential operation of the workflow is executed, which will be described below. Next, following this example, a method 300 will continue to describe how this branch prediction is implemented in the workflow 200 to predict and pre-construct the user interface.

[0021] Referring to FIG. 2, the workflow 200 is composed of several decision elements and possible operations that create the workflow structure. Generally, a workflow such as the workflow 200 can be configured to have a plurality of decision elements (e.g., decision elements 205, 210, and 240) that create a plurality of paths along the workflow. The workflow may have a plurality of possible user interfaces (UIs) that can be triggered at the end of one or more of the paths. The workspace element at the end of the path is called the terminal element.

[0022] In one example, a workflow 200 implemented by a computer is defined to process data records of customer contacts in a call center. An operator who processes calls in the call center executes and navigates the workflow 200 implemented by the computer. Generally speaking, a workflow can take multiple paths with sequences of elements and actions along each path. The various directions of the workflow paths are controlled by decision elements 205, 210, 220, and 240 along the paths. Each decision element 205, 210, 220, and 240 includes logic configured to determine a result based on a value from input data.

[0023] For example, decision element 205 is configured to determine whether "last name = Smith". The determination is made by an action from an operator that initiates a network request to search for a data record from a database. In the example of the call center, the operator is working with a customer, and thus the network request is made to retrieve the data record associated with the customer involved in the workflow. Once the data record is retrieved and the data record values are loaded into memory, decision element 205 can then determine whether the "last name" field in the data record is equal to "Smith". The result of the determination guides the execution flow to an output branch along either a "Yes" branch or a "No" branch.

[0024] In the example of FIG. 2, the output result from decision element 205 can be one of two paths based on whether the determination is "Yes" or "No", leading to either decision element 210 or decision element 240, which are the next workflow elements along the sequential path. Of course, a decision element can have more possible outputs based on the decision condition and input values being tested at that decision element.

[0025] At a certain point along the workflow, the operator will navigate along a certain sequential path and end up on a terminal element. The terminal element is configured to trigger a user interface defined by the terminal element. The user interface is associated with what the operator is working on as defined by the navigated sequence within the path leading to the workflow element. In workflow 200, the terminal elements are elements 215, 230, 235, 245, and 250. In this example, the terminal elements are associated with specific customer contacts and have a user interface (UI) based on the corresponding customer contacts. When the workflow reaches a terminal element, the system knows who the customer is and retrieves the corresponding data record for that customer. Then, a customized user interface is generated and constructed with the record values for that customer. Of course, this system is not limited to workflows for customer contacts and can be implemented to generate any type of user interface based on any criteria defined by the administrator.

[0026] Referring back to decision element 205, if the decision determines that the data record contains a last name equal to "Smith", the next decision element 210 determines whether "First Name = Pat". This decision is made by comparing the value of the "First Name" field from the previously retrieved data record. If the first name is "Pat" (the decision is "Yes"), the flow proceeds to the workspace element 215, which is a terminal element and triggers a user interface (UI) for the workspace contact of Pat Smith.

[0027] In the sequential execution of a workflow, the system generates the corresponding UI when the operator reaches the end of the sequence of sequential workflow operations. Therefore, workflow 200 has a sequential dependency between the decision element (which retrieves and loads data to determine which path to take) and the final rendering of the user interface. In addition to waiting for the execution of the sequential dependency, generating the UI requires additional time because generating the UI is slow relative to other actions and functions within the workflow. Examples of time are shown below.

[0028] As described above, decision elements 205, 210, 220, and 240 within a workflow are required to wait for input data before they can make any decisions to follow the next action element along one of their output branches. Therefore, in prior art systems, no element within the path after a decision element (including the terminal element for generating the UI) could be executed until the decision element was executed and sequential processing along the path reached the terminal element. Not only does waiting for each network request of the decision element to complete delay the system response time, but generating the final UI is also time-consuming compared to other actions, and thus adds more time to sequential processing.

[0029] Referring to FIG. 3, an embodiment of a computer-implemented method 300 executed by the branch predictor 140 of FIG. 1 is shown. Method 300 is configured to perform branch prediction at a decision element and pre-construct a user interface (UI). Therefore, this method predicts the final UI in advance without waiting for the sequential execution of the workflow. Once the prediction is made, the method and system start constructing the UI without waiting for the decision element to complete its processing and without waiting for a series of workflow actions to be completed by the operator.

[0030] In one embodiment, at the start of a workflow such as workflow 200 in FIG. 2, method 300 is initiated and executed to perform branch prediction. In block 310, one or more portions of the workflow structure are input into memory by at least the processor. The processor can sequentially advance and navigate the workflow in the flow sequence in response to user input / actions.

[0031] As described above, workflow 200 is composed of a plurality of execution paths, and the plurality of execution paths include a plurality of decision elements for controlling access to different portions of the execution paths. The plurality of execution paths lead to a plurality of terminal elements associated with a plurality of user interfaces.

[0032] In block 320, the method and system monitor the workflow to determine when a decision element is encountered in the flow sequence. For example, in workflow 200 of FIG. 2, the first decision element encountered is element 205, which includes a plurality of branch paths. In response to the flow sequence encountering the first decision element within the workflow, in block 330, the processor (i) executes a prediction to predict the resulting path of the first decision element, predicting a first user interface that can be encountered later in the flow sequence as part of the first terminal element from among the plurality of user interfaces, and in block 340, (ii) pre-constructs the predicted first user interface before encountering the first terminal element. Further details of the prediction and pre-construction functions are provided below.

[0033] For purposes of discussion, assume that the prediction is that decision element 205 will result in a "Yes" branch and the workflow will reach the "Pat Smith" contact at end element 215 in FIG. 2. In one embodiment, the prediction is (at least in part) based on the previous historical results of the decision element, which will be further described below. The system also pre-builds / generates a user interface associated with the predicted Pat Smith contact. Thus, when decision element 205 executes its logic to determine whether the "last name = Smith" as described above, the prediction and pre-building are executed simultaneously and / or in parallel with the decision element logic. Thus, the sequential dependencies of prior art techniques for processing decision elements and rendering user interfaces are removed, which improves computer functionality by improving workflow processing time. The decision element logic includes requesting and retrieving database records via network requests to a database and determining whether the retrieved database records have a "last name" field that is "Smith" or not "Smith".

[0034] In one embodiment, when the system predicts a user interface (UI) and begins to construct the UI, the UI is not displayed or presented to the user. The predicted UI is constructed in memory and placed in a queue in a background process. The system cannot begin to show the pre-built, predicted UI because the predicted UI may ultimately be the wrong UI (e.g., the workflow ends on a different end element with a different UI). The system cannot display the wrong UI on the display screen because doing so is a processing error and would confuse the user. If the UI is correct, information from the corresponding data record is filled into the UI and the UI is displayed.

[0035] Continuing to refer to method 300 of FIG. 3, at block 350, the system determines whether the prediction is correct. This can be determined, for example, by determining which terminal element the workflow sequence ultimately reaches. In response to the flow sequence reaching the predicted terminal element of Pat Smith contact 215, the prediction is determined to be correct, and a pre-built user interface is displayed and presented on the display device.

[0036] In exemplary workflow 200, it should be noted that along the "Yes" path with the surname = Smith, there is a second decision element 210 for "first name = Pat". Any number of decision elements may be encountered in the workflow path. In one embodiment, the branch prediction is re-executed for the second decision element, which may result in the same or a different prediction.

[0037] Returning to decision block 350 of FIG. 3, if the flow sequence does not take the predicted path and reaches a different terminal element that was not predicted, the prediction is incorrect. Then, method 300 moves to block 370, and in response to the flow sequence reaching a different terminal element, the processor is caused to discard the predicted, pre-built user interface. Then, the system generates a new user interface associated with the terminal element that the workflow actually reached. For example, in FIG. 2, if the actual terminal element reached is the John Smith contact element 230, the predicted user interface for the Pat Smith contact is discarded. Then, a user interface associated with the John Smith contact is generated and rendered on the display screen.

[0038] Constructing a user interface is one of the more time-consuming operations in the system (e.g., requiring approximately 300 ms to 500 ms). Thus, if the prediction is correct, the final UI is already constructed (or nearly constructed) and ready for presentation and use by the time the operator reaches that point in the workflow sequence. This reduces the amount of processing time required by the system as compared to sequential processing of the workflow. An example of the time comparison is described below.

[0039] In another embodiment of method 300, the method can predict branch paths and associated actions for one or more data records. For example, the predicted action may create, delete, or otherwise modify data from the predicted data record before the workflow reaches the terminal element. In this case, the user interface is not part of the terminal element, but rather the action on the predicted data record is executed. For example, if the predictor predicts a certain branch leading to a terminal element with a record modification action at a certain decision element, the system pre-executes the record modification action (as described above) in parallel with the processing of the decision element. Pre-execution may include accessing the database, retrieving the associated data record, and performing data modification on that data record. If the prediction is incorrect and the workflow ends at a different terminal element, the data modification is ignored and not saved to the database. If the prediction is correct, the modified record is saved to and updated in the database.

[0040] Tournament Predictor In one embodiment, the branch predictor 140 of FIG. 1 and the associated prediction function (block 330 of FIG. 3) are implemented using a tournament predictor. In one embodiment, the branch prediction is constructed using a software algorithm and relates to reducing a long time frame for handling network requests for data records and the data center response time for returning the requested data records. These network requests and data records are part of or required by the decision elements.

[0041] As described above, when the workflow reaches a decision element / node, the system triggers the prediction function. For example, the decision node determines an output branch based on the customer name, as in the example of FIG. 2. For each decision element within the workflow, a history of the path taken by the decision element is maintained. In one embodiment, the four previous paths taken by the decision element are stored in the predictor history data structure of that decision element. For decision element 205, the path history may be Yes, Yes, Yes, No. The output paths may be labeled in other ways, such as path history A, A, A, B. Of course, any number of previous paths may be stored for a decision element. This path history is maintained, for example, within the data structure of decision element history 170 shown associated with decision elements 205 and 210.

[0042] Each element within the workflow is assigned a unique ID so that the system can identify and track the workflow element. Each path may also be assigned a unique ID to identify that path from all other paths within the workflow. The predictor history data structure may be configured to map or associate each decision element ID with its corresponding path history. Thus, the path history of a selected decision element may be identified and retrieved when required for making a prediction.

[0043] When the workflow reaches a decision element and there is no historical data (meaning the system is at this decision node for the first time), the decision element is executed without prediction. This includes receiving input data, retrieving the corresponding data record (e.g., customer contact record), evaluating the record's "name" field, and determining the output branch based on the name field value. The system then saves the taken output path (e.g., path "A") to the historical data of that decision element. When historical data is searched for this decision element, the historical data indicates that when the workflow was last at this decision element, the workflow entered path "A". After several predictions are made for the decision element, the system also stores and maintains the accuracy of those predictions as determined based on the actual output path taken.

[0044] When multiple decision elements are within the workflow, the system has multiple predictions that occur, and one predictor for each decision element is based on the last four historical paths taken for that decision element. Since each path has an assigned ID and an associated prediction accuracy, the system compares each predictor from the decision elements to each other to determine which predictor was the most accurate. If the first predictor in the first decision element was accurate in the last prediction, the system trusts that predictor more than the inaccurate predictors. In one embodiment, each predictor is assigned a confidence value corresponding to how accurate previous predictions were. For example, the most frequently selected path in the past is given a higher weight and will be selected as the next prediction. Thus, if the path history for a decision element was A, A, A, B, path A is the most frequently selected path between A and B, so path A will be the next predicted path. The confidence value for path A is 75% (3 out of the last 4 results).

[0045] As described above, the decision made in the decision element is based on the data record having the specified field value. The tournament predictor for each decision element is implemented to predict the result of the decision element and thus the resulting branch path. The predictor may also be executed in parallel and / or simultaneously with the processing of the decision element. Thus, the predictor executes the result and makes its prediction without waiting for or knowing the actual field value from the retrieved data record.

[0046] In one embodiment, the system implements two types of predictors used to attempt to predict the path taken through the workflow, namely a record-based history predictor and a global history predictor. Each decision element within the workflow already has a unique ID associated with the predictor. For each decision element, the following predictors are used to determine the most likely output path to be taken.

[0047] 1) Record-based history predictor. This predictor specifically stores and uses historical data for selected data records. For example, the system generates a history predictor for the data record of "John Smith" and stores the decision result of the last X made in that record. For many customers, a given record may be opened multiple times, and each time it is opened, it will behave consistently. When an agent opens a certain data record (John Smith) during the workflow, the system determines which characteristics in the data record the agent is looking at. The characteristics may include job title, position, location, department, and / or other attributes that may appear in the data record. Each different characteristic may result in the generation of a different user interface using the customized data associated with the characteristic. Assume that the record history of the John Smith record indicates that the record has been opened 4 times and the "job title" data field has been "director" each time. When the record is opened next, the predictor predicts based on the previous history that the job title is still "director" and predicts the corresponding output path and user interface based on the fact that the characteristic is "director".

[0048] As another example, assume that a certain workflow has a certain branch path based on the record being created on a specific day and the record being related to a specific topic. These attributes are less likely to change between times when the agent opens the record. Knowing the path the workflow took when processing this record is a strong predictor of the path the workflow will take again for the same record when the record is opened within the workflow next.

[0049] 2) Global history predictor. Instead of using the history of a single data record as in a record-based history predictor, the global history predictor looks at histories across many different records, which may include the histories of all records within a selected category. For example, the global history predictor examines multiple records with common characteristics and uses their histories to predict the output path at a decision point. A record-based history predictor may not have any data regarding a given record, but the global history can provide a prediction of what an agent is generally doing regardless of the actual workflow assigned to the agent.

[0050] It is also possible that there are different workflows that would process the same record differently each time it is opened. This could be through something like an escalation process that automatically changes values on the record. In these cases, the previous path may not be repeated by the decision element. Recall that different workflows are assigned to an agent based on the type of task being performed or the type of data record opened by the agent. Each workflow may be configured differently to handle a specific task and will have different workflow elements. For example, when an agent opens a "contact" data record, the system assigns the contact workflow for the agent to follow. When an "incident" task record is open (to process an incident report), the system assigns the incident workflow for the agent to follow.

[0051] In one embodiment, each predictor tracks its own accuracy. In a tournament mode, the prediction path from the predictor with the best history accuracy is selected as the overall prediction path. Each predictor participating in the tournament prediction scheme can be arbitrarily complex. In another embodiment, the predictor may be constructed using more advanced machine learning concepts or pattern matching schemes.

[0052] In another embodiment, for each predictor of a decision element / node, the system maintains two queues. The two queues are stored in the decision element history 170 associated with each decision element (shown in FIGS. 1 and 2). If we use a length of 4 again as used above, the system has one queue containing the predictions made by its decision element predictor over the last four executions, while the second queue maintains the actual paths taken in the last four executions. These are used to calculate two things: (1) a path prediction P based on the actual paths taken historically, and (2) a confidence C based on the performance of that particular predictor over a history window.

[0053] For example, let D be a decision node with output paths P ∈ {X, Y, Z}, and Table 1 below shows exemplary histories recorded for three predictors after encountering this decision node four times.

[0054] Table 1 - Predictor History Predictor 1 Actual history: XYX Prediction history: XY Predictor 2 Actual history: XZYZ Prediction history: XZY Predictor 3 Actual history: XZ Prediction history: XZ When the system reaches this decision node next time, a prediction is calculated for each of the registered predictors. The prediction includes two components, namely, an output path P ∈ {X, Y, Z} and a confidence C ∈ [0, 1].

[0055] P is calculated as the most frequent output of the actual history, and C is calculated as the accuracy of that predictor over the history length, comparing its own prediction to the actual result.

[0056] For Predictor 1: P = X / / There are two X's and two Y's, and the tie goes to the more recent history, which is X C = 0.50 / / Two of the last four are correct For Predictor 2: P = Z / / Two of the last four C = 0.25 / / One of the last four is correct For Predictor 3: P = Z / / The most recent prediction wins in the combination C = 0.75 / / Three of the last four are correct Here, the system has a tournament selection among each of the predictors, where it takes the predictor with the highest confidence. Predictor 3 wins with a 75% highest confidence, and the overall result is the path prediction of Z. The reason each of these predictors can have different actual histories is that they can be registered for different ranges, and they do not apply in all the same situations as the others, and thus, may be exposed to different scenarios and thus record different histories.

[0057] In one embodiment, in the case of a combination in the confidence between two predictors predicting different paths, the system performs an implicit ordering based on which type of predictor is considered to provide more accurate results, especially within the domain of the associated product.

[0058] Results In one embodiment, exemplary performance results were measured from enabling this branch prediction system on a service cloud test site. In the test, the test system opened the same record five times and recorded the average time to display the resulting user interface so that the test system could monitor performance regression. This particular test has a workflow with decision factors based on whether a service request has been closed. The system assumes that the number of "closed" requests opened should not be the same as the number of "active" requests opened by the agent, and thus the system automatically makes its prediction (without prior knowledge of the actual workflow). Based on the prediction, the system pre-builds the predicted user interface, which ultimately leads to the rendering of the user interface. The completion time is measured with and without the prediction (e.g., sequential process). The prediction system was able to shorten the time to open an active service request and render the corresponding user interface from about 5 seconds (for the sequential process) to about 3 seconds (when using the prediction system).

[0059] Generation / Prebuild of User Interface The following is an exemplary embodiment of the operations performed to generate / prebuild a user interface as described above. Referring to workflow 200 of FIG. 2, the end workspace contact elements 215, 230, 235, 245, and 250 trigger different user interfaces that can be presented to the user / agent depending on which branch is taken along the workflow.

[0060] When a prediction is made at the decision factor, the system, in one embodiment, constructs the user interface as a web page as follows.

[0061] The structure or skeleton of a web page is defined according to HTML, and the content of the page is defined according to the data bound to that skeleton. There are several steps involved in combining these together and actually drawing the visible elements on the display screen, but that is handled by the browser's rendering engine and is outside the scope of this disclosure.

[0062] The construction of the user interface is performed before the actual rendering step. The steps that the browser executes to render the user interface on the web page are separate from the construction of the user interface. To construct the user interface, the system uses the following.

[0063] (1) A fully expanded HTML tree that describes the layout of a given work space (e.g., the workflow structure and elements within workflow 200 that represent different UIs as shown in FIG. 2). Since the work spaces are globally configurable, each element within them, i.e., text fields, buttons, images, tables, etc., is defined by the appropriate HTML blocks. To request the browser to render the work space, the system groups all the pieces into one object.

[0064] (2) Second, the system uses a corresponding data structure that matches the HTML tree and holds the content that will be displayed. That is, HTML defines the text box we want to show, and this data structure tree defines what we actually show in that text box. We call these auxiliary data structures view models, and we need to construct the same composite tree of both HTML and view models that defines the structure and content of the UI we want to show.

[0065] The work space elements can be arbitrarily complex. A user can add any number of fields, controls, and even custom extensions to their work space. In some systems, when constructing a presentation design pattern, each item shown on the work space is constructed using the MVVM design pattern (Model-View-ViewModel MVVM). This means that there are views and view models that are bound back to the model of the original data. Constructing the views and view models is a somewhat expensive operation from the perspective of time and computing resources, and significant performance gains can be achieved by starting these operations earlier by making predictions. Using the present invention, views and view models can be created and then bound to the view model at a later point in time.

[0066] In one embodiment for the system to construct both of the above components (1) and (2), the system uses a work space definition (our data representation including what the customer wants to see for the UI). For example, the contact work space element in workflow 200 of FIG. 2 shows different terminal elements that can be reached in workflow 200. One objective of this prediction system is to enable the construction of the two trees described in (1) and (2) above before the system actually knows for sure which of the work space contacts the user will end up at when navigating sequentially along workflow 200.

[0067] In one embodiment, these workspace definitions are defined on the browser client, and thus, the system can build anything when triggered. The system only doesn't know which until an actual data record is retrieved (as part of the decision-making factors) to identify what the agent / user is attempting to access and view. This prediction system is realized and executed at this point in the workflow to predict which of the possible workspaces and associated user interfaces the system should pre-build. The prediction and pre-building of the user interface are executed simultaneously while the system waits for the network request to retrieve the data record from the database and judges the result of the decision-making factors.

[0068] Processing Comparison As a comparison, the sequential processing of the decision-making factors is executed as follows.

[0069] 1) Send a network request to the database to obtain the record that the agent / user wants to see.

[0070] 2) The system waits for the record to be returned via network communication, then loads the record and its field values into memory. Then, the decision-making factor judges the result of its decision based on the selected field values. The result corresponds to the output branch in the workflow that leads to constructing the resulting user interface.

[0071] 3) Construct the HTML and view model tree for the resulting user interface.

[0072] 4) Send the user interface to be rendered to the browser engine. In this prediction system, when encountering a decision element, instead of waiting for the network request to complete from steps 1 and 2, the system sends the same request. While waiting for the record to be returned, the system, in parallel, makes a prediction about the user interface and starts the pre-construction of the user interface (for example, constructs HTML and view models from the prediction).

[0073] When the requested record is returned and its field values are analyzed, the prediction system checks whether the prediction was correct based on the result of the decision element. If the prediction is correct, the system continues as is and completes the construction of the user interface that has already been started (if not already completed). Thus, the system effectively reduces the perceived load time by only the time it takes to make the network request and load the retrieved record. If the prediction is incorrect, the pre-constructed user interface is discarded / deleted, and the system resumes processing at step 2 as before. Note that the penalty for being incorrect is essentially nothing because the prediction process is done in parallel.

[0074] Some of the estimated number of hours may provide some context. In the case of a standard user interface generated and rendered on a computer with an appropriate network connection speed, after the data record is retrieved and the decision-making element is completed, it may take 300 ms to 500 ms (milliseconds) to perform all the operations for constructing the HTML and view model. Fetching the data record that tells the system which user interface to construct may take about 100 ms to 200 ms. Adding this time, the sequential processing method would take network trip + processing time = 400 ms to 700 ms. In this system and method that executes these steps in parallel based on a new prediction technique, the system is only limited by the 300 ms to 500 ms processing time for constructing the user interface. Thus, this is an improvement over computer functionality and prior art processes.

[0075] Timing can depend on many factors, but regardless of Internet and computer speed, the end result is that the system can eliminate the sequential dependencies of operations by implementing the prediction technique. The prediction technique enables operations that could not be performed simultaneously with previous sequential dependency techniques to be performed simultaneously.

[0076] Cloud or enterprise embodiments In one embodiment, the prediction system / branch predictor 140 and / or the configured computing device 100 shown in FIG. 1 is a computing / data processing system that includes applications for an enterprise organization or a collection of distributed applications. The applications and computing system 100 may be configured to operate with or may be implemented as a cloud-based networking system, a software as a service (SaaS) architecture, or other type of networked computing solution. In one embodiment, the branch predictor 140 and / or method 300 provides at least the functions disclosed herein and is a centralized server-side application that is accessed by many users via a computing device / terminal that communicates with the computing system 100 (functioning as a server) via a computer network.

[0077] In one embodiment, one or more of the components described herein are configured as program modules stored on a non-transitory computer-readable medium. The program modules are configured with stored instructions that, when executed at least by a processor, cause the computing device to perform the corresponding functions described herein.

[0078] Embodiments of the Computing Device Figure 4 shows an exemplary computing device configured and / or programmed as a dedicated computing device having one or more of the exemplary systems and methods described herein and / or equivalents. The exemplary computing device may be a computer 400 including a processor 402, a memory 404, and an input / output port 410 operably connected by a bus 408. In one example, computer 400 may include a prediction logic / module 430 configured to facilitate the prediction system of computing device 100 and branch predictor 140 shown in FIG. 1, and method 300 shown in FIG. 3. In different examples, logic 430 may be implemented in hardware, a non-transitory computer-readable medium storing instructions, firmware, and / or combinations thereof. Although logic 430 is shown as a hardware component attached to bus 408, it should be understood that in other embodiments, logic 430 may be implemented within processor 402, stored within memory 404, or stored within disk 406.

[0079] In one embodiment, logic 430 or the computer is a means (e.g., structure: hardware, non-transitory computer-readable medium, firmware) for performing the described actions. In some embodiments, the computing device may be a server operating within a cloud computing system, a server configured within a software as a service (SaaS) architecture, a smartphone, a laptop, a tablet computing device, or the like.

[0080] Computer 400 and prediction logic 430 are structures for providing a means (e.g., hardware, non-transitory computer-readable medium storing executable instructions, firmware) for executing the present prediction system.

[0081] Generally, to describe an exemplary configuration of computer 400, processor 402 may be various processors configured to be operated and controlled by prediction logic 430, including dual microprocessors and other multiprocessor architectures. Memory 404 may include volatile memory and / or non-volatile memory. Non-volatile memory may include, for example, ROM, PROM, etc. Volatile memory may include, for example, RAM, SRAM, DRAM, etc.

[0082] Storage disk 406 may be operably connected to computer 400, for example, via an input / output (I / O) interface (e.g., card, device) 418 and an input / output port 410 that are controlled by at least an input / output (I / O) controller 440. Disk 406 may be, for example, a magnetic disk drive, a solid state disk drive, a floppy (registered trademark) disk drive, a tape drive, a Zip drive, a flash memory card, a memory stick, etc. Further, disk 406 may be a CD-ROM drive, a CD-R drive, a CD-RW drive, a DVD ROM, etc. Memory 404 may be able to store, for example, process 414 and / or data 416. Disk 406 and / or memory 404 may be able to store an operating system that controls and allocates resources of computer 400.

[0083] Computer 400 may interact with input / output (I / O) devices via I / O interface 418 and may interact with input / output port 410 via input / output (I / O) controller 440. Input / output devices may be, for example, a keyboard, a microphone, a pointing and selection device, a camera, a video card, a display, disk 406, network device 420, etc. Input / output port 410 may include, for example, a serial port, a parallel port, and a USB port.

[0084] Computer 400 can operate in a network environment and can thus be connected to network device 420 via I / O interface 418 and / or I / O port 410. Through network device 420, computer 400 can interact with the network. Through the network, computer 400 may be logically connected to a remote computer. Networks with which computer 400 may interact include, but are not limited to, LANs, WANs, and other networks.

[0085] Definitions and Other Embodiments In another embodiment, the methods described and / or their equivalents may be implemented using computer-executable instructions. Thus, in one embodiment, a non-transitory computer-readable / storage medium is configured with computer-executable instructions stored thereon that, when executed by a machine, cause the machine (and / or associated components) to execute the method. Exemplary machines include, but are not limited to, a processor, a computer, a server operating in a cloud computing system, a server configured in a software as a service (SaaS) architecture, a smartphone, etc. In one embodiment, a computing device is implemented using one or more executable algorithms configured to execute any of the disclosed methods.

[0086] In one or more embodiments, the disclosed methods or their equivalents are either computer hardware configured to execute the method or computer instructions embodied in modules stored on a non-transitory computer-readable medium and configured as executable algorithms that, when executed by at least a processor of a computing device, cause the method to be executed.

[0087] To simplify the description, the methods shown are presented and described as a series of blocks of an algorithm, but it should be understood that these methods are not limited by the order of the blocks. Some blocks may occur in a different order than illustrated and described, and / or concurrently with other blocks. Further, an exemplary method may be implemented using fewer blocks than all of the illustrated blocks. The blocks may be combined or separated into multiple actions / components. Additionally, additional and / or alternative methodologies may employ additional actions not shown in the blocks.

[0088] The following includes definitions of selected terms used herein. The definitions include various examples and / or forms of components that are within the scope of the term and may be used for implementation. The examples are not intended to be limiting. Both singular and plural terms may be within the definitions.

[0089] References to "one embodiment", "an embodiment", "an example", "an instance", etc. indicate that the embodiment or example so described may include a particular feature, structure, characteristic, property, element, or limitation, but not every embodiment or example necessarily includes that particular feature, structure, characteristic, property, element, or limitation. Further, repeated use of the phrase "in one embodiment" does not necessarily refer to the same embodiment, although it may.

[0090] As used herein, a "data structure" is an organization of data within a computing system that is stored in memory, a storage device, or other computerized systems. A data structure may be any one or combination of, for example, data fields, data files, data arrays, data records, databases, data tables, graphs, trees, linked lists, etc. A data structure may be formed from and may include many other data structures (e.g., a database includes many data records). According to other embodiments, other examples of data structures are possible.

[0091] As used herein, "computer-readable medium" or "computer storage medium" refers to a non-transitory medium that stores instructions and / or data configured to execute one or more of the disclosed functions when executed. In some embodiments, the data may function as instructions. The computer-readable medium may take forms including, but not limited to, non-volatile media and volatile media. Non-volatile media may include, for example, optical disks, magnetic disks, etc. Volatile media may include, for example, semiconductor memory, dynamic memory, etc. Common forms of computer-readable media include, but are not limited to, floppy (registered trademark) disks, flexible disks, hard disks, magnetic tapes, other magnetic media, application specific integrated circuits (ASICs), programmable logic devices, compact disks (CDs), other optical media, random access memory (RAM), read-only memory (ROM), memory chips or cards, memory sticks, solid state storage devices (SSDs), flash drives, and other media that can function together with a computer, processor, or other electronic device. Each type of media may include stored instructions of an algorithm configured to execute one or more of the disclosed and / or claimed functions when selected for implementation in an embodiment.

[0092] As used herein, "logic" is implemented using a computer or electrical hardware, a non-transitory medium having stored instructions of an executable application or program module, and / or a combination thereof, to perform any of the functions or actions disclosed herein, and / or to cause functions or actions from another logic, method, and / or system to be performed as disclosed herein. Equivalent logic may include firmware, a microprocessor programmed with an algorithm, discrete logic (e.g., ASIC), at least one circuit, an analog circuit, a digital circuit, a programmed logic device, a memory device containing instructions of an algorithm, etc., any of which may be configured to perform one or more of the disclosed functions. In one embodiment, the logic may include one or more gates, a combination of gates, or other circuit components configured to perform one or more of the disclosed functions. When multiple logics are described, it may be possible to incorporate the multiple logics into one logic. Similarly, when a single logic is described, it may be possible to distribute the single logic among multiple logics. In one embodiment, one or more of these logics are the corresponding structures associated with performing the disclosed and / or claimed functions. The choice of which type of logic to implement may be based on the desired system conditions or specifications. For example, if faster speed is a consideration, hardware may be selected to implement the function. If lower cost is a consideration, stored instructions / executable applications may be selected to implement the function.

[0093] An "operable connection", or a connection by which an entity is "operably connected", is a connection through which signals, physical communication, and / or logical communication may be transmitted and / or received. An operable connection may include a physical interface, an electrical interface, and / or a data interface. An operable connection may include different combinations of interfaces and / or connections sufficient to enable operable control. For example, two entities may be operably connected to communicate signals with each other directly or through one or more intermediate entities (e.g., a processor, an operating system, logic, a non-transitory computer-readable medium). An operable connection can be formed using a logical communication channel and / or a physical communication channel.

[0094] As used herein, "user" includes, without limitation, one or more persons, one or more computers or other devices, or combinations thereof.

[0095] Although the disclosed embodiments have been illustrated and described in considerable detail, it is not intended to limit or in any way restrict the claims to such detail. Of course, it is not possible to describe every conceivable combination of components or methodologies for purposes of describing various aspects of the subject matter. Accordingly, the disclosure is not limited to the specific details or exemplary examples illustrated and described. Accordingly, the disclosure is intended to embrace alterations, modifications, and variations that fall within the scope of the claims.

[0096] To the extent that the term "includes" or "including" is used in the detailed description or the claims, it is intended to be inclusive in the same manner as the term "comprising" is interpreted when used as a transitional word in a claim.

[0097] As long as the term "or" is used in the detailed description or in the claims (e.g., A or B), it is intended to mean "A or B or both". If the applicant intends to indicate "only A or B, but not both", the phrase "only A or B, but not both" will be used. Accordingly, the use of the term "or" in this specification is inclusive and not exclusive.

Claims

1. A computer program comprising computer-executable instructions which, when executed by at least a processor of a computer, cause the computer to input a workflow into a memory by at least the processor and sequentially advance the workflow in a flow sequence, wherein the workflow is composed of a plurality of execution paths, the plurality of execution paths include a plurality of decision elements for controlling access to different parts of the execution paths, and the plurality of execution paths lead to a plurality of terminal elements associated with a plurality of user interfaces, in response to the flow sequence encountering a first decision element within the workflow that includes a plurality of branch paths, (i) execute a prediction to predict a path resulting from the result of the first decision element, and cause the plurality of user interfaces to predict a first user interface that may be encountered later in the flow sequence as part of a first terminal element, (ii) pre-construct the predicted first user interface before encountering the first terminal element, in response to the flow sequence reaching the first terminal element, (i) display the pre-constructed first user interface on a display device, (ii) mark the prediction as correct to maintain the accuracy of the prediction for the first decision element, (iii) associate the prediction with a history of the path taken from the first decision element, A computer program that, in response to the flow sequence reaching a second terminal element, discards the pre-constructed first user interface and generates a second user interface associated with the second terminal element.

2. The instructions for pre-constructing the predicted first user interface cause the processor to generate the structure of the first user interface and associated data within the memory. The computer program according to claim 1, further comprising instructions for maintaining the first user interface in the memory without rendering the first user interface on the display device until the processor confirms that the flow sequence reaches the first terminal element and triggers the first user interface.

3. Furthermore, when executed by at least the processor, the processor is caused to execute the prediction in response to the workflow reaching a second decision element, and predict a user interface resulting as a second result based at least in part on a history of previous results from the second decision element. The computer program according to claim 1 or 2, further comprising instructions for discarding the pre-constructed first user interface and generating a user interface resulting as the second result if the user interface resulting as the second result is different from the predicted first user interface.

4. Furthermore, when executed by at least the processor, the processor is caused to maintain a history of branches taken at corresponding decision elements during previous executions of the workflow for each decision element within the workflow, The computer program according to any one of claims 1 to 3, further comprising instructions for generating a reliability value for each branch path from the corresponding decision element based on the history of the branches taken.

5. Each decision element is configured to determine a result based on a decision condition of one or more input values, and the one or more input values control the result to cause the progression along an output branch path in the workflow. The computer program according to any one of claims 1 to 4, wherein the one or more input values are received by initiating a network request to a database, retrieving a data record, loading the data record and associated values from the data record into the memory, and resolving the decision condition based on the associated values.

6. A computing system comprising at least one processor; at least one memory operably connected to the at least one processor; a non - transitory computer - readable medium storing instructions, which, when executed by at least the processor, cause the processor to cause at least the processor to input a workflow into a memory and sequentially advance the workflow in a flow sequence, the workflow is composed of a plurality of execution paths, the plurality of execution paths include a plurality of decision elements for controlling access to different parts of the execution paths, and the plurality of execution paths lead to a plurality of terminal elements associated with a plurality of user interfaces, in response to the flow sequence encountering a first decision element that includes a plurality of branch paths within the workflow, (i) execute a prediction to predict the path resulting from the result of the first decision element, and cause the plurality of user interfaces to predict a first user interface that may be encountered later in the flow sequence as part of a first terminal element, (ii) pre - construct the predicted first user interface before encountering the first terminal element, in response to the first decision element outputting a first result path leading to the predicted first user interface, (i) display the pre - constructed first user interface on a display device, (ii) mark the prediction as correct to maintain the accuracy of the prediction for the first decision element, (iii) associate the prediction with the history of the path taken from the first decision element, in response to the first decision element outputting a second result path not associated with the predicted first user interface, cause the pre - constructed first user interface to be discarded and generate a second user interface associated with the second result path, a computing system. **Claim 7** the instructions for pre - constructing the predicted first user interface cause the processor to generate the structure of the first user interface and associated data within the memory, The computing system according to claim 6, wherein the processor further includes an instruction to maintain the first user interface in the memory without rendering the first user interface on the display device until it is confirmed that the flow sequence reaches the first terminal element and triggers the first user interface.

8. Furthermore, when executed by at least the processor, the processor is caused to execute the prediction in response to the workflow reaching a second decision element, and predict a user interface resulting as a second result based at least in part on a history of previous results from the second decision element. The computing system according to claim 6 or 7, further including an instruction to discard the pre-constructed first user interface and generate a user interface resulting as the second result when the user interface resulting as the second result is different from the predicted first user interface.

9. Furthermore, when executed by at least the processor, the processor is caused to maintain a history of branches taken at corresponding decision elements during previous executions of the workflow for each decision element within the workflow, The computing system according to any one of claims 6 to 8, further including an instruction to generate a reliability value for each branch path from the corresponding decision element based on the history of the branches taken.

10. Each decision element is configured to determine a result based on a decision condition of one or more input values, and the one or more input values control the result to cause the progression along an output branch path in the workflow. The computing system according to any one of claims 6 to 9, wherein the one or more input values are received by starting a network request to a database, retrieving a data record, loading the data record and associated values from the data record into the memory, and resolving a decision condition based on the associated values.

11. A method implemented by a computer, executed by a computing device and a processor that executes instructions from a memory, at least the processor inputs a workflow into the memory and includes sequentially proceeding with the workflow in a flow sequence, the workflow is composed of a plurality of execution paths, the plurality of execution paths include a plurality of decision elements for controlling access to different parts of the execution paths, the plurality of execution paths lead to a plurality of terminal elements associated with a plurality of user interfaces, and the method further includes, in response to the flow sequence encountering a first decision element that includes a plurality of branch paths within the workflow, (i) performing a prediction to predict a path resulting from the first decision element, and predicting, from the plurality of user interfaces, a first user interface that may be encountered later in the flow sequence as part of a first terminal element; (ii) pre-constructing the predicted first user interface before encountering the first terminal element; in response to the flow sequence reaching the first terminal element, (i) displaying the pre-constructed first user interface on a display device; (ii) marking the prediction as correct to maintain the accuracy of the prediction for the first decision element; (iii) associating the prediction in a history of the path taken from the first decision element; in response to the flow sequence reaching a second terminal element, discarding the pre-constructed first user interface and generating a second user interface associated with the second terminal element, a method.

12. Pre-constructing the predicted first user interface further includes, generating the structure of the first user interface and associated data in the memory; the processor maintaining the first user interface in the memory without rendering the first user interface on the display device until the processor confirms that the flow sequence reaches the first terminal element and triggers the first user interface, the method according to claim 11.

13. Furthermore, In response to the workflow reaching a second decision element, execute the prediction and predict a user interface resulting as a second result based at least in part on a history of previous results from the second decision element. The method according to claim 11 or 12, comprising: if the user interface resulting as the second result is different from the predicted first user interface, discarding the pre-constructed first user interface and generating the user interface resulting as the second result.

Images