Mindset shifts for functional programming (with Clojure)

Post by KingMob » Thu, Apr 06, 2023, 5:57 AM UTC

samsquire wrote: post #86

janetacarr wrote: post #35

Earlier quoted context omitted.

Agreed, cyclomatic complexity is definitely something to be aware of when designing functional programming systems. Although, I disagree about Clojure's readability, but that's probably because I've been doing it for so long. Interesting Java project you've got there. Reminds me of Clojure's core.async library and software transaction memory ;) (though, I know it's not exactly the same thing). If I was transforming l…

I am really interested by Software transactional memory and enjoyed reading the Joe Duffy's blog posts about Midori and adventures with STM. https://github.com/joeduffy/joeduffy.github.io/blob/master/_... I like left-right concurrency control because it sidesteps a number of thread safety problems by ensuring that a thread can always safely read or write to its own buffer.

Post by KingMob » Thu, Apr 06, 2023, 7:37 AM UTC

austin-cheney wrote: post #92

KingMob wrote: post #90

Earlier quoted context omitted.

Recursion doesn't do that by default, though. And if you have to alter your code to run recursive fns on a new thread or executor, nothing prevents you from doing something similar with a loop, either.

Recursion does do that by default respective to what the given function executes. No alteration or special convention is required. Loops that require use of syntax other than a function call are synchronous only. If it would you can find me on IRC and I would be more than happy to show you how to program.

Post by chriswarbo » Thu, Apr 06, 2023, 9:44 AM UTC

LegionMammal978 wrote: post #70

chriswarbo wrote: post #67

Earlier quoted context omitted.

Many of the replies to this comment seem to have focused on the problem domain (numbers and booleans); and missed the main feature I was trying to show about recursion, which is a collection of functions delegating sub-tasks between themselves (rather than e.g. trampolining via a "main loop") A closer analogy to my code would be something like this: the domain logic is still abstracted and encapsulated into separate…

I think the underlying claim by the OP is that they don't really run into situations in practice that need this kind of mutual recursion. Certainly, mutual recursion is not at all necessary for this boolean example; you argue that the obvious imperative form is not a direct analogue, but it's not really clear in what situation a direct analogue is desirable in the first place.

  function main() {
    world = initWorld()
    while(true) {
      if (quitPressed()) break;

      delta = calculateVelocities(world)
      world = updatePositions(delta, world)
      collisions = findCollisions(world)
      world = handleEvents(mkEvents(collisions), world)
    }
    print("Goodbye")
    quit()
  }

  function main() { gameStep(initWorld()) }

  function gameStep(world) {
    if (quitPressed()) quit(print("Goodbye"))
    else worldStep(world)
  }

  function worldStep(world) {
    delta = calculateVelocities(world)
    updatePositions(delta, world)
  }

  function updatePositions(delta, world) {
    newWorld = 
    collisions = findCollisions(newWorld)
    handleEvents(mkEvents(collisions), newWorld)
  }

  function handleEvents(events, world) {
    newWorld = 
    gameStep(newWorld)
  }

Post by ColonelPhantom » Thu, Apr 06, 2023, 2:38 PM UTC

twawaaay wrote: post #69

janetacarr wrote: post #36

Earlier quoted context omitted.

I agree with your sentiment about recursion. It took me a damn long time to get used to it. But that's why I call it a mindset shift ;). If the codebase was written in Haskell, then there'd be no looping. Clojure is a bit odd in this case as it has a form called "loop" but it's really just a let binding over a fn, providing a point for `recur` to, well, recur to.

Again, the ultimate goal is to make the code readable (without sacrificing too much other qualities like performance). When you have a language and context that makes recursion easier to understand than loop -- go for recursion. One other reason to go for loops is to make sure you control the stack. With recursion it is not always immediately clear that the loop is going to get tail call optimisation. And good 9/10th…

Post by LegionMammal978 » Fri, Apr 07, 2023, 1:11 AM UTC

chriswarbo wrote: post #95

LegionMammal978 wrote: post #70

Earlier quoted context omitted.

I think the underlying claim by the OP is that they don't really run into situations in practice that need this kind of mutual recursion. Certainly, mutual recursion is not at all necessary for this boolean example; you argue that the obvious imperative form is not a direct analogue, but it's not really clear in what situation a direct analogue is desirable in the first place.

> I think the underlying claim by the OP is that they don't really run into situations in practice that need this kind of mutual recursion As mentioned in my comment, this is applicable wherever we have a "main loop". For example, a game might have a bunch of separate functions/methods to handle the various parts of the game; and a "main loop" which passes the return values of some as arguments to others: function ma…