Practical Benefits of Aspect-Oriented Programming Paradigm in Discrete Event Simulation

Algorithm 1

Resulting boiler class (with tangled code) [5].

extends HeatPropagator  {                                                                                    protect double generateHeat〈〉  {

                                                                                                                                                                      synchronized  (qroomslook) {

// instance variables –                                                                                                       vector valves;

private double qT;                                                                                                                       ⋯

private double qrooms;                                                                                                          for (Enumeration e − heaters.elements〈〉;

private Vector heaters;                                                                                                                 

                                                                                                                                                                                      Heater heater − (Heater) (e.nextElement〈〉);

private object qroomslook = new object [0] ;                                                                          ⋯

                                                                                                                                                                                      valves.add(h.getValve〈〉);

// Instance methods                                                                                                          

public void requestHeat(double q,vector h) {                                     ⋯

       synchronized (qroomsLock) {                                                                                              double q;

              qrooms = qrooms + q;                                                                                                 q = MathPackage.RungeKutta(qi,  qrooms,  qT,  …);

              ⋯                                                                                                                                                          ⋯

              heaters.addAll(h);                                                                                                        for (Enumeration e = heaters.elements 〈〉;

        }                                                                                                                                                                               

}                                                                                                                                                                                    Heater heater − (Heater) (e.nextElement〈〉);

protected propagate〈〉  {                                                                                                                  ⋯

       qT −  this.generateHeat〈〉;                                                                                                   h.setValve(valves.elementAt(1));

       next.addHeat(qT);                                                                                                                 

}                                                                                                                                                                           return (q);

protected double transferredHeat〈〉  {                                                        }

       synchronized (qlock) {                                                                                              }

       ⋯                                                                                                                                     }  // End Boilar

        } 

} 

Bold  code corresponds to tangled code due to concurrency aspects.

Underlined  code  corresponds to tangled code  due to mathematical aspects.