Faking Co-Routines, or Why Callback Hell Is Over (2014)

These days I write JavaScript using only functions, literals, variables, and the occasional prototype and it's amazing.

I think many programmers have a desire to believe they are working on complex problems that demand sophisticated tools. I remember learning Ruby and being excited whenever I found a reason to write a DSL. In retrospect it was unnecessary every time. In every case the code would've been clearer if I had just stuck with functions and kept refactoring until I had the right interfaces and data structures.

It helps to remember

    function a() {
      b(function() {
        //etc
      })
    }

    function a() {
      b(c)
    }

    function c() {
      //etc
    }

> function a() { b(function() { //etc }) } is equivalent to

> function a() { b(c) } function c() { //etc } which is not particularly more verbose. And as a side benefit, refactoring that way gives you an opportunity to make c() self-documenting.

It's not always equivalent, since you can have closures.

This makes it impossible, for instance, to write a nice I/O library that is to be called from within a generator (the library is supposed to yield on a blocking situation).