Show HN: SpaceX Dragon simulator docking autopilot in Clojure

  let a = setInterval(() => { 
      // retrieve values from simulation
      let roll = fixedRotationZ;
      let pitch = fixedRotationX;
      let yaw = fixedRotationY;
      let rpy = new THREE.Vector3(roll, pitch, yaw);
  
      let rollRate = -rateRotationZ/10.0;
      let pitchRate = -rateRotationX/10.0;
      let yawRate = -rateRotationY/10.0;
  
      let rpyRate = new THREE.Vector3(rollRate, pitchRate, yawRate);
  
      let pos = camera.position.clone();
      let posRate = motionVector.clone();
      let targetPos = issObject.position.clone();
  
      let targetRpy = new THREE.Vector3(0,0,0);
      let dRpy = targetRpy.clone().sub(rpy);
  
      // P-controller controls target roll,pitch,yaw-rate (targetRpyRate) to reach target orientation
      let targetRpyRate = new THREE.Vector3(
          dRpy.x/1.0, 
          dRpy.y/1.0, 
          dRpy.z/1.0
      );
  
      let minRpyRate = new THREE.Vector3(-1.5, -1.5, -1.5);
      let maxRpyRate = new THREE.Vector3(+1.5, +1.5, +1.5);
      targetRpyRate.clamp(minRpyRate, maxRpyRate)
  
      let dRpyRate = targetRpyRate.clone().sub(rpyRate);
   
      // don't calculate with displayed x,y,z but the internal coordinates 
      // (z-axis is forward and backward)
      let dPos = targetPos.clone().sub(pos);
      let d = dPos.length();
      // P-controller controls target motion (targetPosRate) to reach target position
      let targetPosRate = new THREE.Vector3(
          dPos.x / 100.0,
          dPos.y / 100.0,
          dPos.z / 100.0
      );
      let minPosRate = new THREE.Vector3(-0.1, -0.1, -0.01);
      let maxPosRate = new THREE.Vector3(+0.1, +0.1, +0.01);
  
      // thresholds for bang contRol
      let dRpyRateControlThreshold = new THREE.Vector3(0.0, 0.0, 0.0);
      let dPosRateControlThreshold = new THREE.Vector3(0.001, 0.001, 0.001);
  
      // define some phases where we want to have different movement behaviour
  
      if (dRpyRate.length() > 0.1)
      {
          // not correctly oriented, stop movement
          targetPosRate.x = 0;
          targetPosRate.y = 0;
          targetPosRate.z = 0;
      }
      else if (Math.abs(dPos.z)  +dRpyRateControlThreshold.x)
          rollLeft();
      if (dRpyRate.y  +dRpyRateControlThreshold.y)
          pitchUp();
      if (dRpyRate.z  +dRpyRateControlThreshold.z)
          yawLeft();
  
      // bang control to reach target motion
      if (dPosRate.x  +dPosRateControlThreshold.x)
          translateRight();
      if (dPosRate.y  +dPosRateControlThreshold.y)
          translateUp();
      if (dPosRate.z  +dPosRateControlThreshold.z)
          translateBackward();
  
  },100);

That makes it sound you approach this from a haughty presumptuous, uncharitable angle.

It sounds like you exclude the possibility that the author did not try it "your way" first, for example, but found a simpler way to implement it.

"That's not the most obvious to do it IMO" or "I would have preferred to do it like this..." are much better ways to approach this. Programs should be beautiful and understandable, but "idiomatic" sounds it excludes lots of simple beautiful solutions to a problem out of pure dogma.

  python -c "
  for x in stuff:
    this(x)
    that(x)
  "

  pyc-wrap "for x in stuff { this(x); that(x); }"

========

though after that i sort of went of the deep end adding perl-style "it" ($_) variables for loop variables:

  for stuff { this($); that($);

and for the result of the previous line:

  2; $+1; hex($);
  # roughly translates to:
  x = 2; x = x+1; x = hex(x);

edit: almost forgot - if during execution you used a name `foo` not found in locals/globals, `foo` was treated as an external command, and resolved to something like

  lambda *args: os.system('foo', *args)

---

¹ slightly more involved than a dumb code.replace('{', ':\n') because you need to maintain the indent level... but around that level of sophistication