Fixing the callback spaghetti in node.js (github.com)

Using await - is the program flow suspended until the corresponding function returns , or does await keyword act more like a 'pause and continue' mechanism.

I've been using LuaJIT embedded in Nginx (LuaNginxModule). Lua supports coroutines, so a function can just yield. Here's a brief example:

    -- Query a database using an http backend.
    -- Yields and handles other requests until the reply is complete.
    local record = util.getUserRecord(userId)

    -- Send some text to the client. Yields control while
    -- the actual transfer is in progress.
    ngx.print( "Result=" )
    
    -- Send the result, encoded as JSON, to the client
    -- Again, this call doesn't block the server.
    ngx.print( cjson.encode(result) )
    

I've been using OpenResty [1] which has the Lua module and a bunch of others all configured together. Works great, and I can't complain about the performance.

Someday I'm sure I'll hand the maintenance of this off, and then I might regret not using one of the "popular" frameworks. But the code is SO straightforward using this stack -- and what I'm using it for is so simple -- I think not.

[1] http://openresty.org/

We'd like to think that the C# guys were looking our way when they came up with async/await, but there's no proof. :3

For example, F#'s let! binding works with any monad not just async.

If you're going to innovate, then design a language that compiles down to JS that provides the innovation. CoffeeScript.

If you want to take that a step further, look at ClojureScript. Want delimited continuations? Fine. All w/o requiring you to fork Node.js or CoffeeScript.

This is not going to catch most errors occurring in an asynchronous APIs:

    try {
      asyncOperation(function(err, result) {
         // ...
      });
    } catch (e) {
      // ...
    }

Unless this supports that convention, your code should actually look like:

    async function magic() {
      try {
        // code here
        await err, bar = doSomething();
        if (err) {
          throw err;
        }
        // more code here
        await err, boo = doAnotherThing();
        if (err) {
          throw err;
        }
        // do even more stuff here
      }
      catch (e) {
        // handle the error
      }
    }

This certainly could support the "err" first convention, but APIs that don't use that convention wouldn't work correctly.

Using only that, I rarely go over 80 character column limit that I impose on myself. There is absolutely zero callback spaghetti whether it's 2 or 25 functions deep in the chain.

Tbh, callback spaghetti only happens to newer async programmers in the same way that a newer programmer will write arrow code with if/else statements.

It's simply not a problem that needs to be addressed other than educating people who are new to node.js with some example tutorials that use an async helper library.

(disclaimer: I am the guy who worked on the now-defunct `defer` support in Coffeescript, and am now working with the onilabs folk on the stratifiedJS runtime)

  function foo () {.... }
  function bar () {....foo(); }
  function barfoo () {....bar(); }

  doSomething(barfoo);

"Programs can be automatically transformed from direct style to CPS." [1]

Do the math.

[1] http://en.wikipedia.org/wiki/Continuation-passing_style

http://github.com/crabdude/trycatch