- The paper presents a Python/SimPy simulation of the Waterfall software development lifecycle to estimate project completion times and identify resource bottlenecks.
- Initial simulation results showed resource bottlenecks, particularly a shortage of programmers in the implementation phase, impacting project completion times.
- Optimizing resource allocation through iterative simulation eliminates project delays and significantly reduces overall project completion times.
The paper "Simulating the Software Development Lifecycle: The Waterfall Model" presents a simulation-based approach for estimating software project completion times using the waterfall model. The authors implemented their Software Development Lifecycle (SDLC) simulation using SimPy, a Python discrete-event simulation framework, within a software house context, examining 100 projects of varying sizes across two scenarios.
The paper leverages simulation to experiment and plan for software development projects. It addresses the challenges of cost overruns, missed deadlines, and failures often associated with software development, referencing studies that highlight significant probabilities of failure in IT projects. The authors aim to demonstrate the use of Python and the SimPy framework to simulate the waterfall model, optimizing resource allocation to minimize bottlenecks and idle resources.
The paper reviews the evolution and definitions of the SDLC, tracing its origins to the 1960s and the work of Benington, and acknowledges its continued evolution to include aspects like secure software development, green computing, and the impact of Machine Learning/Deep Learning. The paper describes the waterfall model as a sequential design process where progress flows steadily downwards through phases, with each phase's output becoming the input for the next. The phases include requirements analysis, system and software design, implementation and unit testing, integration and systems testing, and operations and maintenance.
The first scenario provides insight based on an initial set of resources, revealing resource bottlenecks, particularly a shortage of programmers for the implementation phase. The second scenario employs a stepwise algorithm to identify a resource level that achieves zero-wait time.
Materials and Methods
The simulation models a software development house pursuing concurrent projects of small, medium, and large scales with fixed resources. It builds upon the work of Bassil and simulates the waterfall SDLC, comprising five phases executed in sequence. The assumptions include available resources (analysts, designers, programmers, testers, and maintenance personnel), required human resources by project size, duration of phases, and probabilities of error occurrence. Project sizes are introduced using an exponential statistical function with a mean arrival of 35 units of time, parameterized by a lambda value of 1/35, and accounts for the scale of the project. The software allows for changes to these values based on user needs. The paper draws upon Riley's overview of discrete-event simulation techniques to identify a resource level minimizing bottlenecks and resulting in zero-wait times using intuitive methods and an iterative process.
Results
The simulation outcomes from two scenarios are presented. The first scenario relies on an initial, intuitive set of resources, while the second uses resources identified via a stepwise algorithm to eliminate resource-related bottlenecks. During all executions, 100 projects are simulated, each of varying size, using probabilities and an exponential statistical function. All initiated projects are completed successfully.
The first scenario reveals inefficiencies in resource utilization, with the implementation phase, particularly programmers, identified as a significant bottleneck. The design phase also experiences some bottlenecks. Conversely, the analysis and testing phases exhibit relatively lower delays and wait times. The maintenance phase shows zero delays and wait times across all resource sizes. Large-sized projects experience the greatest delays and wait times.
A second simulation, using a stepwise algorithm, identifies resource levels resulting in zero-wait times. Recursive simulation cycles run until no resource delays occur for a certain number of iterations. The resources are substantially adjusted. The second scenario, after adjusting the number of resources, takes 5754.000 units of time to complete, with no delays in procuring resources.
The simulation also provides insight regarding project durations, with the fastest project in the second scenario (zero-wait) completing in 33.000 units of time and the longest taking 168.000 units of time. The mean completion time for projects for Scenario 2 is 57.540 units of time. The simulation reveals the effects of the optimization process on completion time.
The simulation results indicate the likelihood of a phase failing, with errors first becoming possible during the design phase. Failure rates are based on project size, with large projects consistently having the highest failure rates in both Simulation 1 and Simulation 2.
Discussion and Conclusions
The simulation developed in this paper offers a solution to the challenges encountered in software engineering. Coded in Python using the SimPy framework, it is designed to facilitate accurate estimates of project completion times and to identify an optimal allocation of resources, enabling more effective project management. In this work, the authors build on previous efforts to simulate the waterfall model by offering an open-source solution utilizing Python and SimPy exploring two scenarios. The first instance simulates the waterfall model with an intuitive set of proposed resources. This provides initial insights into current resource utilization and identifies bottlenecks within the software development life cycle. This suggests a need for increasing resource allocation to ensure sufficient availability of programmers during this phase. A level of resources that would result in zero-wait is then identified. Subsequently, the simulation is run one final time to ascertain the effect that the optimization process has on the software development life cycle. The results reveal that the adjusted resource levels would achieve no delays, while acknowledging that running the simulation enough times would theoretically produce outliers reflecting resource shortages and phase delays.
The work recognizes that any software is intrinsically bound by the human element, since the program requires comfort working with code, as it lacks a graphical user interface to facilitate user interaction.
The authors conclude by stating that, despite its limitations, the open-source Python simulation system opens several avenues for further paper. They suggest that while the simulation identifies bottlenecks and suggests optimal resource allocation in our hypothetical projects, studying the simulation's use in the real world will allow us to determine its efficiency in helping teams deliver software projects on time and within budget. A second area of further paper involves integrating the simulation into software engineering courses to see how asking students to interact with and paper the parameters and code of the simulation alters the ways in which they understand the software engineering process and the software development lifecycle.