Hacker News Reader

Comment by inglor | Hacker News Reader

> In order to maximize your usage of this feature, you'll want to use modules from the ecosystem that expose Promise instead of just a callback.

Bluebird which is one of the most popular promise libraries converts entire callback APIs to promises in one go:

Promise.promisifyAll(require("fs")); // fs is now promisified and methods return promises.

(full disclosure, I'm a bluebird contributor)

View on HN

Can I import promisifyAll without bringing all of Bluebird?

promisifyAll is _blazing_ fast because it does this: https://github.com/petkaantonov/bluebird/blob/master/src/pro...

It builds a function dynamically and then compiles it and lets the JIT optimize it - it incurs very little overhead.

This is impossible if your only tool is the promise constructor. That said - there are packages that do this without bluebird - like thenify.

Also note - you can use bluebird for promisification and native promises for other stuff if you'd like and it'd work seamlessly as bluebird passes the Promises/A+ test suite.

Is that a no?

Do you have any data that shows Promise speed to be a blocker on UI performance?

Bluebird is mainly designed for node (V8) and promise performance can make a massive difference on the server. On the client there tend to be fewer async calls and so promise performance is usually less of a factor, but obviously, it depends what you're doing.

> promise performance can make a massive difference on the server.

Great, got data on the type of difference?

Check out the Bluebird benchmarks [0], or you can easily try it for yourself - create a simple web server which does some makework async task, like stating a bunch of files, then benchmark with ab or something better.

[0] https://github.com/petkaantonov/bluebird/blob/master/docs/do...

Why should I do the work, you made the claim?

By the same token, why do I owe you any further evidence?

You haven't provided any evidence so far. You owe evidence because you made a claim. If you are unsure whether Bluebird's Promise performance makes a difference in a real-world scenario, why make such a claim?

You are asking a question, I do not owe you an answer, it's up to you to find out whether this stuff matters for your use case. I've done these tests myself, it is trivial for you to do the same. Do your own homework.

> You are asking a question, I do not owe you an answer

I agree! But you did answer it:

> Bluebird is mainly designed for node (V8) and promise performance can make a massive difference on the server.

If I'm sacrificing simplicity (by using a non-native Promise implementation with a very large API) because of performance improvements, I want data (proof) of these performance improvements. If you don't have the data that's fine! No harm done, I'll keep waiting until someone does.

Which they provided by linking to the benchmark/data.

This is a thing you can just infer.

If it takes 100ms CPU time to process 10 promises and 1 request involves creating 10 promises, the server can then only handle 100 requests per second at theoretical max.

IO time doesn't matter as much (for throughput) because IO is asynchronous so the server is free to process other requests while waiting for it. But CPU time is only being used for 1 thing at at time.

So to get e.g. 10k rps out of a node server, handling 100000 promises must take well under a second of CPU time. Looking at the benchmark results you can see how many implementations will bottleneck this.

> promisifyAll is _blazing_ fast

I'm not sure I'd necessarily call ```promisifyAll()``` "blazing fast" but in all fairness it's a cost incurred up front and that's it so it's not that bad.

The call itself is relatively expensive, but as you say it's a one off call at startup time and the methods it produces are faster than explicit promisification using `new Promise`, they are blazing fast :)

Check out github.com/sindresorhus/pify

Reply on news.ycombinator.com