#### Abstract

Software project scheduling is essentially a kind of project scheduling problem with limited human resources. During the development process of a software product, reworking the completed projects, reassessing the workload, and changing the number of employees or their skills are the frequently occurring dynamic issues having direct influences on designing a scheduling scheme. Taking the development cost and duration, the robustness, and the stability of the scheduling schemes as the objective functions, software project scheduling is modeled as a dynamic four-objective optimization problem. The various programming habits among the employees form the specific constraints for the reworking tasks, and the skills of the employees vary due to the effects of learning and forgetting. To solve this problem, an improved multiobjective firework algorithm with a novel explosion operator and reservation strategy is incorporated with rescheduling methods to fully guide the evolution by using the historical evolutionary knowledge. The experimental results indicate that the proposed method has better scheduling performance, and the optimal scheduling schemes have better robustness and stability.

#### 1. Introduction

Efficiently developing and maintaining software products determines the market competitiveness of a software company. To meet the requirements of software development, such as deadlines and budgets, effectively allocating dozens of employees to cooperatively fulfill a project timeline subject to various constraints is a key issue, which is called the software project scheduling problem (SPSP) [1]. An inappropriate project schedule may result in project failure and even large economic losses.

With the increasing of the software’s complexity, more employees are allocated to complete the numerous tasks. Scheduling the complicated software project manually or by traditional numerical programming is inefficient and possibly falls into an unfeasible project schedule [2, 3]. Moreover, many unpredictable events often occur in real-world software development processes, such as employees leaving and joining, changing the task requirements, and the arrival of patching tasks for the developed software, which change the working environment of a project. The employees, as a special scheduling resource, normally possess more than one kind of skill and their proficiencies change with experience due to the inherent learning and forgetting ability of human beings. The optimal schedule that is suitable for the certain development condition is usually unable to achieve the desired performance and may even deteriorate the performance under the changed environment. Based on this, employing the dynamic software project scheduling method is a necessity.

Given that dynamic events that occur in the development process directly affect the schedules, accurately describing the events and modeling the SPSP are two key issues for solving this NP-hard problem. Three kinds of unpredictable and uncertain events, including the uncertain task effort, the new task arrival, and employee leave and return, are first discussed and modeled by Shen [4]. However, the SPSP model with the above dynamic factors is incomplete due to various risks from customers, the development environment, and task demand that may happen in the software project [5]. For example, changing customer demands or wrong estimations regarding the product complexity are apt to modify the functions or cause bugs in software, which requires what is called a reworking task. Without loss of generality, employees that were previously responsible for developing this software are assigned to the task because of their personal programming habits and the high priority of tasks. Understanding the original codes written by the other developers and repairing the functions are time-consuming and unreasonable. In addition, developing the software project in fact requires the mental labor of employees [6]. Employee leave and return changes the search space of the software project scheduling problem, and their skill proficiencies are not fixed in time due to the inherent learning and forgetting ability of human beings. Paiva and Keumseok [7, 8] believed that the learning and forgetting effect is important and accompanying factor affecting the software development process. Active learning, such as participating in the training class for a certain skill, unconscious learning that implicitly accumulates more experience from the development process, and forgetting effects obviously change their skill proficiencies [9] and development efficiency [10]. However, few studies had been done on the learning and forgetting effect of employees. Proactive scheduling and reactive scheduling are essentially the rescheduling method to solve the SPSP with dynamic events [11–14]. Shen [4, 15] presents a dynamic scheduling method based on Q-learning. Though dynamic employees’ skills considering the learning and forgetting effect had been presented by the authors [16], the other dynamic factors, the robustness and the stability of the schedules were not taken into account in software project scheduling model. Based on this, taking the duration and cost of the project, the robustness, and the stability of the schedules as the objective functions, dynamic multiobjective software project scheduling model is constructed. In particular, reworking task arrivals, dynamic skill proficiencies, and employee leave and return are taken into consideration. To solve this problem, an improved multiobjective firework algorithm with a novel heuristic evolutionary operators is presented as the rescheduling method to fully utilize the historical evolutionary knowledge.

The rest of this paper is organized as follows. The model of the dynamic software project scheduling problem is established in Section 2. Section 3 presents the improved multiobjective firework algorithm to solve the dynamic SPSP. In Section 4, the experimental results for the instances are compared and analyzed. At last, the whole paper is concluded and our planned future work is given.

#### 2. Dynamic Multiobjective Software Project Scheduling Model

The essence of software project scheduling is to fulfill the tasks with complex precedence relationship by coordinating the skills of numerous employees. Each task requires an amount of human resources, and its resources demand cannot exceed the total amount of available resources. Three time-varying events, including arriving reworking tasks, leaving and returning of employees, and changing skill proficiency, are taken into account. Newly arrived reworking tasks received prior to the development projects shall be completed by employees before new projects, and may possibly result in leaving of employees before the projects are completed. This decelerates the development process because all of the subsequent tasks that cannot be done in advance and reassigning other employees may be inefficient. Moreover, we also concern about an uncertain factor, inaccurately estimating work load. The workload of a task is usually estimated using the COCOMO model [17]. Unexpected events, such as changing customer requirements, may change the task workload over time.

The basic symbols and their notations for the dynamic SPSP model are shown in Table 1.

Without loss of generality, an entire software development project consists of tasks. The first and the last one at the beginning and end of a project, which are expressed as and , are dummy tasks. All tasks must be conducted in terms of the precedence relationship represented by the activity-on-node (AON) network, as shown in Figure 1. Task can start up only after all tasks in have been completed.

Fulfilling a task normally depends on one or more skills, except for the dummy tasks. Different tasks need various skills, and corresponding workloads also differ from each other. The task during its execution cannot be interrupted, and employees taking over a task cannot drop out. Hence, the duration of task , which is denoted by , is maximum makespan of all employees taking part in this task.

Each employee has a number of skills and their skill proficiencies may be different from other developers. At any moment, an employee can use a skill to complete only one task. Once an employee is assigned to a task, he (she) can be involved in another work task only after fulfilling the current one.

##### 2.1. Modeling the Learning and Forgetting Effects

The skill proficiencies of employees may change with active or unconscious learning and forgetting. Previous studies on the software project scheduling problem [18, 19] normally assumed that the skill proficiency is fixed and less report on the learning and forgetting effects. Based on this, a model describing the time-varying skill proficiencies of employees with the learning and forgetting effect is built.

Wright’s learning curve (WLC) proposed by Wright [20] first described the effect of the product quantity on employees’ skill proficiencies in aircraft production. Given that learning is often accompanied by forgetting, as the inherent characteristics of human being, the relationship between employees’ downtime and forgetting is subsequently described by variable regression to variable forgetting (VRVF) model [21]. Rationally utilizing the learning and forgetting effect can help project managers to fully know their employees’ statuses and construct more efficient and reasonable schedules [22–24]. Being different from the traditional product scheduling problems, lines of code are normally employed to describe the workload changing with the learning/forgetting effect in the SPSP instead of the makespan of the unit product. Besides, once no task is fulfilled by the employees, corresponding skill level decreases with the forgetting effect and does not remain unchanged in the traditional learning model.

Suppose that is th employee and* sk*_{k} is* k*th skill. The skill proficiency of* sk*_{k} for* e*_{i} is expressed by . Based on the WLC and VRVF models, the learning and forgetting model for the SPSP is presented as follows [16]:

In the above formula, represents the time consumed by* e*_{i} to complete task with her (his) skill . If employee does not spend any time on fulfilling this task with , the time is expressed by . and , respectively, denote the total time that uses the skill or not, and they satisfy and . and are, respectively, the skill proficiency of for at times and . and , which are real numbers between , are the coefficients of learning and forgetting which are preset by the decision-makers. The starting points of learning or forgetting are not fixed. and are the workloads with or without tasks for the employees.

##### 2.2. Modeling Dynamic Events

We focus on three characteristics of dynamic events, including their types, the times when events arrived, and their additional information, which are represented by* el*_{1},* el*_{2}, and* el*_{3}, respectively.

The probability of dynamic events occurring obeys a Poisson distribution . All dynamic events that occurred in a project consist of a dynamic event set expressed by .

##### 2.3. Modeling Dynamic Software Project Scheduling Problem

Taking four objectives, including the duration and cost of the project, the robustness, and the stability of the schedules, into account, the dynamic software project scheduling problem is modeled as follows:

In the above formula, represents the duration of the project. Given that the last task is a dummy variable, the project is completed at its starting time, which is expressed by . For each task, it starts after its preceding tasks have been accomplished. The start time of is defined as follows:

The cost of the project, which is denoted by , depends on the salaries of employees and the time it takes to fulfill a task.

represents the robustness of the schedules for the SPSP with dynamic events. Once an unpredictable event arrives, the schedule with less change under the new environment has better robustness. Suppose that and are the duration and cost of a project before new dynamic events arrive. The duration and cost while dynamic events occur are denoted as and .

In the above formula, is a weight coefficient and is preset to 1. The set of all dynamic events that occur in a project are defined as and the number of dynamic events is . In this paper, .

The stability of schedules reflects the differences of the employees’ distributions under the dynamic environments, which is expressed by .

In the above formula, is the weight. Without loss of generality, an employee only can use a skill to fulfill the appropriate task, and the demand for a specific skill for a task only can be completed by an employee. Based on this, the constraints of the dynamic SPSP model are listed as follows:

#### 3. Dynamic Multiobjective Software Project Scheduling Optimization Method Based on Firework Algorithm

The fireworks algorithm, which was first proposed by Tan [25], is derived from the explosion process of fireworks. Each firework or spark can be regarded as a feasible solution. The new individuals, which are called sparks, are generated by the exploding fireworks in the potential region. Only the sparks with the larger fitness values were selected as the explosion locations in the next generation. Two kinds of evolutionary operators, including the explosion operator and the mutation operator, are employed to generate the offspring sparks. The balance between the diversity and distribution is kept by controlling the explosion radius of the fireworks and the number of generated sparks, which are set in advance before the evolution. The above operators are employed to solve continuous optimization problems.

Given that the dynamic software project scheduling problem is a combination of optimization problems, different encodings of individuals cause various evolutionary operators. Based on this, an improved multiobjective firework algorithm (IFA) is proposed and the rough framework is depicted as follows (Figure 2). Here,* i* is the generation and is the terminal iteration.

##### 3.1. Encoding Method

The traditional binary encoding cannot describe the complicated relationship between the tasks and the employees, resulting in the infeasible solutions. The real-number encoding, consequently, is employed to construct a schedule. Without loss of generality, determining the executed order of tasks and assigning the employees are two necessary parts of a scheduling scheme, denoted as* C*_{1} and* C*_{2}, respectively.

Randomly allocating the tasks is infeasible due to their precedential relationship. Thus, a rank-priority is employed to encode the tasks. Each task is assigned a rank in terms of their precedential relationship, and the ranks of the first and last dummy tasks are 1 and , respectively. A task having a lower rank must be executed and assigned the employees prior to others with higher ranks. Taking the AON network shown in Figure 1 as an example, each task, except for the dummy tasks (*a*_{1} and* a*_{8}), needs four kinds of skills and eight employees possess these skills. The rank for all tasks is , and is obtained by arranging the tasks in ascending order, as shown in Figure 3.

An employee is assigned to fulfill a task in terms of its requirement for the skills. We denote* J* as the number of nondummy tasks in a project. The assignment scheme of an employee is defined as* C*_{2} shown in Figure 4, except for the first and last dummy tasks, with the purpose of facilitating the evolutionary operations. By combining the task allocation scheme* C*_{1} with the employee assignment scheme* C*_{2}, a complete software project scheduling scheme expressed by is formed, as shown in Figure 5 [26].

##### 3.2. Explosion Operator

Multiple sparks are produced by the explosion operator around a firework. Appropriately setting the explosion radius and the number of produced sparks is of importance. A nondominated firework produces more sparks within a small explosion radius with the purpose of enhancing the local search and exploitation abilities. A large explosion radius is employed to generate fewer sparks around the suboptimal firework to explore the search space with good diversity.

Given that a firework or spark is encoded by a vector composed of two parts, two explosion radii expressed by* A*_{n_c1} and* A*_{n_c2} are adaptively adjusted in terms of the ranks of individuals. The number of produced sparks for the* n*th individual also varies with their distribution.

In the above formulas, . , , and* M *are constants.* x*_{n_rank} represents the rank of* x*_{n} obtained by the nondominated sorting method [27]. We call if () or ( and ).

As shown in Figure 6, a new task allocation satisfying the precedential constraint is obtained by changing the priority of certain tasks or the sequence of tasks in parallel. For example, the priority of* a*_{2} becomes lower after the explosion, and the corresponding task is completed first.

An employee is replaced by another one after randomly selecting a location in* C*_{2} with a certain probability, which is expressed by* r*_{ijk}. Different from the traditional explosion operator, the probability depends on the model and the skill proficiencies of employees instead of a Gaussian distribution. An employee having the better skill proficiency is more likely to be selected.

##### 3.3. Reservation Strategy

The explosion operator is employed to explore the region around a firework, and it possibly falls into the local optimum, which causes an ineffective search and large computation cost. In the traditional reservation strategy of the firework algorithm, an individual having the large crowding distance is possibly a local optimum. However, calculating the crowding distance for the dynamic SPSP is meaningless because of its special encoding method. Therefore, a novel reservation strategy is proposed.

All sparks are divided into mature and immature fireworks and saved in different archives, which are denoted by and , respectively. Individuals who are close enough to the local optimum are stored in . The nondominated individuals out of are saved as the sparks in who execute the explosion operation, the mutation operation, and the crossover operation in every* Ta *generation and the size of the mature archive is . The detailed update processes of mature and immature archives are shown in Algorithms 1 and 2, respectively.

Input: The sorted sparks set , previous mature firework archive | |

Output: | |

(1) if | |

(2) = the former sparks of | |

(3) else | |

(4) = Fast non-dominated sorting(US()) | |

(5) = the former sparks of | |

(6) | |

(7) | |

(8) end if |

Input: | |

Output: | |

(1) Sorting | |

(2) | |

(3) | |

(4) | |

(5) for to do | |

(6) Sorting | |

(7) Random select 2 sparks from | |

(8) | |

(9) | |

(10) | |

(11) end for | |

(12) |

##### 3.4. Heuristic Evolutionary Operators

Different mutation operators are applied to two parts of sparks. For* C*_{1} of a randomly selected spark, , changing the priority of any task results in a new* C*_{1}. An employee that is randomly selected from* C*_{2} is replaced by another one having the same skill and satisfying the constraint for the workload of this skill. Moreover, the crossover operator is introduced to produce two sparks along the potential direction with the purpose of fully exchanging information between nondominated sparks in Algorithm 3.

Input: Immature firework archive | |

Output: new sparks | |

(1) Randomly select 2 fireworks and from | |

(2) Split and into , , , and respectively | |

(3) Form new sparks and . |

Once a dynamic event arises, a heuristic strategy is designed for the dynamic software project scheduling problem to reschedule the employees.

For new reworking tasks that arrive prior to the executing one, employees participating in developing the original rework project are assigned to complete the urgent reworking task and replaced by other idle employees having the same skills to take over the suspended executing task. The mutation operator for* C*_{2} is triggered to find the one that is most suitable for the executing software project.

The leave and return of employee are paired events, and only the tasks accomplished during this period shall be rescheduled. The idle employees having the highest skill proficiencies are arranged to complete the tasks according to the mutation operator for* C*_{2}. If no one is free, the task is delayed until any employee is available or the employee returns to perform the task.

#### 4. Experimental Results and Analysis

The dynamic software project scheduling problem with three types of unpredictable events and unfixed skill proficiencies is built to further analyze the reasonableness of the proposed scheduling method. The 30 instances are divided into three groups with 10, 20, and 30 nondummy tasks that are obtained by using the generator of Alba and Chicano [28] and 3 other real instances are recorded as Real_b1, Real_2, and Real_3, respectively. The key parameters about employees are listed in Tables 2 and 3. Each kind of dynamic event occurs once at most in a project. All experiments are done by using MATLAB 7.0.

Three metrics are employed to analyze the performance of the schemes. The inverted generational distance (IGD) [29] calculates the distance between the objective values of the Pareto optimal solutions and the true Pareto front. The hypervolume (HV) [30] represents the volume of the hypercube between the Pareto-optimal front and the reference point in objective space. The reference point is set to after normalization. Spacing (SP) is employed to evaluate the distribution of the Pareto-optimal front. All of them measure the convergence and diversity of the Pareto optimal front. A lower IGD and larger HV mean that the optimal solutions better approximate the true Pareto front. Less SP means that individuals are evenly distributed along the Pareto-optimal front. In addition, C-metric and* Imp* are employed to compare the dominating relationship and the mean of each objective between the two methods [31].

##### 4.1. Experiment I: The Influence of Robustness and Stability

To analyze the influence of the robustness and stability on the search direction, two methods with/without robustness and stability as the objectives, which are called the IFA-R and the IFA-N, are employed. Ten independent experiments are conducted for each instance. The Pareto-optimal fronts obtained by the two methods are compared in Table 4. The* p-*value calculated in the rank-sum test is assessed with respect to p=0.05. Here, “=” means that there is no obvious difference between the algorithm performances of the IFA-R and the IFA-N, while “+” indicates that the IFA-R has better performance than the IFA-N.

The* p-*value is less than 0.05 in 25 instances, which indicates that the IFA-R has significantly better performance than the IFA-N. The overall performance of the Pareto-optimal front skews the results in favor of taking the robustness and stability of the solutions into consideration. The italic part in the table labeled the degraded values of the IFA-R that are worse than those of the IFA-N and it shows the four objectives coupled with each other. In summary, the robustness and stability of the nondominated solutions obtained by the IFA-R are significantly improved, while their costs and duration may be slightly worse.

##### 4.2. Experiment II: Comparison of Algorithm Performances with Other Methods

The algorithmic performance of IFA is compared with those of the NSGA-II, the FA, and MPSO by running each instance 10 times, as shown in Tables 5 and 6. The nonpositive values in Table 5 have been in italic, and the optimal value of each metric in Table 6 is labeled in italic.

The means of the cost and duration are obviously optimized for 33 instances by IFA compared with the FA, MPSO, and NSGA-II. HV and IGD of IFA have the best performances, except for T10_4, meaning that IFA performs better with respect to the convergence and diversity. Compared with NSGA-II, MPSO, and FA, it indicates that the crossover operator and the novel reservation strategy significantly improve the performance of IFA. In addition, IFA has a better distribution due to the less SP for most of the instances. With the increasing number of the tasks in instances, the distribution of the Pareto-optimal front obtained by IFA becomes more uniform. Particularly, IFA shows the best performance in 3 real instances.

##### 4.3. Experiment III: Influence of Dynamic Employees’ Skill Proficiency

Three nondominated solutions for the instances with different numbers of the tasks are chosen to analyze the learning and forgetting effect on the skill proficiency by using the Gantt charts shown in Figure 7.

**(a) J10**

**(b) J20**

**(c) J30**

In the early stage of the project, the completion time of each task is relatively similar, and becomes longer over time, such as J10_a6, J20_a8, J30_a14, and J30_a19. In addition, the completion time of the task tends to be stable. Under the above situation, the curves of the skill proficiency changes over time are shown in Figure 8. The red, green, blue, and black curves represent* sk*1,* sk*2,* sk*3, and* sk*4, respectively.

**(a) J10**

**(b) J20**

**(c) J30**

The time consumption of J10_a6 is large because the workload of* sk*_{1} for* a*_{6} in instance J10 is done by* e*_{2}. The skill proficiency of* sk*_{1} plotted by the red line in Figure 8 decreases at first due to the forgetting effect. Following that,* e*_{2} is assigned to fulfill the task with this skill, causing the increasing of its skill proficiency because of the subconscious learning ability. The learning factor of* e*_{2} is less than those of other employees, eventually leading to a longer time to fulfill the corresponding task. sk_{4} of* e*_{2} in J20_a8 and* sk*_{2} of* e*_{1} in J30_a14 have similar changing trends. Different from the former, the reason for the time consumption of J30_a19 is the competition of employees in tasks. The workloads of* sk*_{2} and* sk*_{4} for* a*_{19} in instance J30 are completed by* e*_{2} and* e*_{4}, respectively. Actually,* e*_{4} finished his (her) job in advance, but, at this time,* e*_{2} is participating in another task and finally starts the workload of* sk*_{4} for* a*_{19} later. In summary, the learning and forgetting effect of employees have significant impacts on the development of the software project. Therefore, it is crucial to make reasonable assignments according to the dynamic characteristics of employees.

#### 5. Conclusion

Various unpredictable events may arise in the development of a software project. In this paper, the dynamic software project scheduling problem with 3 types of frequently occurring dynamic events and varied skill proficiencies of employees is studied. According to the experience of software management experts, actual dynamic events include the leave and return of employees, the arrival of new reworking tasks, and inaccurate estimations. Furthermore, the skill proficiencies of an employee change due to the learning and forgetting effect over time. Taking four objectives, the robustness and stability of a nondominated spark, the duration, and cost of a scheduling scheme, into account, the dynamic SPSP model is built. To solve this problem, an improved multiobjective firework algorithm with the following three contributions is proposed: a spark or firework is encoded by two parts, the task allocation and the employee assignment, and corresponds to a scheduling scheme; the explosion radius and the number of produced sparks for the explosion operator are adaptively adjusted in terms of the fireworks’ status; and mature and immature sparks are, respectively, restored to two archives. This reservation strategy avoids repeated searches in a small range and reduces the possibility of the algorithm quickly falling into local optimum. The experimental results show that the performance of IFA is the best compared with FA, NSGA-II, and MPSO. The robustness and stability of new objectives successfully guide IFA to obtain the more suitable nondominated solutions in each dynamic environment, which meet the need of software engineers. In addition, the dynamic characteristics of the employees’ skills have significant impacts on the optimal schedule of a software project. In our future work, more unpredictable factors and complex situations, such as overtime pay and project outsourcing, shall be taken into account, and we will study more effective methods for solving dynamic software project scheduling problems.

#### Data Availability

The data used to support the findings of this study are available from the corresponding author upon request.

#### Conflicts of Interest

The authors declare that they have no conflicts of interest.

#### Acknowledgments

This work was jointly supported by the National Natural Science Foundation of China under Grant no. 61573361, Six Talent Peak Project in Jiangsu Province under Grant no. 2017-DZXX-046, National Key Research and Development Program under Grant no. 2016YFC0801406, and the State Key Laboratory of Robotics under Grant no. 2019-O21.