A flow control library that fits in a slideshow
Switch branches/tags
Nothing to show
Clone or download
Latest commit 77a5b62 Jun 15, 2016
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
lib wait for all callbacks to complete Sep 12, 2014
test Add first tests for chain Jun 15, 2016
.travis.yml Add .travis.yml Jun 23, 2016
LICENSE isc license Aug 19, 2013
README.md Replace pdf by README.md. Apr 29, 2013
index.js Just expose a main module, not a lib dir Feb 3, 2011
package.json Add first tests for chain Jun 15, 2016

README.md

Controlling Flow: callbacks are easy

What's actually hard?

  • Doing a bunch of things in a specific order.
  • Knowing when stuff is done.
  • Handling failures.
  • Breaking up functionality into parts (avoid nested inline callbacks)

Common Mistakes

  • Abandoning convention and consistency.
  • Putting all callbacks inline.
  • Using libraries without grokking them.
  • Trying to make async code look sync.

Define Conventions

  • Two kinds of functions: actors take action, callbacks get results.
  • Essentially the continuation pattern. Resulting code looks similar to fibers, but is much simpler to implement.
  • Node works this way in the lowlevel APIs already, and it's very flexible.

Callbacks

  • Simple responders
  • Must always be prepared to handle errors, that's why it's the first argument.
  • Often inline anonymous, but not always.
  • Can trap and call other callbacks with modified data, or pass errors upwards.

Actors

  • Last argument is a callback.
  • If any error occurs, and can't be handled, pass it to the callback and return.
  • Must not throw. Return value ignored.
  • return x ==> return cb(null, x)
  • throw er ==> return cb(er)
// return true if a path is either
// a symlink or a directory.
function isLinkOrDir (path, cb) {
  fs.lstat(path, function (er, s) {
    if (er) return cb(er)
    return cb(null, s.isDirectory() || s.isSymbolicLink())
  })
}

asyncMap

Usecases

  • I have a list of 10 files, and need to read all of them, and then continue when they're all done.
  • I have a dozen URLs, and need to fetch them all, and then continue when they're all done.
  • I have 4 connected users, and need to send a message to all of them, and then continue when that's done.
  • I have a list of n things, and I need to dosomething with all of them, in parallel, and get the results once they're all complete.

Solution

var asyncMap = require("slide").asyncMap
function writeFiles (files, what, cb) {
  asyncMap(files, function (f, cb) {
    fs.writeFile(f, what, cb)
  }, cb)
}
writeFiles([my, file, list], "foo", cb)

chain

Usecases

  • I have to do a bunch of things, in order. Get db credentials out of a file, read the data from the db, write that data to another file.
  • If anything fails, do not continue.
  • I still have to provide an array of functions, which is a lot of boilerplate, and a pita if your functions take args like
function (cb) {
  blah(a, b, c, cb)
}
  • Results are discarded, which is a bit lame.
  • No way to branch.

Solution

  • reduces boilerplate by converting an array of [fn, args] to an actor that takes no arguments (except cb)
  • A bit like Function#bind, but tailored for our use-case.
  • bindActor(obj, "method", a, b, c)
  • bindActor(fn, a, b, c)
  • bindActor(obj, fn, a, b, c)
  • branching, skipping over falsey arguments
chain([
  doThing && [thing, a, b, c]
, isFoo && [doFoo, "foo"]
, subChain && [chain, [one, two]]
], cb)
  • tracking results: results are stored in an optional array passed as argument, last result is always in results[results.length - 1].
  • treat chain.first and chain.last as placeholders for the first/last result up until that point.

Non-trivial example

  • Read number files in a directory
  • Add the results together
  • Ping a web service with the result
  • Write the response to a file
  • Delete the number files
var chain = require("slide").chain
function myProgram (cb) {
  var res = [], last = chain.last, first = chain.first
  chain([
    [fs, "readdir", "the-directory"]
  , [readFiles, "the-directory", last]
  , [sum, last]
  , [ping, "POST", "example.com", 80, "/foo", last]
  , [fs, "writeFile", "result.txt", last]
  , [rmFiles, "./the-directory", first]
  ], res, cb)
}

Conclusion: Convention Profits

  • Consistent API from top to bottom.
  • Sneak in at any point to inject functionality. Testable, reusable, ...
  • When ruby and python users whine, you can smile condescendingly.