asyncblock

It would be tough for Fibers to be totally abandoned, as http://www.meteor.com/ relies on it. I don't think it's really needed any code updates recently, as it works on Linux / OS X / Windows and all recent versions of node. I think it's somewhat hard to tell what the adoption of fibers looks like, as it typically wouldn't be used by other modules in npm. You don't want to force people using your module to use fibers. So, it would mostly see its usage in applications. It will be interesting to see what happens to fibers once generators ship with core node (available now under the --harmony-generators v8 flag). The most compelling reasons for using fibers can also be met by using generators. (I maintain a library built on top of fibers: https://github.com/scriby/asyncblock)

https://github.com/scriby/asyncblock I'll just leave this here. It's been my pet project for the last couple years, and is a fully featured version of this concept. There's also https://github.com/0ctave/node-sync, which is the same concept.

Will these examples protect you from thrown exceptions? Null reference exception? Oops, your callback isn't getting called -- and you're probably leaking resources or leaving things in an inconsistent state. So the recommendation is to restart the process - but let's not forget that hundreds+ of other requests could currently be in the pipeline - are we just going to abort those too? Ok, we'll clearly the solution is to wrap all our callbacks with try/catch! Shoot me now... For large, sprawling applications used to support a business, something like https://github.com/scriby/asyncblock can resolve most of the headaches with async code, including error handling. It's worked out well for my team at work, which is building a "very large" node application. Disclaimer: Asyncblock is my pet project.

For those interested in the fibers way of doing things, I recommend checking out https://github.com/scriby/asyncblock. It provides an easy-to-use abstraction to get the best of both worlds (straight-line code without blocking). I don't think there really needs to be a fibers based ecosystem. Isn't it best if modules don't rely on fibers such that they can be reused in either context?

V8 isn't really designed to run multi-threaded code, which makes sense, since it's designed to run JavaScript code for the browser, and browser JS is single-threaded (except for Web Workers, which are isolated, and isolation requires a different style of code just like asynchronicity does). Here's one effort to add multithreading to V8: http://code.google.com/p/v8-juice/wiki/ThreadingInJS However, it has limitations because V8 isn't really intended to be used that way. If you just want to write code in blocking style, you can use asyncblock with node.js: https://github.com/scriby/asyncblock

Don't like callback hell? Use fibers. https://github.com/scriby/asyncblock (My pet project, a flow control library built on fibers that gives you all the benefits of async programming without the callbacks)

This appears only to support one-at-a-time synchronous control flow. Giving up parallel tasks is a funny proposition in node, as it's one of its greatest strengths. So this framework still seems limited in the potential uses, but maybe it will grow over time. I wrote a library based on fibers that can provide similar benefits to any node application. It also gives simple patterns for error handling, makes debugging easier by maintaining stack traces across async boundaries, and provides really easy ways to do series and parallel flow control. Take a look at https://github.com/scriby/asyncblock. It would actually be pretty cool to integrate asyncblock into this project as it could provide the flow control portion for free.

I wrote a module based on fibers to help with these sort of problems. Take a look at https://github.com/scriby/asyncblock