I tried a couple of them recently. From (fab), to josi, to express.
And while (fab) is interesting conceptually, its syntax doesn't lend itself to easy understanding of which parts have a single, double, or ternary arity. Since it's basically chaining functions, the syntax highlighter can't tell the difference between the different parts w/ different arities.
Josi works pretty much as expected, especially if you're familiar with Sinatra. However, what doesn't make sense about it at all is that the http response is expected as a return from the controller methods. That doesn't make sense at all, since in order to take advantage of node's asynchronous nature, your database calls also need to be asynchronous--and this is usually done through anonymous function callbacks. I think this is the most important aspect to watch out for in the node.js frameworks.
Express doesn't suffer from this problem, and it also uses the Connect middleware. So far so good, and it's small enough that it's understandable.
I haven't checked whether any of these frameworks pollute the global namespace, but it doesn't seem like a problem yet.
I recently evaluated the state of the art in node.js frameworks for a project and came to some similar conclusions.
(fab) is incredibly cool, but lacks some maturity and the code is very dense and hard to reverse engineer.
geddy looks like a very solid framework, but I prefer having something a little more configurable and pluggable ... these types of things are coming, but geddy is a little too opinionated for my taste.
connect and express are what I am going with - in terms of heritage these are much more akin to sinatr/padrino, where geddy is a bit more railish. express/connect has a solid development team, burgeoning communitt and an agile and flexible underlying philosophy.
In a world where the dust is yet to settle on a default stack, I think having fewer opinions is actually a win ... as time progresses and there is a clear choice in node-land this will be less of an issue. but for now, loose coupling and high cohesion are the order of the day.
It's great to have such a rush from different developers. A "winner" will sooner or later emerge but the quantity of frameworks just show how many clever people are flocking around node.js.
Who says I want monoculture. However when one framework breaks out and gets traction, then you get a lot of things as an end user. Documentation, stability, plethora of open source plugins. Are these things so terrible?
