It&#x27;s interesting to use languages that do not harshly penalize recursion by imposing stack size limits.  The upcoming GNU Guile 2.2 release, a Scheme implementation, has a dynamically expandable stack so algorithms that are naturally recursive can be implemented that way rather than contorted into iterative form to please the stack limit god.<p>For example, in Guile 2.0, this natural definition of &#x27;map&#x27; will cause the stack to overflow on large lists:<p><pre><code>    (define (map proc lst)
      (if (null? lst)
          &#x27;()
          (cons (proc (car lst))
                (map proc (cdr lst)))))
</code></pre>
The iterative solution is to construct the list backwards and reverse it as a final step:<p><pre><code>    (define (map proc lst)
      (let loop ((lst lst)
                 (result &#x27;()))
        (if (null? lst)
            (reverse result)
            (loop (cdr lst) (cons (proc (car lst)) result)))))
</code></pre>
There&#x27;s no real gain here in terms of performance or readability.  You trade a large stack for a large reverse operation at the end.  Guile 2.2 allows a whole class of recursive algorithms that were not practical before because of the fixed size stack (like most languages I know of), and they perform well, too!<p>Needless to say I agree with this article.  Recursion is an integral part of computing, and more programming languages should provide better support for it. Embrace it, don&#x27;t avoid it!