Algorithmic sequencing is one method for schedule construction. The sequencer uses an algorithm to select an order and places each operation for that order on the planning board. It repeats this process until all orders (and therefore, all operations) have been loaded. Each operation is loaded on its specified resource at the first available time slot that satisfies the constraints for that operation. The order-at-a-time construction process, sometimes called Order Based Method or Sequential Loading, is shown in following diagrams. In this example, we first load Order A, then Order B, and finally, Order C.
Step 1: Load Order A
Step 2: Load Order B
Step 3: Load Order C
In an order-at-a-time sequencer, selecting the sequence in which the orders are loaded onto the planning board controls the schedule. Once an order is selected, all of its operations are loaded in a straightforward, unalterable way. Hence, the key to the quality of the schedule that is generated by the algorithmic sequencer is the rule that is used for selecting the order-loading order. There are a number of very simple heuristic rules that can be used to select the sequence for loading the orders on the planning board. One rule that can be used for selecting the order sequence is to sort the orders by a priority value that has been assigned to each order. Other possible sorting criteria are earliest due date, earliest release date, and smallest remaining slack time. None of these rules are optimal in a mathematical sense. Each rule represents a different strategy and focus in planning the orders. For example, the due date-related rules (earliest due date, least remaining slack) focus on reducing the number of late orders, whereas the priority-based rule strives to complete the most important orders as soon as possible. In some applications, a given operation can be performed on two or more different resources. For example, a drilling operation might be performed on either of two drills. In such cases, the schedule in an algorithmic sequencer is first determined by the sequence of orders, then by the rule that is used to determine to which resource a given operation is assigned during the loading process. Again, simple heuristic rules (e.g., assign the operation to the resource that will complete the operation first) can be used to determine the schedule. Although an order-at-a-time sequencer typically loads each order working forward in time by starting with the first operation and continuing through to the last operation, (forward sequencing), it is also possible to use this same sequencing scheme but reverse the procedure to work backward in time (backward sequencing). In this case, the sequencer begins by loading the last operation for the order to finish at its due date. It then continues by loading the order's preceding operation to finish at the start time of the last operation. This process is continued, working backward in time, until the first operation for the order is loaded. At this point, the sequencer then selects a new order to load and repeats the entire process, again starting with the last operation and working backward in time. It continues in this fashion until all orders are loaded. The following diagram shows a schedule generated by backward sequencing Orders A, B, and C, where the vertical line on the right denotes the due date for all three orders.
Backward Sequencing Chart for Orders A, B, and C
The advantage of a backward algorithmic sequencer is that it always generates a schedule that has no late orders. However, the schedule may require start times that are infeasible; that is, the orders must start before the current time. In essence, a forward order-at-a-time sequencer fixes the start times for an order and determines the end times (which may violate the due dates), whereas a backward order-at-a-time sequencer fixes the end times and determines the start times. Although the idea of constructing a schedule that has no late orders is appealing, backward sequencing has some practical limitations, even in cases where a feasible solution is generated. Backward scheduling shifts all orders to the right on the planning board so that they start as late as possible while still meeting the due date. This means that there is no time buffer in the system and any disruptions that occur; (machine breakdowns, late material arrivals, etc.) will typically create late orders. In addition, by postponing the use of our available capacity and waiting until the last minute to start each order, we give up the opportunity to consider additional orders that may arrive later and need to be added to the schedule. For these reasons, many schedulers prefer a forward sequencing. There is also a tendency for backward sequencing to produce lower resource utilization. If you consider the Backward Sequencing Chart, a gap has been left between operations A-10 and B-20 on Resource 1. It is likely that the gap is too small to be filled by operations loaded later in the sequencing process, resulting in lower utilization. If the work had been forward sequenced the gap would have been at the end of B-20 (i.e. added to the as yet unused pool of capacity), making it available to other operations of any duration. It is also possible to use an algorithmic sequencer in a bidirectional mode. In this case, we select an operation somewhere in the middle of the order and schedule the remaining operations using forward sequencing and the preceding operations using backward sequencing. This is useful in cases where we have an available time slot on a critical, highly utilized resource and we want to assign an operation to this critical resource and then load its upstream and downstream operations around this operation. We can accomplish this by fixing the operation on the critical resource and bidirectional sequencing the remaining operations for this order. In summary, an algorithmic sequencer is a simple and fast method for loading a set of orders on the planning board. The schedule is completely determined by specifying the sequence of orders and a rule for selecting between resources.