Asynchronous Iteration Patterns (in Node.js) (metaduck.com)

Correct me if I'm wrong, but I don't think he means tail recursion. It's recursion, yes. But does tail recursion even make sense in an asynchronous setting?

In languages that are not fundamentally synchronous, such as Erlang, you do not leap through hoops to manage this. You simply write a function that performs your insertions in the straightforward and obvious way, and the runtime manages it with no blocking at any point.

I actually don't like the frequently-made assertion that "a pattern is automatically a weakness in the language", but it does apply here. As the Node.js community laboriously builds up the patterns necessary to work in this paradigm, recapitulating the work done in numerous other async-on-top-of-sync-language libraries, it probably is worth keeping the assertion in mind. You shouldn't even have to think about this, let alone argue which way is the best way to do it.

(Somebody modded this down. Maybe I should make it clear that I'm actually speaking from experience on another asynchronous project written in Perl on top of glib's asynchronousness, which isn't fundamentally different from Node.js'. I'm not speculating, I've been on the receiving end of this complexity explosion. It will happen.)

http://groups.google.com/group/nodejs/browse_thread/thread/c...

Also, that guy is responsible for nodetuts, which I'm very thankful for!

http://nodetuts.com/index.html

   function insertCollection(collection) {
     for(var i = 0; i < collection.length; i++) {
       db.insert(collection[i]);
     }
   }

  function insertCollection(collection, callback) {
    var coll = collection.slice(0); // clone collection
    (function insertOne() {
      var record = coll.splice(0, 1)[0];
      try {
        db.insert(record, function(err) {
          if (err) { callback(err); return }
          if (coll.length == 0) {
            callback();
          } else {
            insertOne();
          }
        }
      } catch (exception) {
        callback(exception);
      }
    })();
  }

This is awesome that you wrote a post on this, it is an important building block to proper node.js coding. I know I had trouble with it.

There is another way to handle asynchronous iteration, while similar to what you have done, gives a bit more flexibility and is abstracted out so you can use it anywhere.

https://gist.github.com/b5af7369ec9939ab7d94

This is using code from a script of mine as an example, but it should be pretty easy to see the pattern.

Here is your above serialized example with the above function I just showed you:

https://gist.github.com/26bda51358610667f9f3

---

On a side note, I wanted to say that people hell bent on turning node.js into another language should just use that language. There is nothing wrong with the way node.js handles asynchronous code, and really keeping everything asynchronous instead of building in stuff to fake synchronous code is bad for node.js and the whole ecosystem. It promotes bad habits and bad code. If you can't handle callbacks or events, then maybe you should go back to using whatever you are more comfortable with, or write your own abstractions.

https://gist.github.com/845874

    @defer.inlineCallbacks
    def insertCollection(collection):
        for ob in collection:
            yield db.insert(ob)

I agree with substack that you can do this without changing the language, but you do have to get something usable to people at some point.

I think most people who write any code in node.js run into this issue. I am a casual user, but ran into it a couple of days ago and did some research to find that there are many third-party modules I could bring in to do a for loop, but nothing built-in. The old way of doing this in twisted (manually managing deferreds) really turned a lot of people off. By the time twisted got inlineDeferreds and inlineCallbacks, people already had their impressions of how difficult things are.

I still think node.js is fun and viable, but it does need a for loop.