Why should you learn about sports just so you can participate a conversation of content won't matter in a week? I recommend a different approach: Have a conversation about something constructive that your peers might not know about. "Did you read gwern's article about spaced repetition?"[1] "I played around with WebRTC last week and got video chat working. I found a lot of bugs in Chrome and Firefox..." "Have you ever wondered how async.js avoids exploding the stack if you give it synchronous functions?"[2] Etc.
This can enrich your peers as well as yourself. Heck, they might even follow your lead and do more interesting things in their spare time.
1. http://www.gwern.net/Spaced%20repetition
2. Actually, it looks like sync detection was reverted a few months ago. It was initially added in https://github.com/caolan/async/commit/6ad64aca4c0
caolan
async
JavaScript2010–2020
caolan / async
async
Async utilities for node and the browser
76Distinct people
81Mentions
2Explicit recommenders
28.1KGitHub stars
What to know before exploring
What it is
Async utilities for node and the browser
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
It's a little tiring to see some of the same old fallacies about Node repeated ad infinitum in this thread. I suspect a lot of the complaints stem from poor development…
yid used a recommendation phrase. 2 indexed comments match. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
- creationix/step · linked in 3 of the same discussions
- kriskowal/q · linked in 2 of the same discussions
- nodejs/node-v0.x-archive · linked in 2 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 7:56:55 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year81 dated mentions
Observed mentions: 2010-10-12 01:05:50 UTC to 2020-01-21 18:21:07 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2010 | 2010-01-01 00:00:00 UTC | 2011-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2011 | 2011-01-01 00:00:00 UTC | 2012-01-01 00:00:00 UTC | 18 | 1 | 17 |
| 2012 | 2012-01-01 00:00:00 UTC | 2013-01-01 00:00:00 UTC | 21 | 0 | 21 |
| 2013 | 2013-01-01 00:00:00 UTC | 2014-01-01 00:00:00 UTC | 18 | 0 | 18 |
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 10 | 0 | 10 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 6 | 2 | 4 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 0 | 0 | 0 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 1 | 0 | 1 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Async is a utility module which provides straight-forward, powerful functions for working with asynchronous JavaScript. Although originally designed for use with Node.js and installable via npm i async, it can also be used directly in the browser. An ESM/MJS version is included in the main async package that should automatically be used with compatible bundlers such as Webpack and Rollup.
A pure ESM version of Async is available as async-es.
For Documentation, visit https://caolan.github.io/async/
For Async v1.5.x documentation, go HERE
// for use with Node-style callbacks...
var async = require("async");
var obj = {dev: "/dev.json", test: "/test.json", prod: "/prod.json"};
var configs = {};
async.forEachOf(obj, (value, key, callback) => {
fs.readFile(__dirname + value, "utf8", (err, data) => {
if (err) return callback(err);
try {
configs[key] = JSON.parse(data);
} catch (e) {
return callback(e);
}
callback();
});
}, err => {
if (err) console.error(err.message);
// configs is now a map of JSON data
doSomethingWith(configs);
});
var async = require("async");
// ...or ES2017 async functions
async.mapLimit(urls, 5, async function(url) {
const response = await fetch(url)
return response.body
}, (err, results) => {
if (err) throw err
// results is now an array of the response bodies
console.log(results)
})
Read the full README on GitHubWhat Hacker News says
18 sourcesIn Play Fantasy Even If You Hate Football
I like your examples. As one who is casually familiar with promises, I would find it helpful to see more promise patterns/recipes. In particular, how about a blog post on the promise equivalents to the https://github.com/caolan/async Collections and Control Flow methods (since that library seems to be heavily used in the node community)? Would a higher level promises utility library be appropriate or overkill?
In Bluebird – A full-featured, fast promises library for JavaScriptHere are some results from my benchmark [1]
results for 20000 parallel executions, 1 ms per I/O op
file time(ms) memory(MB)
promiseishBluebird.js 1076 76.08
async.js 2634 113.79
promiseishKew.js 2654 123.50
promiseishQ.js 56508 804.21
note: async.js is basically waterfall from https://github.com/caolan/async
[1]: https://github.com/spion/async-compare
In Bluebird – A full-featured, fast promises library for JavaScriptmaybe https://github.com/caolan/async is the answer?
In Raw: the missing link between spreadsheets and vector graphicsInteresting article... my 2c is that you might want try a library like async.js, that handles asynchronous code with explicity flow-control based structure. Async has throttling ( https://github.com/caolan/async#queue ) and all kinds of things built into it that can address some of those things.. for other things where you are worried about buffers, you could use things like RabbitMQ or AWS-SQS to mitigate situations where you have mismatch in push/pull.
In It ain't about the callbacks, it's about the flow control> Some people simply love to nest callbacks... Anytime I see that it drives me crazy....
This is the correct reaction to heavily nested callbacks.
https://github.com/caolan/async provides several excellent functions to make readable code instead of callback soup.
In Why JavaScript Will Become the Dominant Programming Language of the EnterpriseI don't understand what the big deal is. Callbacks are OK. They're less cumbersome if the language you're using has smaller function definitions.
Callbacks 'get crazy' when you've got more than one I think, and thankfully someone smart has made a library you can use to manage them!
https://github.com/caolan/async
Saying that, I don't mind the way things look with the whole await/async stuff in C# and etc. However I don't think we should be waving our arms around saying callbacks are like goto, they so completely are not! I have written heaps of stuff with callbacks and it's _not that confusing or unmaintainable_. It's just different.
In Callbacks as our Generation's Goto StatementI have just started doing development in Node.js. Originally using the excellent caolan/async library (https://github.com/caolan/async) for handling synchronous situations. Now started moving towards Promises but finding it quite hard to locate any "Promises for Dummies" type guide. Most of the libraries like "q" etc (https://github.com/kriskowal/q) just give you a list of functions to use and related syntax but I have yet to come across a guide that goes into detail as to exactly how and why you use certain functions.
I am kind of figuring things out as I go along but if anyone here can point me to such guides, I would be most grateful.
In Promises/A+Just a note for anyone interested in what was mentioned in the article but more comfortable with JavaScript.
There is mori http://swannodette.github.io/mori/#mori for persistent data structures.
Callbacks are handled by Promises or say async https://github.com/caolan/async
For heavy compute tasks you can launch child processes under Node.js and communicate with one management process, the Cluster http://nodejs.org/docs/latest/api/cluster.html lib is experimental as of now.
In Why I am so excited about ClojureOne of "coolest" things about Javascript (that persuades many to try Node) is that it has a non-blocking control-flow. But if you are coming to Node from a PHP/Ruby background, you might lament the default synchronicity of PHP. For example, you query your database in PHP, you can rest assured that your program doesn't keep running without the DB result. In Node, you either 1.) descend into "callback hell" or 2.) use some sort of Async module [ https://github.com/caolan/async ]. I personally love Node but would say 'Expect to learn new patterns' to anyone making a transition to it.
In “Why are you using Node.js rather than PHP?”I posted this comment:
"It's obvious that you're new to Node.js.
First of all, you should be aware that Async.js is a mere flow-control library. It does not offload work to separate threads, and neither is it able to parallelize work. Internally, it mostly does bean-counting (but very helpfully so).
As you can see in the source https://github.com/caolan/async/blob/master/lib/async.js#L35... async.sortBy simply uses Array.sort for the actual sorting. The only reason you'd want to use Async.sortBy is if the values that the array of "keys" is not known beforehand (and needed to be loaded through io - asynchronously). This is clearly exemplified in the documentation. https://github.com/caolan/async#sortBy
The implication of this that your call to async.sortby can be replaced by a call to array.sort. This will remove two unnecessary runs of a
Read the rest
sync.map, inflicting a potentially huge performance penalty.
You do need to pass array.sort a comparator function, otherwise it will sort lexicographically (see https://developer.mozilla.org/en-US/docs/JavaScript/Referenc... ). That said, I'm not sure what the actual contents of your input file is. In your .Net example, you do not seem to bother to convert the array of strings to an array of ints (or floats). I think that .Net sort will sort an array of strings lexicographically as well. Furthermore, in the node.js example, you seem to be content with returning the resulting median as an int, not as float. Do the input "decimals" in the input file represent ints or floats? Do they all have exactly the same amount of decimals? Are both the Node.js and .Net algorithms doing the same thing? I think not.
Finally, we get to Array.sort. Array.sort blocks. Depending on the multi-threading efficiency of the underlying algorithm of Array.sort (which I don't have insight in), the code may not be able to use all available system resources. Keep in mind that Node.js is single-threaded. I practically don't know anything about .Net, but I assume it will magically start new processes and or threads if the runtime deems this beneficial. For Node.js, you may want to try the Cluster api, http://nodejs.org/api/cluster.html . You could try seeing if performance increases by adding one or more extra server processes.
I can't comment about the quality of the .net code since I don't have any experience with it.
I think it would be fair (and very educative to others) if you'd rerun the benchmarks with
1. Async.sortBy replaced with array.sort
2. with both .Net and Node.js algorithms fully doing the same thing (i.e. let them both sort either floats, ints, or strings), and
3. at least one extra server process for Node.
I think most interesting would be if you'd made the changes step-by-step, and run the benchmarks at each step.
My guess is that step 1 would give the biggest difference.
Depending on how you decide to resolve the differences in the two algorithms, performance of your .Net code may be slightly affected. It could potentially be speed up in fact, if somehow it's able to sort ints (or floats) faster than strings. The actual job of sorting probably overshadows it all though."
What do you guys think of this?
Sorry I didn't express myself correctly (see my reply to akuchling below).
Basically yes, Python had Twisted for years, it had Diesel, Monocle, Tornado, and some other ones. I am aware of those and as you've read my comment you saw that I used Twisted enough to know its ins and outs (5 years).
> There are also async frameworks that make writing async code the same as synchronous code.
Yes there is inlineCallbacks and I used. Node.js also has async (https://github.com/caolan/async). But you don't address the main problem that I raised -- fragmentation of libraries. Python is great because it comes with batteries, and then you can find even more batteries everywhere, _except_ if you use an async framework like Twisted, which, percolates all the way through you API code. Once your socket.recv() returns a Deferred(), that deferred will bubbl
Read the rest
e up all the way to the user interface. So you now you end up searching or recreating a parallel set of libraries.
> Twisted has a lot of libraries but it has so much going on that many developers find it too complex.
It is too complex with too many libraries for those who want to take it up but it is not complex and doesn't have enough libraries if you are in it already -- every library you use has to be Twisted now. That's the danger of inventing a new framework.
Yes it will be standard, but there is already a practical standard -- eventlet and gevent. This is somethin Node.js doesn't have. I will personally take monkey-patching and the danger that my function will context switch inside while doing IO over using Twisted. I saw a practical benefit from it at least.
https://github.com/caolan/async
Once I started using the async library, all of these problems everyone is illustrating basically disappeared.
In Escape from Callback HellI find LiveScript's back-calls (<-) very elegant. In fact it makes concurrent code very easy to write and comprehend. Combined with async (https://github.com/caolan/async) it is a pure joy.
As for pure JavaScript, dealing with callbacks is definitely not fun.
In Escape from Callback HellA great library for structuring your callbacks is "async":
https://github.com/caolan/async
I've only used it with node.js, but it's supposed to work in web browsers as well.
It allows you to think a little more procedurally ("waterfall" is especially handy here) while writing CPS code. Very good.
In Escape from Callback HellShowing the 15 most recent of 18 sources. Enable JavaScript to search and browse every indexed mention.