Genetic programming for production scheduling: a survey with a unified framework
 3.4k Downloads
 24 Citations
Abstract
Genetic programming has been a powerful technique for automated design of production scheduling heuristics. Many studies have shown that heuristics evolved by genetic programming can outperform many existing heuristics manually designed in the literature. The flexibility of genetic programming also allows it to discover very sophisticated heuristics to deal with complex and dynamic production environments. However, as compared to other applications of genetic programming or scheduling applications of other evolutionary computation techniques, the configurations and requirements of genetic programming for production scheduling are more complicated. In this paper, a unified framework for automated design of production scheduling heuristics with genetic programming is developed. The goal of the framework is to provide the researchers with the overall picture of how genetic programming can be applied for this task and the key components. The framework is also used to facilitate our discussions and analyses of existing studies in the field. Finally, this paper shows how knowledge from machine learning and operations research can be employed and how the current challenges can be addressed.
Keywords
Genetic programming Job shop Production scheduling HyperheuristicsIntroduction
Production scheduling has been one of the most popular research topics in operations research, management science, and artificial intelligence. Because of limited production resources, jobs or customer orders usually have to wait in the shop floor significantly longer than their actual processing times. Production scheduling is required to determine when a job needs to be processed, which machine to process, or which priority assigned to the job. The goal of production scheduling is to effectively utilise the available resources to achieve some organisational objectives such as minimising average time that jobs have to spend in the system and minimise penalties caused by late deliveries. Over the years, new production technologies have been adopted but production scheduling is still an essential task to help businesses coordinate production activities and become more competitive.
Production scheduling has a number of challenges. For example, production environments are dynamic and uncertain (e.g. job arrivals, job cancellations, machine breakdowns), which cause computational difficulties for most optimisation techniques. The complexity of the production systems caused by heterogeneous production processes (e.g. batching, sequencedependent setup times, assembly) also makes scheduling tasks particularly hard. Moreover, production scheduling has to take into account multiple conflicting objectives to ensure that the obtained schedules are approved and applicable.
In the last few decades, a large number of studies in artificial intelligence (AI) and operations research (OR) have been conducted to develop new scheduling techniques for production scheduling. Many techniques to search for optimal solutions such as branchandbound and dynamic programming have been investigated in the literature but they are mainly restricted to small and special problems. However, these techniques are too time consuming and impractical to handle realworld production scheduling problems. Therefore, heuristics have been proposed to find “good enough” and “quick” solutions. Scheduling heuristics can be very simple such as simple dispatching rules FirstInFirstOut (FIFO), shortest processing time (SPT), and earliest due date (EDD). Some heuristics also monitor the status of the shop and machine to decide which dispatching rule to be applied. For example, the rule FIFO/SPT will apply FIFO when the jobs in the queue of the considered machine have been waiting for more than a specific time and SPT will be applied otherwise. Heuristics can also be very sophisticated such as composite dispatching rules [119], which are combinations of simple rules basically in the form of sophisticated humanmade priority functions of various scheduling parameters. Other heuristics based on understandings of problem domains have been also proposed in the literature such as shifting bottlenecks [5]. More general techniques based on metaheuristics such as tabu search [106] and genetic algorithm [16] have been developed to deal with different production scheduling problems and show promising results. However, it is noted that designing a good heuristic is not a trivial task and it can be very time consuming and requires a lot of problem domain knowledge.
The field of automated heuristic design or hyperheuristics [21, 23] has been very active recently to facilitate the design of heuristics for hard computational problems. The goal of this approach is to explore the “heuristic search space” of the problems instead of the solution search space in the cases of heuristics and metaheuristics. In this survey, we focus on hyperheuristics for heuristic generation to fabricate a new heuristic (or metaheuristic) by combining various small components (normally common statistics/features or operations used in preexisting heuristics) and these heuristics are trained on a training set and evolved to become more effective. The motivation of this approach is to reduce the time needed to design heuristics from the human experts and to increase the chance to explore a wide range of powerful and undiscovered heuristics. In the last decade, genetic programming [6, 67] has been the dominating technique for automated design for production scheduling heuristics [20].
As compared to other hyperheuristics based on supervised learning such as decision tree [107, 127], logistic regression [57], support vector machine [129], and artificial neural networks [32, 138], genetic programming (GP) has shown a number of key advantages. First, GP has flexible representations which allow various heuristics to be represented as different computer programs. Second, GP has powerful search mechanisms which can operate in the heuristic search space to find optimal or near optimal scheduling heuristics. Different from the supervised learning methods mentioned above, GP can simultaneously explore both the structure and corresponding parameters of a heuristic without assuming any model based on a particular distribution or domain knowledge. Moreover, many evolutionary multiobjective optimisation (EMO) techniques are also available in the literature to help GP design effective heuristics to deal with multiple conflicting objectives. Finally, heuristics obtained by GP can be partially interpretable and very efficient, which is a very important feature to enhance its applicability in practice.
In the last decade, there is a growing number of articles about automated heuristic design and its applications. In Burke et al. [22], a general genetic programmingbased hyperheuristic framework was presented and some studies were used to explain the idea. Burke et al. [24] provided a general survey of related studies on hyperheuristics developed to deal with a wide range of scheduling and combinatorial optimisation problems. Both heuristic selection and heuristic generation are discussed in that survey. Brief discussions of hyperheuristic applications were also provided. Although there are a number survey papers for production scheduling such as Ouelhadj and Petrovic [109] and Hart et al. [43], they just focused on traditional metaheuristics to find optimal solutions for a set of static scheduling instances. Recently, Branke et al. [20] presented the most comprehensive survey of existing studies on hyperheuristics and production scheduling. In the survey, critical design aspects such as attribute selection, representation, and fitness functions are presented. However, as the survey attempts to cover all existing hyperheuristic approaches for production scheduling, only key general issues are provided.
GPbased hyperheuristics have been applied to many production scheduling problems and many new algorithms have been developed. As compared to other evolutionary computation techniques, GP is more sophisticated because of its variable representations and special operators. Production scheduling problems themselves are also complicated and have special characteristics as compared to other combinatorial optimisation problems. To successfully apply genetic programming to production scheduling, researchers will need to understand technical aspects from these two research areas. The goal of this paper is to provide a comprehensive review of existing studies on using GP for automated design of production scheduling heuristics. A unified framework is presented in this paper to show how GP can be applied to design production scheduling heuristics and the key components that can influence the performance of GPHHs for these tasks. Each key component is described in detail and we also analyse how they are treated in the previous studies. Then we discuss the connections between GP and other AI and OR techniques. Finally we highlight the current issues and challenges. It is expected that the survey will help the beginning researchers have a good overview of this emerging and interesting research area and pick up key ideas and challenges for the future studies.
Background
Before moving to detailed discussions of GP for production scheduling, we provide a brief overview of production scheduling and genetic programming. This section targets researchers who are new to these two research areas. Those who are familiar with scheduling and GP concepts can safely skip this section.
Production scheduling
Production scheduling is about allocation of scarce manufacturing resources to tasks over time. Depending on the nature of production processes and customer demand, there are many different types of production environments. In the literature, a scheduling problem is described by the triplet \(\beta \gamma \delta \), where \(\beta \) represents the machine environment, \(\gamma \) provides the processing characteristic (it may contain no entry at all or multiple entries), and \(\delta \) describes the objective to be optimised [119]. The goal of production scheduling is to determine when a job (or a customer order) should be processed and which machine (i.e. production resource in \(\beta \)) is used to process that job to optimise \(\delta \), given that all process constraints \(\gamma \) are satisfied. For the single machine environment, a job only needs to go through one production process to be completed. For multistage (with multiple machines) environment, a job is a sequence of operations, each of which is to be performed on a particular machine.
Studies of production scheduling literature can be classified into two main streams. The first one focuses on static scheduling problems where information of all jobs is available. Previously studies on static problems try to develop efficient algorithms to find optimal solutions. Nevertheless, many scheduling problems are proven to be NPhard. Thus, most proposed exact methods such as branchandbound and dynamic programming fail to find optimal solutions (or can only find optimal solutions for very small instances). As a result, a large number of scheduling heuristics, e.g. NEH for flows shop scheduling [136], and shifting bottleneck [119] for job shop scheduling, are developed to search for “good enough” solutions within a reasonable computational times. Metaheuristics such as tabu search [106], genetic algorithm [16], particle swarm optimisation [126] have also been applied extensively to solve production scheduling problems.
For dynamic scheduling problems, jobs may arrive randomly over time and their information is not available before their arrivals. Dispatching rules is the most popular approach for dynamic scheduling problem. In most cases, dispatching rules are represented by priorities functions that assign priorities to jobs. Then the jobs with the highest priority will be processed first. Many rules have been developed by practitioners and researchers to cope with a wide range of production environments. Three attractive characteristics of the dispatching rules are their efficiency, reactiveness, and interpretability. GP plays a major role in dynamic scheduling, which is to be described below.
Genetic programming
Different from genetic algorithms, each individual of a GP population is not represented by a fixedlength string of genes (bits, real numbers, or symbols). Because the shape and length of the final program is normally not known by the user, individuals in GP usually represent programs as tree structures which are constructed by a set of terminals and a set of functions. Basically, a GP individual is a specific combination of elements selected from these two sets. The terminal set consists of programs’ inputs (also referred to as features or attributes) or (ephemeral random) constants [67]. Meanwhile, the function set can contain arithmetic operators, logic operators, mathematical or specialised functions used to construct GP programs. Other representations are also developed in grammarbased GP [139], graphbased GP [120, 124] and linearbased GP [17, 69] and achieve very promising results. For each representation, special genetic operators (crossover, mutation) are developed to help GP create new individuals based on parent programs.
Genetic programming for production scheduling
Topics covered by previous studies
Paper  Metaalgorithm  Representation  Genetic operator  Search mechanism  Fitness function  Multiple decisions  Multiobjective  Attribute analysis  Interpretability  Generalisability 

Miyashita [81]  \(\checkmark \)  
Dimopoulos and Zalzala [30]  \(\checkmark \)  \(\checkmark \)  
Yin et al. [142]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Ho and Tay [50]  \(\checkmark \)  
Geiger et al. [38]  \(\checkmark \)  \(\checkmark \)  
Jakobovic and Budin [59]  \(\checkmark \)  \(\checkmark \)  
Jakobovic et al. [60]  \(\checkmark \)  
Tay and Ho [134]  \(\checkmark \)  
Beham et al. [14]  \(\checkmark \)  
Geiger and Uzsoy [37]  \(\checkmark \)  \(\checkmark \)  
Baykasoglu [9]  \(\checkmark \)  \(\checkmark \)  
Li et al. [73]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Tay and Ho [135]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Yang et al. [141]  \(\checkmark \)  \(\checkmark \)  
Mucientes et al. [83]  \(\checkmark \)  \(\checkmark \)  
Baykasolu and Gken [12]  \(\checkmark \)  
Kofler et al. [66]  \(\checkmark \)  
Furuholmen et al. [36]  \(\checkmark \)  \(\checkmark \)  
Hildebrandt et al. [46]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Kuczapski et al. [68]  \(\checkmark \)  
Nie et al. [100]  \(\checkmark \)  \(\checkmark \)  
Pickardt et al. [117]  \(\checkmark \)  
Baykasoglu et al. [11]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Abednego and Hendratmo [1]  \(\checkmark \)  
Nguyen et al. [85]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Nie et al. [101]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Nie et al. [102]  \(\checkmark \)  
VazquezRodriguez and Ochoa [136]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Jakobovi and Marasovi [58]  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [86]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [87]  \(\checkmark \)  \(\checkmark \)  
Nie et al. [103]  \(\checkmark \)  \(\checkmark \)  
Han et al. [41]  \(\checkmark \)  
Nguyen et al. [88]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [89]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [90]  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [91]  \(\checkmark \)  \(\checkmark \)  
Nie et al. [104]  \(\checkmark \)  \(\checkmark \)  
Park et al. [110]  \(\checkmark \)  \(\checkmark \)  
Park et al. [111]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Pickardt et al. [118]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Qin et al. [122]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Nie et al. [105]  \(\checkmark \)  
Hildebrandt and Branke [45]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Hildebrandt et al. [47]  \(\checkmark \)  \(\checkmark \)  
Hunt et al. [53]  \(\checkmark \)  
Hunt et al. [54]  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [93]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [92]  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [94]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [95]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [96]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Park et al. [112]  \(\checkmark \)  
Alsina et al. [3]  \(\checkmark \)  \(\checkmark \)  
Belisrio and Pierreval [15]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Sim and Hart [130]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Branke et al. [18]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Hunt et al. [56]  \(\checkmark \)  \(\checkmark \)  
Hunt et al. [55]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [97]  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [98]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Park et al. [114]  \(\checkmark \)  \(\checkmark \)  
Park et al. [113]  \(\checkmark \)  \(\checkmark \)  
Shi et al. [128]  \(\checkmark \)  
Wang et al. [137]  \(\checkmark \)  
Baykasoglu and Ozbakr [10]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Chen et al. [26]  \(\checkmark \)  \(\checkmark \)  
Durasevic et al. [31]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Freitag and Hildebrandt [35]  \(\checkmark \)  \(\checkmark \)  
Hart and Sim [42]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Karunakaran et al. [63]  \(\checkmark \)  \(\checkmark \)  
Park et al. [115]  \(\checkmark \)  \(\checkmark \)  
Park et al. [116]  \(\checkmark \)  \(\checkmark \)  
Riley et al. [123]  \(\checkmark \)  \(\checkmark \)  
Branke et al. [19]  \(\checkmark \)  \(\checkmark \)  
Mei and Zhang [78]  \(\checkmark \)  
Karunakaran et al. [64]  \(\checkmark \)  \(\checkmark \)  
Masood et al. [75]  \(\checkmark \)  \(\checkmark \)  
Mei et al. [79]  \(\checkmark \)  \(\checkmark \)  
Nguyen [84]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \)  
Nguyen et al. [99]  \(\checkmark \)  \(\checkmark \)  \(\checkmark \) 
Unified framework
Production scheduling problems
GP has been applied in a wide range of production scheduling problems, ranging from single machine scheduling [30, 38, 59, 100, 142], parallel machine scheduling [31, 60], to (flexible) job shop scheduling [42, 53, 59, 63, 79, 81, 88, 89, 95, 102, 104, 135, 136]. Most machines considered in these problems are the same in terms of capability (eligibility to handle a job) and assumptions (e.g. utilisation level). Although some special cases are considered in the literature such as batching [37, 118], machine breakdowns [142], and unrelated parallel machines [31], these are very limited. In addition, most scheduling problems handled by GP are dynamic problems where jobs will arrive randomly over time and their information is only available upon their arrivals. For most of these problems, the main concern is to find the best way to prioritise or schedule jobs to optimise some objectives such as makespan, mean flowtime, maximum flowtime, mean tardiness, and total weighted tardiness.
Metaalgorithm of scheduling heuristics
For example, Fig. 3 shows a generalized schedule construction algorithm [16, 89, 119] to construct an active schedule, a nondelay schedule or a hybrid of both active and nondelay schedules with a specific dispatching (priority) rule. This algorithm was based on the Giffler and Thompson [39] and has been widely used in the scheduling literature to deal with different production scheduling problems. The algorithm first identifies the machine m \(^{*}\) to be scheduled based on the earliest completion time of all available operations P. Then a subset P’ \(\in \) P including candidate operations to be scheduled next is determined by checking if the ready times of these operations are smaller than S \(^*\)+alpha(C \(^*\)S \(^*\)). The parameter alpha is the nondelay factor \(\in [0, 1]\) to control the lookahead ability of the algorithm by restricting operations included in P’ (the algorithm generates nondelay schedules if alpha = 0 and active schedules if alpha=1). A dispatching rule is applied to determine the next operation in P’ to schedule next. It is clear that performance of the algorithm depends on how the subset P’ is determined and how the next operation is picked. This algorithm is very efficient because the next operation can be determined easily by calculating priorities for jobs in P’. These two decisions are governed by the nondelay factor alpha and the dispatching rule. In this algorithm, alpha and dispatching rule are the two variable components and the rest are fixed. When designing scheduling heuristics based on the algorithm in Fig. 3, we need to decide alpha and dispatching rule to apply to obtain optimal or near optimal schedules. These two are candidate components which can be evolved using GP.
It is noted that the above algorithm and its variants have been used in most previous studies on automated design of production scheduling heuristics. Nguyen et al. [88] proposed iterative dispatching rules (IDR) which are able to create multiple schedules iteratively and the new schedule is generated based on the information of the previous generated schedule (e.g. completion times of jobs). Although their metaalgorithm is slightly different from one in Fig. 3 (only small change in step 2 and step 7), two variable components to be designed are still alpha and dispatching rule. In the variable neighborhood search with IDR [88], k iterative dispatching rules can be used to improve the quality of the final schedule. In this case, the variable components are the k dispatching rules and the nondelay factor.
Component(s) to be evolved

Dispatching rule or priority rule is used for sequencing tasks in a scheduling problem. At the moments when a sequencing decision needs to be made, dispatching rules will prioritise the jobs in the queue of a considered machine. Then, the job with the highest priority is processed next.

Routing rule or machine assignment rule is used to decide which machine from a predetermined set of machines to process the considered operation. Routing rules are usually investigated when dealing with flexible job shop scheduling problems.

Due date assignment rule is used to determine the due dates for arriving jobs by estimating the job flowtimes (the time taken from the arrival until the completion of a job).

Batch formulation rule is used to determine how to group the individual jobs into batches. This is mainly investigated for shops with batching processes.

Performance/processing time estimation: a model is obtained to estimate processing times or performance measures for planning purposes.

Inserted idle time a model is obtained to estimate the idle times to be inserted into the schedule to absorb disruptions.

Nondelay factor is used to govern the lookahead ability of dispatching rules, i.e. to what extent upstream jobs will be considered when making scheduling decisions.

Improvement/greedy heuristics is used to iteratively improve the quality of schedules in static scheduling problems.
Component(s) to be evolved by GP
Component  References 

Dispatching rule or priority rule  Miyashita [81], Dimopoulos and Zalzala [30], Yin et al. [142], Ho and Tay [50], Geiger et al. [38], Jakobovic and Budin [59], Jakobovic et al. [60], Tay and Ho [134], Beham et al. [14], Tay and Ho [135], Yang et al. [141], Baykasoglu et al. [11], Kofler et al. [66], Hildebrandt et al. [46], Kuczapski et al. [68], Nie et al. [100], Pickardt et al. [117], Abednego and Hendratmo [1], Nie et al. [102], Jakobovi and Marasovi [58], Nguyen et al. [86], [103], Nguyen et al. [89, 90, 91], Nie et al. [104, 105], Park et al. [110, 111], Pickardt et al. [118], Qin et al. [122], Hildebrandt and Branke [45], Hildebrandt et al. [47], Hunt et al. [53, 54], Nguyen et al. [96], Park et al. [112], Branke et al. [18], Chen et al. [26], Han et al. [41], Hunt et al. [55, 56], Nguyen et al. [97, 98], Park et al. [113, 114], Shi et al. [128], Sim and Hart [130], Wang et al. [137], Branke et al. [19], Karunakaran et al. [64], Durasevic et al. [31], Freitag and Hildebrandt [35], Hart and Sim [42], Karunakaran et al. [63], Masood et al. [75], Mei et al. [79], Nguyen [84], Nguyen et al. [99], Park et al. [115, 116], Riley et al. [123], Mei and Zhang [78] 
Routing rule  
Due date assignment rule  
Batch formulation rule  
Performance/processing time estimation  
Inserted idle time  Yin et al. [142] 
Nondelay factor  
Improvement/greedy heuristic  Nguyen et al. [85], VazquezRodriguez and Ochoa [136], Mascia et al. [74], Nguyen et al. [88, 92, 93] 
Others  Alsina et al. [3], Baykasoglu and Ozbakr [10], Belisrio and Pierreval [15], Furuholmen et al. [36], Li et al. [73] 
Most previous studies focused on only one component and fixed all other components to reduce the complexity. For example, Tay and Ho [135] applied GP to evolve dispatching rules for flexible job shop scheduling and use the least waiting time assignment [49] to find a suitable machine to process an operation. Similarly, Pickardt et al. [117] evolved dispatching rules for semiconductor manufacturing and used two existing heuristics, i.e. minimum batch size (MBS) and larger batches first (LBF), to control batch formulation. Nguyen et al. [94] used GP to evolve the due date assignment rules while fixing the dispatching rules.
A limited number of studies focused on multiple components simultaneously. For example, Nie et al. [103, 104] considered both dispatching rules and routing rules simultaneously when designing scheduling heuristics for flexible job shop scheduling. Nguyen et al. [95] developed a GP technique to deal with both sequencing decisions and due date assignment decisions. Yin et al. [142] aimed at designing predictive scheduling heuristics using GP to evolve two components, i.e. a dispatching rule and an estimation function to calculate the inserted idle time. Although the above studies showed benefits of evolving multiple components together, it may not be always the case. In the research on order acceptance and scheduling, Park et al. [111] showed that evolving both acceptance rules and dispatching rules is less effective than only focusing on dispatching rules and using a simple rule to reject orders. Therefore, selecting components to be evolved will be problem specific and depends on costs and benefits of the selection.
Representations, function sets, and terminal sets
After determining which component(s) will be evolved by GP, the next critical step is to select the suitable representation(s) for the component(s). In this section, we describe the most popular GP representations employed in the previous studies, especially those used to represent the dispatching rules because they are the main focus of previous studies (as shown in Table 2).
Evolving priority function
The treebased representation of the traditional GP technique [6, 67] and the linear representation in gene expression programming (GEP) [34] are usually applied in the previous studies. For the treebased GP, there are many genetic operators available in the literature [6, 67]. Subtree crossover and subtree mutation are commonly used to evolve scheduling heuristics. The subtree crossover creates new individuals for the next generation by randomly recombining subtrees from two selected parents. Meanwhile, the subtree mutation is performed by selecting a node of a chosen individual and replacing the subtree rooted by that node with a newly randomly generated subtree.
Evolving multiple components
Due to the complexity of production scheduling problems, evolving a single component may not be sufficient to generate effective and comprehensive scheduling heuristics. Therefore, more sophisticated representations have been developed. Geiger et al. [38] propose a multiple tree representation to evolve different dispatching rules (trees) for different machines or groups of machines. The goal of this approach is to generate specialised rules to cope with particular requirements of each machine.
Estimate quality of evolved scheduling heuristics
Similar to any EC methods, GP needs to estimate the quality of heuristics in its population. Here we discuss how evolved heuristics are evaluated and how fitnesses of heuristics are calculated. Recent developed techniques to improve the efficiency of GP evaluations are also presented.
Evaluation models
GP guides the search based on the quality of evolved scheduling heuristics, i.e. fitness values. To calculate the fitness function, a evaluation model or evaluator needs to be developed. Ideally, the evaluation model has to be a good representation of the realworld problems or the environment in which the obtained scheduling heuristics will be applied to. For static scheduling problems, the quality of a heuristic is determined by applying the heuristic to a set of static problem instances, obtained from realworld situations. In the literature, instances from popular benchmark datasets, e.g. ORlibrary [13], or randomly generated based on some assumptions [59, 135], are usually applied to test the quality of different GP methods.
Meanwhile, for dynamic scheduling problems, simulation models are used to determine the steadystate performance of scheduling heuristics. Discrete event simulation (DES) [70] was the main simulation technique to estimate the performance of scheduling heuristics [46, 51, 95]. In previous studies, different theoretical simulation models have been employed. For example, the tenmachine symmetrical job shop model [51] is commonly used to evaluate performance of evolved dispatching rules. Although this model is relatively simple, it can reflect important characteristics of job shops (which is suitable for studies on scheduling decisions) and its scale is reasonable for evaluation purpose. More complex simulation models such as simulation models of semiconductor production systems [118] have also been used to evaluate scheduling heuristics.

Formulate the problem.

Collect data and define a model.

Check if the model assumptions are correct and complete.

Construct and verify a computer program (simulator).

Make pilot runs and validate the programmed model.
Although DES has been shown to be a better way to evaluate the scheduling heuristics in dynamic environments, it is computationally much more expensive. As thousands of evolved scheduling heuristics need to be evaluated by GP, timeconsuming simulation will dramatically increase the running times of GP. In the next sections, we will discuss some techniques that can be used to efficiently utilise the computational budget.
Fitness function

\(r_j\): the release time when job j is available to be processed.

\(w_j\): the weight of job j in the weighted tardiness objective function.

\(d_j\): the due date assigned to job j.

\(C_j\): the completion time of job j.

\(f_j\): the flowtime of job j calculated by \(f_j=C_jr_j\).

\(T_j\): the tardiness of job j calculated by \(T_j=\max (C_jd_j,0)\).

\(\mathbb {C}\): the collection of jobs recorded to calculate the objective values. (\(\mathbb {C}\) is all the jobs in static JSS problem instances or a set of jobs recorded after the warmup period of the simulation of the dynamic job shops).

\(\mathbb {T}=\{j \in \mathbb {C}: C_jd_j > 0\}\): the collection of tardy jobs.
Performance measures of scheduling heuristics
Mean flowtime  \({F} = \frac{\sum _{j \in \mathbb {C}}{f_j}}{\mathbb {C}}\) 
Maximum flowtime  \( {F}_\mathrm{{max}}=\max _{j \in \mathbb {C}}\{ f_j \}\) 
Percentage of tardy jobs  \(\%{T}= 100\times \frac{\mathbb {T}}{\mathbb {C}}\) 
Mean tardiness  \({T}= \frac{\sum _{j \in \mathbb {T}}{(C_jd_j)}}{\mathbb {T}}\) 
Maximum tardiness  \({T}_\mathrm{{max}}= \max _{j \in \mathbb {T}}\{C_jd_j\}\) 
Makespan  \({C}_\mathrm{{max}} = \max _{j \in \mathbb {C}}\{ C_j \}\) 
Total weighted tardiness  \(\text {TWT} = \max _{j \in \mathbb {T}}\{w_j \times (C_jd_j)\}\) 

Sum [or average] of objective values \(fitness(\mathcal {H}) = [\frac{1}{T}] \sum _{i=1}^{T}{z_i(\mathcal {H})}\)

Average relative objective value \(fitness(\mathcal {H}) = \frac{1}{T} \sum _{i=1}^{T}{\frac{{z_i(\mathcal {H})}}{{z_i(\mathrm{ref})}}}\)

Sum [or average] of relative deviations \(fitness(\mathcal {H}) = [\frac{1}{T}] \sum _{i=1}^{T}{\frac{{z_i(\mathcal {H})}{z_i(\mathrm{ref})}}{{z_i(\mathrm{ref})}}}\)
As discussed previously, the evaluations of scheduling heuristics can be very time consuming, a full evaluation with a large number of training instances to calculate the fitness function is slow. Because GP usually requires a large population (hundreds to thousands of individuals), full evaluations for the whole population could be computationally too expensive. Therefore, most past studies did not use full evaluations to calculate the fitness function and replaced them with much cheaper evaluations as discussed in “Evaluation models”. Hildebrandt et al. [46] showed that it is possible to evolve effective dispatching rules for dynamic job shop using a single simulation replication per generation. The random seed for the simulation will be changed in each generation to improve the diversity in the population. They also gave high penalties for heuristics causing instability in the simulated shop as they will slow down the evaluation process and usually are bad scheduling heuristics. This is particularly true in early generations of GP since the chance to generate bad scheduling heuristics are very high.

Early termination of the simulation: stop the simulation when the number of jobs in the system exceed some predefined threshold [46].

Use a small number of simulation replications but change the random seed for each replication when moving to a new generation [46, 99].

Avoid evaluating the same evolved rules [45].

Surrogate models: reduce the evaluation costs caused by expensive simulation [45, 99].
Surrogateassisted models
Recently, surrogate models have been proposed to reduce the computational costs of GP [45, 96, 99]. These models have reduced the evaluation costs of GP and improved its convergence. Hildebrandt and Branke [45] proposed a surrogate model based on the phenotypic characterisation of evolved priority functions. In this technique, the phenotype of an evolved heuristic is characterised by a decision vector with the dimension of K, where K is the number of decision situations (each decision situation includes a number of jobs to be prioritised). Figure 10 gives an example of how decision vector is determined. First, a reference rule (e.g. 2PTWINQNPT) is selected and applied to all decision situation. The ranks of jobs (smaller ranks for jobs with higher priorities) in each situation determined by the reference rule are recorded. For each evolved priority function, the corresponding ranks are also determined and the decision value for each decision situation is the rank determined by the reference rule of the job whose rank obtained by the evolved priority function is 1. In Fig. 10, the decision vectors for rule 1 and rule 2 are \(\langle 3,1,\ldots ,3\rangle \) and \(\langle 2,2,\ldots ,1\rangle \), respectively. An archive is used to store past explored rules and their decision vector and are recorded during GP evolution. During the reproduction process, the fitness of a new generated rule is approximated by the fitness of the closest rule in the archive based on the distance between their corresponding decision vectors. This surrogate model, even though simple, can provide good estimation of fitness and help screening out bad rules created by crossover and mutation.
Also trying to reduce the computational times of GP for automated heuristic design [99] proposed a new technique to estimate the fitness of evolved rules using a simplified version of the original simulated shop, as shown in Fig. 11. Instead of evaluating evolved heuristics with the model of the original shop which can be very large, a smaller model of the shop is created with a smaller number of machines, smaller simulation length while maintaining the same level of utilisation, due date tightness, etc. A set of benchmark rules are applied to different models and their objective values are recorded. The simplified model that has the highest rank correlation with the original model will be used to estimate the fitness of newly generated rules. Then, only the ones with the highest estimated fitness are moved to the next generation and estimated by the original model. The proposed GP technique based on this simplified model showed better results as compared to other GP techniques.

Real fitness function: requires a lot of simulation replications and it is the most expensive fitness function. This should be used to validate the performance of selected evolved heuristics.

Generational fitness function: identify the most potential heuristics for real fitness evaluations. The generational fitness function can use a small number of replications to reduce the computational costs but new training instances are used for each generation to prevent GP from overfitting and improve the diversity of the population [46].

Fitness estimated by surrogate models: determines the rough quality of generated heuristics. Because the likelihood to produce bad heuristics via crossover and mutation by GP is very high, GP may waste a lot of time evaluating bad heuristics. The fitness estimated efficiently by surrogate models [45, 99] helps the algorithm screen out heuristics with poor performance and reduce the computational costs as well as improve the convergence of GP.
Figure 12 illustrates the tradeoffs between the accuracy and computational costs of different models used to evaluate the performance of evolved scheduling heuristics. In this figure, full evaluations are the one with the best accuracy and the highest computational times while evaluations with static training instances are the most efficient ones but may cause overfitting issues [46, 89]. Surrogateassisted GP can be designed to effectively use these models in the algorithm. Currently, surrogate models are only used as the preselection strategy [62]. Other applications of surrogate models in GP can be also investigated in future studies (e.g. individualbased, generationbased and populationbased techniques).
Search mechanisms
Most GP techniques proposed in the literature for automated design of production scheduling heuristics imitate Darwinian biological evolution by maintaining and evolving a large population. Genetic operators inspired by natural evolution such as crossover, mutation, and elitism (as discussed in “Representations, function sets, and terminal sets”) are used to generate new individuals. Despite its simplicity, this mechanism is able to discover very effective scheduling heuristics. However, to deal with more complicated design issues such as multiple scheduling decisions and multiple conflicting objectives, specialised search mechanisms will be needed.
Evolutionary multiobjective optimisation
Multiple conflicting objectives are a natural characteristic in realworld applications and the design of new scheduling heuristics also need to consider this issue. One advantage of using GP for designing heuristics is that their search mechanisms are very flexible and many advanced EC techniques [27, 61, 133] have been developed to cope with multiple objectives.
Tay and Ho [135] aimed to tackle three objectives (makespan, mean tardiness, and mean flowtime) when using GP to evolve dispatching rules for a flexible job shop. To simplify the design problem, the three objectives are aggregated using the weighted sum approach with the same weight for each objective. However, because the scale of each objective and the knowledge about the objective search space may be unknown in advance, this approach can lead to unsatisfactory results. For this reason, the rules evolved by their GP method are sometimes worse than simple rules such as FIFO Freitag and Hildebrandt [135]. When these evolved rules are examined in a long simulation [46], they are only slightly better than the earliest release date (ERD) rule and worse than the SPT rule with respect to mean tardiness. It suggests that using the weighted aggregated objective to deal with multiobjective design problem is not a good approach if the prior knowledge about the individual objective is not available.
Nguyen et al. [90] developed a multiobjective genetic programmingbased hyperheuristic (MOGPHH) for dynamic job shop scheduling. In this work, the goal is to evolve a set of nondominated dispatching rules for five common objective functions in the literature. By relying on the Pareto dominance rather than any specific objective, the proposed MOGPHH was able to evolve very competitive rules as compared to existing benchmark rules in the literature. Their results showed that it is very easy for MOGPHH to find rules that totally dominate simple rules such as FIFO and SPT regarding all five considered objectives. The proposed MOGPHH can also find rules that dominate more sophisticated rules such as ATC, RR, 2PT+WINQ+NPT, and COVERT [125] in most of its runs. The experimental results showed that the obtained Pareto front contains many dispatching rules with good tradeoffs that have not been explored earlier in the literature (e.g. percentage of tardy jobs \(\%\)T can be reduced greatly without significantly deteriorating other objectives). Similar observations for a complex semiconductor manufacturing system are found by [35]. Thus, evolving the Pareto front is more beneficial as compared to evolving a single rule generally. Similar methods have been applied to evolve comprehensive scheduling policies for dynamic job shop scheduling [95] and order acceptance and scheduling [84] and showed promising results.
Masood et al. [75] proposed to combine the advantage of GP and NSGAIII to evolve a set of Paretooptimal dispatching rules for manyobjective job shop scheduling. The proposed algorithm uses the treebased representation and evolutionary operators of GP and the fitness assignment scheme (i.e. nondominated sorting and reference points) of NSGAIII. They further extended their work [76] by taking the discrete and possibly nonuniform Pareto front into account. To search for the nonuniform Pareto front more efficiently, they proposed a scheme to adaptively adjust the positions of the reference points using particle swarm optimisation.
Coevolution
Miyashita [81] proposes three multiagent learning structures based on GP to evolve dispatching rules for dynamic job shop scheduling. The first one is a homogeneous agent model, which is basically the same as other GP techniques which evolve a single dispatching rule for all machines. The second model treated each machine (resource) as a unique agent which requires distinct heuristics to prioritise jobs in the queue. In this case, each agent has its own population to coevolve heuristics with GP. Finally, this research proposed a mixed agent model in which resources are grouped based on their status. Two types of agents in this model are the bottleneck agent and the nonbottleneck agent. Because of the strong interactions between agents, credit assignment is difficult. Therefore, the performance of each agent is directly measured by the quality of the entire schedule. The experimental results show that the distinct model has better training performance compared to the homogeneous model. However, the distinct model has overfitting issues because of the too specialised rules (for single/local machines). The mixed agent model shows the best performance among the three when tested under two different shop conditions. The drawback of this model is that it depends on some prior knowledge (i.e. bottleneck machines) of the job shop environment, which can be changed in dynamic situations.
To deal with multiple scheduling decisions (sequencing and due date assignment) in job shops, Nguyen et al. [95] develop a GPbased cooperative coevolution approach in which scheduling rules and due date assignment rules are evolved in their own subpopulation. Similar to Miyashita [81], the fitness of each rule is measured by the overall performance obtained through cooperation. Specialised crossover, archiving and representation strategies are also developed in this study to evolve the Pareto front of nondominated scheduling heuristics. The results show that the cooperative coevolution approach is very competitive compared to some other evolutionary multiobjective optimisation approaches. The analysis also indicates that the proposed cooperative coevolution approach can generate more diverse sets of nondominated scheduling heuristics.
In another study, Beham et al. [14] utilised parallel technologies to evolve dispatching rules for a flexible job shop with a large terminal and function sets. They developed three new GP methods based on island models and SASEGASA [2] in which rules are evolved in multiple subpopulations. The results show that the SASEGASA method can cope better with the states of exception in the simulation than islandbased methods. In a very recent study, Karunakaran et al. [63] investigated GP with different topologies of the island model to deal with multiobjective job shop scheduling. Their experimental results showed that the proposed techniques outperform some generalpurpose multiobjective optimization methods, including NSGAII and SPEA2.
Park et al. [116] proposed two GP techniques to evolve ensembles of dispatching rules based on Multilevel Genetic Programming (MLGP) [140] and cooperative coevolution [121]. While MLGP aims at automatically finding a group of individuals that work together effectively, the cooperative coevolution uses decomposition approaches to coevolve multiple subpopulations. The experimental results showed that MLGP outperformed the simple GP technique with no significant increase in computational times. Meanwhile, the cooperative coevolution technique are better than MLGP in terms of performance of evolved rules but significantly slower than MLGP.
Other search mechanisms
Nguyen et al. [97] developed a new technique called automatic programming via iterated local search (APRILS) to design dispatching rules for dynamic job shop scheduling. APRILS used treebased representation similar to GP but it employed iterated local search to search for the best rule instead of populationbased search in most studies. In the proposed algorithm, the neighbour heuristics are created by applying subtree mutation (but only small random subtree is generated). To help the algorithm escape from the local optimum, subtree mutation and subtree extraction operators are used. Given a fixed number of fitness evaluations, the experimental results showed that APRILS is significantly better than simple GP with the treebased representation in terms of performance of evolved heuristics, program lengths, and the running times.
Hart and Sim [42] developed a hyperheuristic based on an ensemble method called NELLI [131]. The proposed NELLIGP extends NELLI by evolving a set of dispatching rules represented as an expression tree. NELLI uses a method inspired by Artificial Immune Systems [25] to evolve a set of heuristics, which are behaviourally diverse in the sense that each solves different subsets of a large instance set. The three main components of NELLIGP are: (1) a heuristic generator to generate new scheduling heuristics, (2) sets of problem instances, and (3) a network inspired by the idiotypic network theory of the immune system. The key idea is to evolve ensembles of heuristics that interact to cover a problem space. The experiments showed that NELLIGP can produce promising results.
Pickardt et al. [118] proposed a twostage approach to evolve dispatching rule sets for semiconductor manufacturing. In the first stage, GP is used to evolve general dispatching rules. The best obtained dispatching rule is combined with a list of benchmark dispatching rules to generate a set of candidate rules. In the second stage, a \(\mu + \lambda \) evolutionary algorithm (EA) is used to select the most suitable dispatching rule in the set of candidate rules for each work centre in the shop. The experiments compared the performance of the twostage hyperheuristics with the pure GP and EA hyperheuristics. The results show that the three hyperheuristics outperformed benchmark dispatching rules and the twostage hyperheuristics produced significantly better performance than the other two hyperheuristics.
Postprocessing

Simplification of obtained heuristics.

Visualisation.

Analyse feature usage within obtained heuristics.

Analyse code fragment.

Relearn obtained heuristics.
Visualisation is also an attractive alternative to interpret the evolved scheduling heuristics. Branke et al. [18] used contour plot to visualise priorities as the functions of attributes. Nguyen et al. [99] used parallel coordinate plot which is able to show how priorities change with different combinations of attributes. These visualisation techniques are helpful to show the general characteristics of the evolved heuristics and the differences between different heuristics. However, it is still hard to fully understand the complex behaviours of evolved scheduling heuristics.
Analysing the usages of attributes included in the evolved scheduling heuristics has also been done in the literature to understand the contributions of these attributes. For example, Nguyen et al. [89] analyses the frequency usage of attributes in the final dispatching rules evolved by GP to show what are the most useful attributes. Branke et al. [18] analysed the importance of each attribute by measuring the performance of the best rules when certain attributes are not available. Their analyses show that some attributes are more important for specific representations. Instead of independently investigating each attribute, Hunt et al. [55] performed fragment analyses to show the most common fragments (with the depth of two) in the evolved scheduling heuristics. The analyses show that some fragments representing the differences between due date, machine ready time, and current time appear most often in the evolved heuristics. The analyses also showed that most frequent fragments from different GP techniques can be different.
Since the evolved heuristics are usually complicated, Nguyen et al. [99] attempted to apply supervised machine learning techniques to relearn the scheduling heuristics obtained by GP. Random sampling are applied to randomly pick pairs of jobs and decide which one has the higher priority based on the heuristics to be relearned. From the collected data, a binary classification problem is created. In this problem, the attributes are the relative attributes of the two jobs and the label is whether or not the first job has a higher priority than the second one. Decision tree has been applied as the obtained decision tree is easy to understand and more important attributes can be easily detected (usually in the top of the decision tree).
Evaluating GP methods
The performance of a GP method is measured by the performance of the evolved scheduling heuristics. Similar to traditional studies in the scheduling literature, scheduling heuristics are evaluated based on the quality of obtained scheduling solutions (usually the average objective value from a set of test problem instances), the robustness (i.e. the test performance in unseen scenarios), and the computational times. Wellknown benchmark instances in the scheduling literature [4, 29, 71, 132] are commonly used for evaluation purposes. Some random instance generators [42, 59, 135] are also applied to generate training and test instances for GP. However, these are mainly used for static production scheduling problems. For dynamic stochastic scheduling problems, DES (as discussed in“Evaluation models”) is typically applied. Most DES simulators are developed by researchers to cope with their GP systems and specific research objectives. [20] suggested that the publication of entire simulators (e.g. Jasima from [44]) would greatly help replicability and facilitate fair comparisons.
For a new application of GP, it is important to compare evolved scheduling heuristics with the stateoftheart heuristics in the literature to demonstrate its effectiveness [46, 59, 89, 135]. As discussed in “Evolutionary multiobjective optimisation”, these comparisons can reveal interesting insights about evolved heuristics [90]. When comparing different GP methods, the average (relative) objective values of obtained scheduling heuristics are the primary performance measures. The complexity of evolved heuristics, i.e. often measured in terms of the lengths of GP individuals, is also used to compare GP methods [97, 99]. Interpretability has been recently investigated when comparing different hyperheuristics methods [18, 55]. For multiobjective scheduling problems, common EMO metrics such as hypervolume and inverted generational distance can be used to measure the quality of the obtained tradeoff heuristics [75, 95].
In this section, we have discussed key components for automated design of scheduling heuristics with GP and showed how these components are connected under a unified framework. For each component, the basic setting as well as the more advanced techniques developed for complex situations have been presented. The new techniques have been developed based on the needs of discovering more effective and interpretable scheduling heuristics while reducing the computational times. Although there have been many fruitful studies in the last five years, many issues still remain unsolved and require more studies in the future.
Connections with other artificial intelligence (AI) and operations research (OR) techniques
Automated heuristic design is a relatively new area of research and has attracted much attention of many researchers in AI and OR. In previous studies, both machine learning and operations research techniques have been applied within automated heuristic design. In the rest of this section, we discuss different ways that machine learning and operations research can be used to enhance the way GP evolves production scheduling heuristics.
Machine learning
In most previous studies, GP is used as a unsupervised learning technique to learn the most effective heuristics for scheduling problems. GP has to discover both the heuristic structures as well as the corresponding parameters. From this viewpoint, automated heuristic design can be simply treated as an optimisation problem where the objective function is the fitness function to evaluate the quality of heuristics. As the search space of GP is very large, searching for (near) optimal heuristics is very challenging and it is even more difficult if there are many attributes or features to be considered (in the terminal set). To deal with this issue, feature selection are needed to remove redundant attributes which may influence the performance of GP. Mei et al. [79] has shown that selecting a good feature subset can significantly improve the performance of GP, i.e. finding better scheduling heuristics. Feature construction [52] and feature extraction will be also an interesting aspects that need to be considered in the future studies.
Supervised learning techniques such as decision tree [107, 127], logistic regression [57], support vector machines [129], and artificial neural networks [32, 138] have also been investigated in the literature for automated design of production scheduling heuristics. For supervised learning, optimal decisions from solving small instances with exact optimisation methods or from the historical data are needed to build the training set. However, there are a number of challenges with supervised learning. As scheduling decisions are highly interdependent (i.e. the decision for an operation may influence decision of other operations), learning the optimal decisions for the whole schedule will not be easy. If the goal is to determine which dispatching rules to apply given a set of jobs and system status, there is also no guarantee that the learned heuristics will actually provide the (near) optimal solution as the available dispatching rules may not be effective (similar to the cases when historical data are used). Nguyen et al. [93] proposed a sequential GP to learn a set of rules that can learn optimal scheduling decisions for order acceptance and scheduling problem. The training set is a number of decision situations which the optimal decisions obtained by exact methods. The obtained heuristics are very efficient and are competitive as compared to customised metaheuristics developed in the literature. Combining the power of advanced supervised machine learning techniques with GP would be an interesting research direction in the future.
The scheduling literature has covered a wide range of scheduling problems. In production scheduling, many popular problems have been investigated intensively such as single machine scheduling, parallel machine scheduling, (flexible) flow shop scheduling, (flexible) job shop scheduling, and open shops. There is shared knowledge between these problems which can be used to develop different heuristics (e.g. ATC can be extend to ATCS to deal with setup dependent scheduling problems). Clearly, transfer learning [7, 33] and multitask learning [8, 40, 108] will be very useful in automated design of production scheduling heuristics. The knowledge to solve a simple scheduling problem can be reused to solve hard problems and scheduling jobs at different machines can be based on some common pieces of knowledge.
Operations research

Continuous simulation In some cases, production systems need continuous simulation method [70] as the states of the system change continuously [48] like the movement of liquids (e.g. oil, chemical) or the steel making process. Scheduling with the continuous production process is an interesting topic and continuous simulation or hybrid simulation combining both DES and continuous simulation will be useful (e.g. in food industry).

Multiagent simulation To gain better understandings of the system and investigate how individual behaviours may influence the overall performance, multiagent simulation, a powerful technique in OR and AI, will be a more suitable method. Miyashita [81] investigated different GPbased agent models and showed interesting preliminary results. In the future studies, different realworld aspects (e.g. human factors) should be considered to see how GPbased agents will behave.

Simulation optimisation Automated design of production scheduling heuristics can be treated as simulation optimisation problems as the fitness of heuristics is stochastic. Then, many advanced techniques developed in simulation optimisation can be applied in this case to improve the accuracy of fitness evaluations and improve the efficiency of GP.
Current issues and challenges
There are many issues that are worth considering in the future studies. Here we point out three key issues needed to be addressed if we want to apply automated heuristic design in practice.
Dynamic changes
Dynamic changes are unavoidable in the realworld applications and coping with this issue is essential. Traditional optimisation methods could not handle dynamic change well. Fortunately, scheduling heuristics evolved by GP can cope very well with the dynamic changes. Basically, these heuristics can deal easily with most dynamic changes such as dynamic job arrivals, machine breakdowns, and stochastic processing times. However, to improve the quality as well as the robustness of evolved heuristics, the problem domain knowledge is needed. Either the knowledge is provided to GP by the researchers or automatically extracted from the environment will need further investigation.

Completely reactive scheduling no schedule is generated in advance and decisions are made in real time. Priority dispatching rules are the main techniques for completely reactive scheduling.

Predictivereactive scheduling scheduling/rescheduling is triggered by the realtime events where both objectives of interest and stability (measured by the deviation from original schedule) are considered.

Robust proactive scheduling focus on building predictable schedules; the key idea is to improve the predictability of the schedules in a dynamic environment (e.g. by inserting additional time in the predictive schedule) with minimal effects on the schedule performance.
Multiple decisions
Previous studies on production planning and scheduling focused mainly on scheduling or sequencing decisions and assumed that other related decisions are fixed. For example, the due date assignment rules (e.g. total work content) and the job release policy (e.g. immediate release) are fixed and we try to find the best scheduling heuristics. These assumptions reduce the computational burden of the optimisation or learning techniques, but they also restrict us from developing an effective comprehensive systems. It should be noted that past studies are limited by manual designs of scheduling heuristics and computational power, which is not a serious issue now. The automated heuristic design and the growing computing power provide us with the chance to consider a much wider scope.
However, to effectively handle multiple decisions, better search mechanisms will need to be developed. There are two common approaches to dealing with multiple decisions. The first approach creates a sophisticated representation that contains two or more decision rules and programs based on this representation are evolved and reproduced based on some customised genetic operators. The second approach is to apply cooperative coevolution technique to coevolve multiple subpopulations for multiple decision rules. In these two approaches, each rule is constructed based on an independent set of terminals and functions. Since each decision rule has its own characteristic, it is not necessary to use GP to evolve all the rules. For example, supervised learning (e.g. regression) can be used to estimate due dates of randomly arriving jobs given a fixed dispatching rule. It would be useful to investigate how GP can be combined with other machine learning techniques to deal with multiple decisions in production planning and scheduling.
Multiple conflicting objectives
Similar to multiple decisions, GP allows the researchers to cope with multiple conflicting objectives in various ways. Using pure EMO search mechanisms such as NSGAII [28] may have troubles dealing with this designing problems because of a number of reasons. First, the search space for GP to explore can be very large because of the number of terminals, functions sets, and the number of objectives to be optimised. Therefore, it will be much harder for the search methods to find a good set of nondominated heuristics. Second, GP usually requires a large population to maintain a large and diverse genetic materials to create effective scheduling heuristics, especially when dealing with multiple conflicting objectives. As a result, more heuristic evaluations will be needed, which significantly increases the computational costs of GP. Finally, it will be more difficult to understand how the tradeoffs are achieved via the evolved heuristics (it has been already very hard to understand scheduling heuristics in the case of optimising a single objective). In addition, how to measure the robustness of scheduling heuristics (when they are applied to different/unseen scenarios) is still a open research question.

Developing more specialised genetic operators and local search heuristics to improve the search effectiveness and efficiency.

Incorporating user’s preferences to guide the search of GP to improve the efficiency of GP.

Developing new surrogated assisted GP to reduce the computational costs of GP and improve its effectiveness.

Developing new representations to allow GP to deal with multiple objectives effectiveness and improve the interpretability of evolved scheduling heuristics.
Other challenges
Developing an efficient, effective, and scalable GP systems for evolving scheduling heuristics will continue to be a major challenge for the research community. As the realworld production systems can be very complicated with many different types of resources and technical constraints, many attributes need to be considered to construct heuristics and the search space of scheduling heuristics can be very large. The key point for future research is to enhance the search mechanism of GP so that GP is able to evolve effective sophisticated structures of scheduling heuristics and optimise their related parameters for complex production environments. As mentioned earlier, transfer learning can be an interesting research topic for GP to reuse the knowledge obtained from handling different scheduling problems.
Conclusions
Automated design of production scheduling heuristics is an interesting and challenging research area which has a lot of potential applications. GP has been the most popular technique for the automated design tasks in the last several years. Different from existing survey papers that focused on general ideas and taxonomies, the goal of this paper is to emphasise on the technical issues when using GP to evolve production scheduling heuristics. In this paper, we discussed the key issues related to automated design of scheduling heuristics with GP including metaalgorithms of scheduling heuristics, selection of component(s) to be evolved, representations, evaluation models, fitness functions, search mechanism and postprocessing. A unified framework was developed to provide beginning researchers with an overall picture of all essential steps, components, and their connections when developing a GP system for automated design of production scheduling heuristics. Through analyses of each component, we also pointed out the strength and weakness of each technique proposed in the literature and provided hints for future studies. Representations, evaluation models, and postprocessing are still three main research directions to be explored as they can directly influence the applicability of these techniques in practice. Researchers from GP communities can develop better representations and genetic operators to help GP discover more powerful and more interpretable scheduling heuristics. Advanced knowledge from the fields of simulation and optimisation of expensive functions can be very useful when systematically applied to GP. For postprocessing, it is a space for creativeness, in which the goal is to explain how the evolve how discovered heuristics work, its sensitivity, and the reliability of decisions made by the heuristic.
Automated design of production scheduling heuristics is a multidisciplinary and interdisciplinary research area where the knowledge from operations research and artificial intelligence is required. Scheduling has its root from operation research and many clever techniques have been proposed in the literature. It would be interesting to see how GP can assist to make scheduling research more productive. For AI, automated heuristics design will greatly enlarge the scope of machine learning applications from traditional prediction tasks to making optimal decisions based on historical operational data. In addition, many aspects from supervised learning, unsupervised learning, and transfer learning will need to be investigated in the context of automated heuristic design.
Production environments can be complex and it is critical for GP to handle key issues that commonly occur in realworld situations such as dynamic changes, multiple decisions, and multiple conflicting objectives. Although many issues can be handled directly by GP (e.g. reactively dealing with dynamic changes), some have not been investigated or have not had a satisfactory solutions. In addition, many aspects discussed here will be true for other scheduling and combinatorial optimisation problems and we expect that more applications will appear in the near future.
References
 1.Abednego L, Hendratmo D (2011) Genetic programming hyperheuristic for solving dynamic production scheduling problem. In: IEEE 2011 international conference on electrical engineering and informatics (ICEEI)Google Scholar
 2.Affenzeller M, Wagner S (2004) SASEGASA: a new generic parallel evolutionary algorithm for achieving highest quality results. J Heuristics 10(3):243–267CrossRefGoogle Scholar
 3.Alsina EF, Capodieci N, Cabri G, Regattieri A, Gamberi M, Pilati F, Faccio M (2015) The influence of the picking times of the components in time and space assembly line balancing problems: an approach with evolutionary algorithms. In: 2015 IEEE symposium series on computational intelligence, pp 1021–1028Google Scholar
 4.Applegate D, Cook W (1991a) A computational study of the jobshop scheduling instance. ORSA J Comput 3(2):149–156zbMATHCrossRefGoogle Scholar
 5.Applegate D, Cook W (1991b) A computational study of the jobshop scheduling problem. ORSA J Comput 3(2):149–156zbMATHCrossRefGoogle Scholar
 6.Banzhaf W, Nordin P, Keller R, Francone F (1998) Genetic programming: an introduction. Morgan Kaufmann, San FranciscozbMATHCrossRefGoogle Scholar
 7.Baxter J (1998) Theoretical models of learning to learn. In: Thrun S, Pratt L (eds) Learning to learn. Springer US, Boston, pp 71–94. doi: 10.1007/9781461555292_4
 8.Baxter J (2000) A model of inductive bias learning. J Artif Int Res 12(1):149–198MathSciNetzbMATHGoogle Scholar
 9.Baykasoglu A (2008) Gene expression programming based metamodelling approach to production line design. Int J Comput Integr Manuf 21:657–665CrossRefGoogle Scholar
 10.Baykasoglu A, Ozbakr L (2015) Discovering task assignment rules for assembly line balancing via genetic programming. Int J Adv Manuf Technol 76:417–434CrossRefGoogle Scholar
 11.Baykasoglu A, Gocken M, Ozbakir L (2010) Genetic programming based data mining approach to dispatching rule selection in a simulated job shop. SIMULATION Trans Soc Model Simul 86:715–728CrossRefGoogle Scholar
 12.Baykasolu A, Gken M (2009) Gene expression programming based due date assignment in a simulated job shop. Expert Syst Appl 36(10):12143–12150CrossRefGoogle Scholar
 13.Beasley JE (1990) Orlibrary: distributing test problems by electronic mail. J Oper Res Soc 41(11):1069–1072CrossRefGoogle Scholar
 14.Beham A, Winkler S, Wagner S, Affenzeller M (2008) A genetic programming approach to solve scheduling problems with parallel simulation. In: Wu J, Robert Y (eds) Proceedings of the 2008 IEEE International Parallel & Distributed Processing Symposium. IEEE Computer Society Press, Los Alamitos, CA, pp 1–5Google Scholar
 15.Belisrio LS, Pierreval H (2015) Using genetic programming and simulation to learn how to dynamically adapt the number of cards in reactive pull systems. Expert Syst Appl 42(6):3129–3141CrossRefGoogle Scholar
 16.Bierwirth C, Mattfeld DC (1999) Production scheduling and rescheduling with genetic algorithms. Evol Comput 7(1):1–17CrossRefGoogle Scholar
 17.Brameier MF, Banzhaf W (2010) Linear genetic programming, 1st edn. Springer Publishing Company, Incorporated, BerlinzbMATHGoogle Scholar
 18.Branke J, Hildebrandt T, ScholzReiter B (2015) Hyperheuristic evolution of dispatching rules: a comparison of rule representations. Evol Comput 23(2):249–277CrossRefGoogle Scholar
 19.Branke J, Groves MJ, Hildebrandt T (2016a) Evolving control rules for a dualconstrained job scheduling scenario. In: Proceedings of the 2016 Winter Simulation Conference, Winter Simulation ConferenceGoogle Scholar
 20.Branke J, Nguyen S, Pickardt CW, Zhang M (2016b) Automated design of production scheduling heuristics: a review. IEEE Trans Evol Comput 20(1):110–124CrossRefGoogle Scholar
 21.Burke EK, Hyde M, Kendall G, Woodward J (2007) Automatic heuristic generation with genetic programming: evolving a jackofalltrades or a master of one. In: GECCO ’07: Proceedings of the 9th annual conference on genetic and evolutionary computation. ACM Press, New York, pp 1559–1565Google Scholar
 22.Burke EK, Hyde MR, Kendall G, Ochoa G, Ozcan E, Woodward JR (2009) Exploring hyperheuristic methodologies with genetic programming. In: Mumford C, Jain L (eds) Computational intelligence, intelligent systems reference library, vol 1. Springer, Berlin, pp 177–201Google Scholar
 23.Burke EK, Hyde M, Kendall G, Ochoa G, Ozcan E, Woodward JR (2010) A classification of hyperheuristic approaches. In: Handbook of metaheuristics, international series in operations research & management science, vol 146. Springer, New York, pp 449–468Google Scholar
 24.Burke EK, Gendreau M, Hyde M, Kendall G, Ochoa G, Ozcan E, Qu R (2013) Hyperheuristics: a survey of the state of the art. J Oper Res Soc 64(12):1695–1724CrossRefGoogle Scholar
 25.Castro LRd, Timmis J (2002) Artificial immune systems: a new computational intelligence paradigm. SpringerVerlag New York Inc, secaucuszbMATHGoogle Scholar
 26.Chen L, Zheng H, Zheng D, Li D (2015) An ant colony optimizationbased hyperheuristic with genetic programming approach for a hybrid flow shop scheduling problem. In: CEC’15: IEEE congress on evolutionary computationGoogle Scholar
 27.Coello Coello CA (1999) A comprehensive survey of evolutionarybased multiobjective optimization techniques. Knowl Inf Syst 1(3):269–308CrossRefGoogle Scholar
 28.Deb K, Pratap A, Agarwal S, Meyarivan T (2002) A fast and elitist multiobjective genetic algorithm: NSGAII. IEEE Trans Evol Comput 6(2):182–197CrossRefGoogle Scholar
 29.Demirkol E, Mehta S, Uzsoy R (1998) Benchmarks for shop scheduling problems. Eur J Oper Res 109(1):137–141. doi: 10.1016/S03772217(97)000192 zbMATHCrossRefGoogle Scholar
 30.Dimopoulos C, Zalzala AMS (2001) Investigating the use of genetic programming for a classic onemachine scheduling problem. Adv Eng Softw 32(6):489–498zbMATHCrossRefGoogle Scholar
 31.Durasevic M, Jakobovi D, Kneevi K (2016) Adaptive scheduling on unrelated machines with genetic programming. Appl Soft Comput 48:419–430CrossRefGoogle Scholar
 32.Eguchi T, Oba F, Toyooka S (2008) A robust scheduling rule using a neural network in dynamically changing jobshop environments. Int J Manuf Technol Manag 14(34):266–288Google Scholar
 33.Feng L, Ong YS, Lim MH, Tsang IW (2015) Memetic search with interdomain learning: a realization between CVRP and CARP. IEEE Trans Evol Comput 19(5):644–658CrossRefGoogle Scholar
 34.Ferreira C (2006) Gene expression programming: mathematical modeling by an artificial intelligence, 2nd edn. Springer, BerlinzbMATHGoogle Scholar
 35.Freitag M, Hildebrandt T (2016) Automatic design of scheduling rules for complex manufacturing systems by multiobjective simulationbased optimization. CIRP Ann Manuf Technol 65(1):433–436CrossRefGoogle Scholar
 36.Furuholmen M, Glette K, Hovin M, Torresen J (2009) Coevolving heuristics for the distributor’s pallet packing problem. In: CEC’09: IEEE congress on evolutionary computation, pp 2810–2817Google Scholar
 37.Geiger CD, Uzsoy R (2008) Learning effective dispatching rules for batch processor scheduling. Int J Prod Res 46(6):1431–1454zbMATHCrossRefGoogle Scholar
 38.Geiger CD, Uzsoy R, Aytu H (2006) Rapid modeling and discovery of priority dispatching rules: an autonomous learning approach. J Sched 9(1):7–34zbMATHCrossRefGoogle Scholar
 39.Giffler B, Thompson GL (1960) Algorithms for solving productionscheduling problems. Oper Res 8(4):487–503MathSciNetzbMATHCrossRefGoogle Scholar
 40.Gupta A, Ong Y, Feng L (2016) Multifactorial evolution: toward evolutionary multitasking. IEEE Trans Evol Comput 20(3):343–357CrossRefGoogle Scholar
 41.Han S, Seo J, Park J (2012) Designing an effective scheduling scheme considering multilevel BOM in hybrid job shop. In: Proceedings of the 2012 international conference on industrial engineering and operations management, pp 1302–1310Google Scholar
 42.Hart E, Sim K (2016) A hyperheuristic ensemble method for static jobshop scheduling. Evol Comput. doi: 10.1162/EVCO_a_00183
 43.Hart E, Ross P, Corne D (2009) Evolutionary scheduling: a review. Genetic Program Evol Mach 6(2):191–220CrossRefGoogle Scholar
 44.Hildebrandt T (2014) Jasima an efficient java simulator for manufacturing and logistics. http://code.google.com/p/jasima/
 45.Hildebrandt T, Branke J (2014) On using surrogates with genetic programming. Evol Comput 23(3):343–367CrossRefGoogle Scholar
 46.Hildebrandt T, Heger J, ScholzReiter B (2010) Towards improved dispatching rules for complex shop floor scenarios a genetic programming approach. In: Pelikan M, Branke J (eds) GECCO ’10: Proceedings of the 12th annual conference on genetic and evolutionary computation. ACM Press, Portland, Oregon, USA, pp 257–264Google Scholar
 47.Hildebrandt T, Goswami D, Freitag M (2014) Largescale simulationbased optimization of semiconductor dispatching rules. In: Proceedings of the 2014 winter simulation conference, pp 2580–2590Google Scholar
 48.Hmida JB, Lee J, Wang X, Boukadi F (2014) Production scheduling for continuous manufacturing systems with quality constraints. Prod Manuf Res 2(1):95–111Google Scholar
 49.Ho NB, Tay JC (2004) GENACE: An efficient cultural algorithm for solving the flexible jobshop problem. In: Evolutionary computation, 2004. CEC2004. Congress on, IEEE, vol 2, pp 1759–1766Google Scholar
 50.Ho NB, Tay JC (2005) Evolving dispatching rules for solving the flexible jobshop problem. In: IEEE congress on evolutionary computation, vol 3, pp 2848–2855. doi: 10.1109/CEC.2005.1555052
 51.Holthaus O, Rajendran C (2000) Efficient jobshop dispatching rules: further developments. Prod Plan Control 11(2):171–178CrossRefGoogle Scholar
 52.Hunt R (2016) Genetic programming hyperheuristics for job shop scheduling. PhD thesis, Victoria University of Wellington, http://researcharchive.vuw.ac.nz/handle/10063/5219
 53.Hunt R, Johnston M, Zhang M (2014) Evolving lessmyopic scheduling rules for dynamic job shop scheduling with genetic programming. In: Igel C, Arnold DV (eds) GECCO ’14: Proceedings of the 2014 conference on genetic and evolutionary computation. ACM Press, New York, pp 927–934Google Scholar
 54.Hunt R, Johnston M, Zhang M (2014) Evolving machinespecific dispatching rules for a twomachine job shop using genetic programming. In: Liu D, Hussain A, Zeng Z, Zhang N (eds) 2014 IEEE congress on evolutionary computation (CEC). IEEE Press, Piscataway, NJ, pp 618–625Google Scholar
 55.Hunt R, Johnston M, Zhang M (2015a) Evolving dispatching rules with greater understandability for dynamic job shop. Tech. Rep. ECSTR1506, Victoria University of WellingtonGoogle Scholar
 56.Hunt R, Johnston M, Zhang M (2015b) Using Local Search to Evaluate dispatching rules in dynamic job shop scheduling. In: Ochoa G, Chicano F (eds) Evolutionary computation in combinatorial optimization. Springer International Publishing, Lecture notes in computer science, pp 222–233Google Scholar
 57.Ingimundardottir H, Runarsson TP (2011) Supervised learning linear priority dispatch rules for jobshop scheduling. In: Coello Coello CA (ed) Learning and intelligent optimization, Springer, Berlin and Heidelberg, LNCS, vol 6683, pp 263–277Google Scholar
 58.Jakobovi D, Marasovi K (2012) Evolving priority scheduling heuristics with genetic programming. Appl Soft Comput 12(9):2781–2789CrossRefGoogle Scholar
 59.Jakobovic D, Budin L (2006) Dynamic scheduling with genetic programming. In: Collet P, Tomassini M, Ebner M, Gustafson S, Ekrt A (eds) Genetic programming, Springer, Berlin, LNCS, vol 3905, pp 73–84Google Scholar
 60.Jakobovic D, Jelenkovic L, Budin L (2007) Genetic programming heuristics for multiple machine scheduling. In: Ebner M, O’Neill M, Ekrt A, Vanneschi L, EsparciaAlczar AI (eds) Genetic programming, Springer, Berlin, LNCS, vol 4445, pp 321–330Google Scholar
 61.Jin Y (2006) Multiobjective machine learning (studies in computational intelligence) (studies in computational intelligence). SpringerVerlag New York Inc, SecaucusGoogle Scholar
 62.Jin Y (2011) Surrogateassisted evolutionary computation: recent advances and future challenges. Swarm Evol Comput 1(2):61–70CrossRefGoogle Scholar
 63.Karunakaran D, Chen G, Zhang M (2016a) Parallel multiobjective job shop scheduling using genetic programming. In: Ray T, Sarker R, Li X (eds) Artificial life and computational intelligence. Springer International Publishing, Lecture notes in computer science, pp 234–245Google Scholar
 64.Karunakaran D, Mei Y, Chen G, Zhang M (2016b) Dynamic job shop scheduling under uncertainty using genetic programming. In: AsiaPacific symposium on intelligent and evolutionary systems (IES) (to appear)Google Scholar
 65.Keijzer M, Babovic V (1999) Dimensionally aware genetic programming. In: Banzhaf, W (ed) Proceedings of the first genetic and evolutionary conference (GECCO 99), Morgan, pp 1069–1076Google Scholar
 66.Kofler M, Wagner S, Beham A, Kronberger G, Affenzeller M (2009) Priority rule generation with a genetic algorithm to minimize sequence dependent setup costs. In: MorenoDaz R, Pichler F, QuesadaArencibia A (eds) Computer aided systems theory EUROCAST 2009, Springer, Berlin, LNCS, vol 5717, pp 817–824Google Scholar
 67.Koza JR (1992) Genetic programming: on the programming of computers by means of natural selection. MIT Press, CambridgezbMATHGoogle Scholar
 68.Kuczapski AM, Micea MV, Maniu LA, Cretu VI (2010) Efficient generation of near optimal initial populations to enhance genetic algorithms for jobshop scheduling. Inf Technol Control 39(1):32–37Google Scholar
 69.Langdon WB, Banzhaf W (2005) Repeated sequences in linear genetic programming genomes. Complex Syst 15(4):285–306MathSciNetzbMATHGoogle Scholar
 70.Law AM, Kelton DM (1999) Simulation modeling and analysis. McGrawHill Higher Education, BostonzbMATHGoogle Scholar
 71.Lawrence S (1984) Resource constrained project scheduling: an experimental investigation of heuristic scheduling techniques. PhD thesis, Graduate School of Industrial Administration, CarnegieMellon University, Pittsburgh, PennsylvaniaGoogle Scholar
 72.Li D, Zhan R, Zheng D, Li M, Kaku I (2016) A hybrid evolutionary hyperheuristic approach for intercell scheduling considering transportation capacity. IEEE Trans Autom Sci Eng 13(2):1072–1089CrossRefGoogle Scholar
 73.Li XY, Shao XY, Gao L (2008) Optimization of flexible process planning by genetic programming. Int J Adv Manuf Technol 38(1–2):143–153CrossRefGoogle Scholar
 74.Mascia F, LopezIbanez M, DuboisLacoste J, Stutzle T (2013) From grammars to parameters: automatic iterated greedy design for the permutation flowshop problem with weighted tardiness. In: Nicosia G, Pardalos P (eds) Learning and intelligent optimization, Springer, Berlin, LNCS, vol 7997, pp 321–334Google Scholar
 75.Masood A, Mei Y, Chen G, Zhang M (2016a) ManyObjective genetic programming for jobshop scheduling. In: CEC’16: IEEE congress on evolutionary computation, pp 209–216Google Scholar
 76.Masood A, Mei Y, Chen G, Zhang M (2016b) A PSObased reference point adaption method for genetic programming hyperheuristic in manyobjective job shop scheduling. In: Australasian conference on artificial life and computational intelligence (ACALCI), (to appear)Google Scholar
 77.Mckay RI, Hoai NX, Whigham PA, Shan Y, O’Neill M (2010) Grammarbased genetic programming: a survey. Genetic Program Evolv Mach 11(3–4):365–396CrossRefGoogle Scholar
 78.Mei Y, Zhang M (2016) A comprehensive analysis on reusability of GPevolved job shop dispatching rules. In: WCCICEC’16: IEEE congress on evolutionary computationGoogle Scholar
 79.Mei Y, Zhang M, Nyugen S (2016) Feature selection in evolving job shop dispatching rules with genetic programming. In: Proceedings of the genetic and evolutionary computation conference 2016, GECCO ’16, pp 365–372Google Scholar
 80.Miller JF, Thomson P (2000) Cartesian genetic programming. European Conference on Genetic Programming. Springer, Berlin, pp 121–132Google Scholar
 81.Miyashita K (2000) Jobshop scheduling with genetic programming. In: Whitley D, Goldberg D, CantuPaz E, Spector L, Parmee I, Beyer HG (eds) GECCO 2000: Proceedings of the genetic and evolutionary computation conference. Morgan Kaufmann, San Francisco, pp 505–512Google Scholar
 82.Montana DJ (1995) Strongly typed genetic programming. Evol Comput 3(2):199–230CrossRefGoogle Scholar
 83.Mucientes M, Vidal JC, Bugarin A, Lama M (2008) Processing times estimation in a manufacturing industry through genetic programming. In: IEEE 2008 3rd international workshop on genetic and evolving fuzzy systems (GEFS)Google Scholar
 84.Nguyen S (2016) A learning and optimizing system for order acceptance and scheduling. Int J Adv Manuf Technol. doi: 10.1007/s0017001583216
 85.Nguyen S, Zhang M, Johnston M (2011) A genetic programming based hyperheuristic approach for combinatorial optimisation. In: GECCO’11: Proceedings of the 13th annual conference on genetic and evolutionary computation, ACM, pp 1299–1306Google Scholar
 86.Nguyen S, Zhang M, Johnston M, Tan KC (2012a) A coevolution genetic programming method to evolve scheduling policies for dynamic multiobjective job shop scheduling problems. In: CEC’12: IEEE congress on evolutionary computation (CEC), pp 1–8Google Scholar
 87.Nguyen S, Zhang M, Johnston M, Tan KC (2012b) Evolving reusable operationbased duedate assignment models for job shop scheduling with genetic programming. In: EuroGP’12: Genetic Programming, no. 7244 in Lecture notes in computer science, pp 121–133Google Scholar
 88.Nguyen S, Zhang M, Johnston M, Tan K (2013a) Learning iterative dispatching rules for job shop scheduling with genetic programming. Int J Adv Manuf Technol 67(14):85–100CrossRefGoogle Scholar
 89.Nguyen S, Zhang M, Johnston M, Tan KC (2013b) A computational study of representations in genetic programming to evolve dispatching rules for the job shop scheduling problem. IEEE Trans Evol Comput 17(5):621–639CrossRefGoogle Scholar
 90.Nguyen S, Zhang M, Johnston M, Tan KC (2013c) Dynamic Multiobjective job shop scheduling: a genetic programming approach. In: Uyar AS, Ozcan E (eds) Urquhart N (eds) Automated scheduling and planning, no. 505 in studies in computational intelligence, Springer, Berlin, pp 251–282Google Scholar
 91.Nguyen S, Zhang M, Johnston M, Tan KC (2013d) Learning reusable initial solutions for multiobjective order acceptance and scheduling problems with genetic programming. In: Krawiec K, Moraglio A, Hu T, EtanerUyar A, Hu B (eds) Genetic programming, Springer, Berlin, LNCS, vol 7831, pp 157–168Google Scholar
 92.Nguyen S, Zhang M, Johnston M (2014a) Enhancing branchandbound algorithms for order acceptance and scheduling with genetic programming. In: EuroGP’14: Genetic programming, no. 8599 in Lecture notes in computer science, Springer, Berlin, pp 124–136Google Scholar
 93.Nguyen S, Zhang M, Johnston M (2014b) A sequential genetic programming method to learn forward construction heuristics for order acceptance and scheduling. In: Liu D, Hussain A, Zeng Z, Zhang N (eds) CEC’14: IEEE congress on evolutionary computation (CEC). IEEE Press, Piscataway, NJ, pp 1824–1831Google Scholar
 94.Nguyen S, Zhang M, Johnston M, Tan K (2014c) Genetic programming for evolving duedate assignment models in job shop environments. Evol Comput 22(1):105–138CrossRefGoogle Scholar
 95.Nguyen S, Zhang M, Johnston M, Tan KC (2014d) Automatic design of scheduling policies for dynamic multiobjective job shop scheduling via cooperative coevolution genetic programming. IEEE Trans Evol Comput 18(2):193–208CrossRefGoogle Scholar
 96.Nguyen S, Zhang M, Johnston M, Tan KC (2014e) Selection Schemes in surrogateassisted genetic programming for job shop scheduling. In: SEAL’14: simulated evolution and learning, Springer International Publishing, pp 656–667Google Scholar
 97.Nguyen S, Zhang M, Johnston M, Tan K (2015a) Automatic programming via iterated local search for dynamic job shop scheduling. IEEE Trans Cybern 45(1):1–14CrossRefGoogle Scholar
 98.Nguyen S, Zhang M, Tan KC (2015b) Enhancing genetic programming based hyperheuristics for dynamic multiobjective job shop scheduling problems. In: CEC’15: IEEE congress on evolutionary computation (CEC), pp 2781–2788Google Scholar
 99.Nguyen S, Zhang M, Tan KC (2016) Surrogateassisted genetic programming with simplified models for automated design of dispatching rules. IEEE Trans Cybern. doi: 10.1109/TCYB.2016.2562674
 100.Nie L, Shao X, Gao L, Li W (2010) Evolving scheduling rules with gene expression programming for dynamic singlemachine scheduling problems. Int J Adv Manuf Technol 50(58):729–747CrossRefGoogle Scholar
 101.Nie L, Gao L, Li P, Wang X (2011) MultiObjective optimization for dynamic singlemachine scheduling. In: Tan Y, Shi Y, Chai Y, Wang G (eds) Advances in swarm intelligence: second international conference, ICSI 2011, Chongqing, China, June 12–15, 2011. Proceedings, Part II, Springer, Berlin, pp 1–9Google Scholar
 102.Nie L, Gao L, Li P, Zhang L (2011) Application of gene expression programming on dynamic job shop scheduling problem. In: Proceedings of the 2011 15th international conference on computer supported cooperative work in design. IEEE Press, Piscataway, NJ, pp 291–295Google Scholar
 103.Nie L, Bai Y, Wang X, Liu K (2012) Discover scheduling strategies with gene expression programming for dynamic flexible job shop scheduling problem. In: Tan Y, Shi Y, Ji Z (eds) Advances in swarm intelligence, Springer, Berlin, LNCS, vol 7332, pp 383–390Google Scholar
 104.Nie L, Gao L, Li P, Li X (2013a) A GEPbased policies constructing approach for dynamic flexible job shop scheduling problem with job release dates. J Intell Manuf 24(4):763–774CrossRefGoogle Scholar
 105.Nie L, Gao L, Li P, Shao X (2013b) Reactive scheduling in a job shop where jobs arrive over time. Comput Ind Eng 66:389–405CrossRefGoogle Scholar
 106.Nowicki E, Smutnicki C (1996) A fast taboo search algorithm for the job shop problem. Manag Sci 42(6):797–813zbMATHCrossRefGoogle Scholar
 107.Olafsson S, Li X (2010) Learning effective new single machine dispatching rules from optimal scheduling data. Int J Prod Econ 128(1):118–126CrossRefGoogle Scholar
 108.Ong Y, Gupta A (2016) Evolutionary multitasking: a computer science view of cognitive multitasking. Cognit Comput 8(2):125–142CrossRefGoogle Scholar
 109.Ouelhadj D, Petrovic S (2008) A survey of dynamic scheduling in manufacturing systems. J Sched 12(4):417MathSciNetzbMATHCrossRefGoogle Scholar
 110.Park J, Nguyen S, Johnston M, Zhang M, (2013a) Evolving Stochastic dispatching rules for order acceptance and scheduling via genetic programming. In: AI, (2013) Advances in artificial intelligence. Springer International Publishing, Lecture notes in computer scienceGoogle Scholar
 111.Park J, Nguyen S, Zhang M, Johnston M (2013) Genetic programming for order acceptance and scheduling. In: Coello Coello CA, De la Fraga LG (eds) 2013 IEEE congress on evolutionary computation (CEC). IEEE Press, Piscataway, NJ, pp 1005–1012Google Scholar
 112.Park J, Nguyen S, Zhang M, Johnston M (2014) Enhancing heuristics for order acceptance and scheduling using genetic programming. In: SEAL’14: Simulated evolution and learning, Springer International Publishing, pp 723–734Google Scholar
 113.Park J, Nguyen S, Zhang M, Johnston M (2015a) Evolving Ensembles of dispatching rules using genetic programming for job shop scheduling. In: EuroGP’15: Genetic programming, Springer International Publishing, pp 92–104Google Scholar
 114.Park J, Nguyen S, Zhang M, Johnston M (2015b) A single population genetic programming based ensemble learning approach to job shop scheduling. In: GECCO’15: Proceedings of the 2015 on genetic and evolutionary computation conference companion, pp 1451–1452Google Scholar
 115.Park J, Mei Y, Chen G, Zhang M (2016a) Niching genetic programming based hyperheuristic approach to dynamic job shop scheduling: an investigation into distance metrics. In: GECCO’16: Proceedings of the 2016 on genetic and evolutionary computation conference companion, pp 109–110Google Scholar
 116.Park J, Mei Y, Nguyen S, Chen G, Johnston M, Zhang M (2016b) Genetic programming based hyperheuristics for dynamic job shop scheduling: cooperative coevolutionary approaches. In: Genetic programming, no. 9594 in Lecture notes in computer science, Springer International Publishing, pp 115–132Google Scholar
 117.Pickardt C, Branke J, Hildebrandt T, Heger J, ScholzReiter B (2010) Generating dispatching rules for semiconductor manufacturing to minimize weighted tardiness. In: Johansson B, Jain S, MontoyaTorres J, Hugan J, Ycesan E (eds) Proceedings of the 2010 winter simulation conference. IEEE Press, Piscataway, NJ, pp 2504–2515Google Scholar
 118.Pickardt CW, Hildebrandt T, Branke J, Heger J, ScholzReiter B (2013) Evolutionary generation of dispatching rule sets for complex dynamic scheduling problems. Int J Prod Econ 145(1):67–77CrossRefGoogle Scholar
 119.Pinedo ML (2008) Scheduling: theory, algorithms, and systems, 3rd edn. Springer, New YorkzbMATHGoogle Scholar
 120.Poli R (1998) Discovery of symbolic, neurosymbolic and neural networks with parallel distributed genetic programming. In: Artificial neural nets and genetic algorithms, pp 419–423Google Scholar
 121.Potter MA, De Jong KA (2000) Cooperative coevolution: an architecture for evolving coadapted subcomponents. Evol Comput 8(1):1–29CrossRefGoogle Scholar
 122.Qin W, Zhang J, Sun Y (2013) Multipleobjective scheduling for interbay amhs by using geneticprogrammingbased composite dispatching rules generator. Comput Ind 64:694–707CrossRefGoogle Scholar
 123.Riley M, Mei Y, Zhang M (2016) Improving job shop dispatching rules through terminal weighting and adaptive mutation in genetic programming. In: IEEE congress on evolutionary computation, pp 3362–3369Google Scholar
 124.Schmidt M, Lipson H (2009) Distilling freeform natural laws from experimental data. Science 324(5923):81–85CrossRefGoogle Scholar
 125.Sels V, Gheysen N, Vanhoucke M (2011) A comparison of priority rules for the job shop scheduling problem under different flow time and tardinessrelated objective functions. Int J Prod Res 50(15):4255–4270CrossRefGoogle Scholar
 126.Sha DY, Hsu CY (2006) A hybrid particle swarm optimization for job shop scheduling problem. Comput Ind Eng 51(4):791–808CrossRefGoogle Scholar
 127.Shahzad A, Mebarki N (2016) Learning dispatching rules for scheduling: a synergistic view comprising decision trees, tabu search and simulation. Computers 5(1):3. doi: 10.3390/computers5010003. http://www.mdpi.com/2073431X/5/1/3
 128.Shi W, Song X, Sun J (2015) Automatic heuristic generation with scatter programming to solve the hybrid flow shop problem. Adv Mech Eng 7(2):1–9CrossRefGoogle Scholar
 129.Shiue YR (2009) Dataminingbased dynamic dispatching rule selection mechanism for shop floor control systems using a support vector machine approach. Int J Prod Res 47(13):3669–3690zbMATHCrossRefGoogle Scholar
 130.Sim K, Hart E (2015) A novel heuristic generator for jssp using a treebased representation of dispatching rules. In: GECCO’15: Proceedings of the companion publication of the 2015 on genetic and evolutionary computation conferenceGoogle Scholar
 131.Sim K, Hart E, Paechter B (2015) A lifelong learning hyperheuristic method for bin packing. Evol Comput 23(1):37–67CrossRefGoogle Scholar
 132.Taillard E (1993) Benchmarks for basic scheduling problems. Eur J Oper Res 64(2):278–285zbMATHCrossRefGoogle Scholar
 133.Tan K, Lee T, Khor E (2002) Evolutionary algorithms for multiobjective optimization: performance assessments and comparisons. Artif Intell Rev 17(4):251–290zbMATHCrossRefGoogle Scholar
 134.Tay JC, Ho NB (2007) Designing dispatching rules to minimize total tardiness. In: Dahal KP, Tan KC, Cowling PI (eds) Evolutionary scheduling, studies in computational intelligence, vol 49. Springer, Berlin, pp 101–124CrossRefGoogle Scholar
 135.Tay JC, Ho NB (2008) Evolving dispatching rules using genetic programming for solving multiobjective flexible jobshop problems. Comput Ind Eng 54(3):453–473CrossRefGoogle Scholar
 136.VazquezRodriguez JA, Ochoa G (2011) On the automatic discovery of variants of the NEH procedure for flow shop scheduling using genetic programming. J Oper Res Soc 62(2):381–396CrossRefGoogle Scholar
 137.Wang X, Nie L, Bai Y (2015) Discovering scheduling rules with a machine learning approach based on GEP and PSO for dynamic scheduling problems in shop floor. In: Computational intelligence in industrial application, pp 365–370Google Scholar
 138.Weckman GR, Ganduri CV, Koonce DA (2008) A neural network jobshop scheduler. J Intell Manuf 19(2):191–201CrossRefGoogle Scholar
 139.Whigham PA (1995) Grammaticallybased genetic programming. In: Rosca JP (ed) Proceedings of the workshop on genetic programming: from theory to realworld applications, pp 33–41Google Scholar
 140.Wu SX, Banzhaf W (2011) Rethinking multilevel selection in genetic programming. In: Proceedings of the 13th annual conference on genetic and evolutionary computation, ACM, New York, NY, USA, GECCO ’11, pp 1403–1410Google Scholar
 141.Yang JW, Cheng HC, Chiang TC, Fu LC (2008) Multiobjective lot scheduling and dynamic OHT routing in a 300mm wafer fab. In: 2008 IEEE international conference on systems, man and cybernetics, pp 1608–1613Google Scholar
 142.Yin WJ, Liu M, Wu C (2003) Learning singlemachine scheduling heuristics subject to machine breakdowns with genetic programming. In: Sarker R, Reynolds R, Abbass H, Tan KC, McKay B, Essam D, Gedeon T (eds) The 2003 congress on evolutionary computation (CEC 2003), IEEE Press, Piscataway, NJ, vol 2, pp 1050–1055Google Scholar
Copyright information
Open AccessThis article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.