Using Standard Software Approaches is Extremely Unwieldy

Initially, the algorithm looks quite simple:

To Compute New Sequence:
  Loop through the aircraft list and compute each ETA,
  Finally, compute the sequence if any ETA’s have changed.

However, what if the ETA for the first aircraft changes significantly while we are still calculating the ETAs for the others? What if the user needs the schedule right now and can’t wait for the ETAs to be recalculated for all 60 aircraft?

What if we come to realise that we need to include wind effects in the ETA calculation? We need to add a step into the main loop to update the wind model before doing the ETA calculations. How is the incoming weather data handled and stored?

As the number of variables climbs, so does the complexity. This leads to bugs and software that is unresponsive (e.g., while it is computing ETAs, it is not able to compute a new sequence):

To Compute New Sequence:
  Did the user just interrupt?
    if so, return old sequence.
  Could any of the new ETAs have changed while sequencing?
    if so, re-compute them.
  Compute ETA for each aircraft,
    each time, check to see if the user interrupted,
  Finally, compute sequence if any ETA’s have changed.

The key point is that there is a single locus of control. The main loop grows with the complexity of the problem, and reactivity has to be manually incorporated into each step of the loop. Because of the inherent complexity of interactions, traditional software approaches lead to a monolithic code-base that is error-prone and difficult to alter without breaking the carefully coded handling of the dynamic aspects of the problem.

Next: JACK Agents Inherently Reduce Complexity

© AOS Group, 1997-2008, All rights reserved.