In beginner tutorials, Node's non-blocking nature is usually demonstrated by showing a blocking example (using a return statement) and the non-blocking Node example (using callbacks). For an example, see here.
Should I take it as a "smell" that using return creates blocking code in my Node app, and find a way to redo it using callbacks?
TL;DR: if code may take a "long" time, it may be cleaner/more efficient to handle it with a callback.
It's not about return/not-return, it's about what the code actually does.
The example function doesn't block because there's a return, it blocks because db.query takes an arbitrary amount of time. If you want to do other things during that time, return right away, and do the result processing in the callback.
Whether or not you should depends on what's actually going on, what else may be affected by, or depend on, the data passed to the callback (or returned), and so on.
Blocking calls typically return something because the return happens after the "action" caused by the call, so it can return information about the success or failure of the action, and any data produced by the action. This applies also to calls that don't block per se, but don't do i/o, so the callback isn't needed.
Non-blocking calls, such as one to a function that reads a file, don't tend to make use of the return value because they typically return before they do anything of significance. Instead, they call the callback and send it whatever data was produced, or possibly an error message.
The main motivation behind a using a non-blocking call is that you are waiting for some external process or device to return, so you release control of the thread to allow other operations to run "while you wait".
Because non-blocking/asynchronous code using callbacks is more difficult to write, read, and maintain you should avoid non-blocking code except where it will make a difference in the performance and scalability of your application, or where it is required by an API you are using.
Consider this relatively silly example:
function add(a,b,cb) { cb(a+b); }
console.log('2+2 is', add(2,2)); // -> 4
function add(a,b) { return a+b; }
add(2,2,function(sum) { console.log('2+2 is', sum); }); // -> 4
The first one is a fair bit easier on the eyes.
Many node APIs have an asynchronous version but no syncronous version. When using those APIs it will be obvious that you need to make your code asynchronous.
In cases where you have a choice (as when reading a file) ask yourself: "Will a blocking call make the end-user wait for an unreasonable amount of time?". During application startup the answer is generally "no" because that code only runs once and the end users haven't had the chance to touch the server. However, if you are responding to a web request then making all users wait for an outbound API call or disk read will slow down the site for all the users, whereas a non-blocking call allows node to continue processing new requests until the data you requested comes back.
