Hacker News Reader

Comment by weixiyen | Hacker News Reader

I wrote a library (30 loc) to handle sequence and parallel flows.

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.

View on HN

So instead of spaghetti code (a tangled mess) it now is macaroni code (small pieces of code everywhere, with unclear execution flow)? :-)

At least that's my experience with structuring asynchronous event-driven programs (without coroutines).

pretty much but I find it quite readable and maintainable. The execution flow is very clear though if you look at the comments in my gist.

Yes :) Still waiting for a proper execSync ( https://github.com/joyent/node/issues/1167 ).

Without it small build/utility scripts turn into macaroni cheese unless you resort back to Python/Ruby/Bash - more languages, harder to maintain.

I think this is coroutines under the hood?

IMHO the fact that the accepted solution to this problem is "use an async helper library" is a bad sign. This is so fundamental it should be part of the language, or at least runtime.

Actually that's a good point. I'd like to change my stance to it would be nice to have this language feature, but there are current workarounds that are decent.

i agree with you, i don't see it as a big issue. anyway: i'm excited that there are new/other paradigms out there. i'm not yet convinced that this the ultimate (if there is such a thing) solution, but i will give it a try.

got a link? I'd be interested to know how it deals with errors / exceptions, for example.

https://gist.github.com/1250084

Looks concise, but doesn't much help with the fundamental problems of callback code - exceptions don't work right, and "callbacks all the way down" whenever something starts having any async computation.

what do you mean by this -> "callbacks all the way down" whenever something starts having any async computation.

Imagine function a calls b() and function b calls c(), and they're all sync.

Now, let's say c() changes and needs to call someAsyncFunction() and provide a callback. Which means c itself needs to take a callback. Which means b needs to provide a callback, so b needs to also take a callback, so a needs to provide a callback. And so forth.

Callbacks are infectious - once anybody in the call stack needs one, everybody needs one even if they just pass it on down the stack. Unless you don't need to do anything with return values, but that's fairly rare.

I've been using: https://github.com/caolan/async

It looks pretty decent in CoffeeScript:

  blah = (done) ->
    async.series [
      (next) -> foo next
      (next) => @bar.baz 1, 2, 3, next
      (next) ->
        x = y
        z w next
    ], done

Reply on news.ycombinator.com