One of the best ways to deliver software complex algorithm (taking multiple inputs, executing multiple elements of a logic) is to divide the problem into three stages.
1. First create a model based on a pseudo code for the logic that you want to deliver as a solution.
2. Second create the consistent solution that runs correctly with any input (including garbage).
3. The third stage is for sraping all you’ve built and building it from the ground up again.
The third stage is probably the most interesting as you’d probably throw away the solution created in the previous step. Iterate from the third stage onwards. In fact it’s most likely that with each iteration a complete rewrite is the only correct way of solving the problem without fear of breaking things. This is because only by the time your model is proven you’d be able to asses what’s really needed to build the software.
You will also know the exceptions to rules previously assumed, the correctness of input and equally all bottlenecks you’re likely to encounter. Only having all of that in hand as a proven working software, as opposed to most technical specification, you’d be able to make the right choices in terms of technology stack or optimisations. The solution created in step 2 is going to be thrown away, however it’s actually far from waste.
Instead of throwing it away completely one can use the software to compare the new version against. Think of it as a rig for unit testing and a reference point for all your benchmarks. Once having the concept moved from pseudo code into actually working software you’re able to automate the solution created in step 2 so that it calls itself, its successor created in step 3 and whitle down any differences both in terms of correctness and the performance.