Rendering page asynchronously issue

The problem with your code is that you're saying "go do these two things for a while and then send my response." -- in other words you've told node to go into the other room to get the next pages of a book, and told it to do when it was done doing that, but then when it was out of the room, you just continued trying to read the book without the new pages.

What you need to do is instead send your response only when the two database queries are done.

There are several ways you can do that, how you do it is up to you.

You can chain the queries. This is inefficient since you're doing one query, waiting for it to return, doing the second, waiting for it to return and then sending your response, but it's the most basic way to do it.

   var content = '';
   db.query(imageQuery,function(images){
       content += images;
       db.query(userQuery,function(users){
           content += users;
           response.end('<div id="page">'+content+'</div>');
       });
   });

See how the response.end is now inside the last db.query's callback, which inside the first db.query's callback? This guarantees order of operations however. Your first query will ALWAYS complete first.

You could also write some sort of primitive latching system to run the queries in parallel. This is a little more efficient (they don't necessarily happen simultaneously, but it'll be faster than chaining them.) However, with this method you can't guarantee order of operations.

var _latch = 0;
var resp = '';

var complete = function(content){
    resp += content;
    ++_latch;
    if(_latch === 2){
        response.end('<div id="page">'+resp+'</div>');
    }
};

db.query(imageQuery, complete);
db.query(userQuery, complete);

So what you're doing there is saying run these queries and then call the same function. That function aggregates the responses and then counts the number of time it's been called. When it's been called the number of times you're making queries, it then returns the results to the user.

These are the two basic ways of handling multiple asynchronous methods. However, there are a lot of utilities to help you do this so you don't have to handle it manually.

• async is a great library that will help you run async functions in series, parallel, waterfall, etc. Takes a TON of pain out of async management.
• runnel is a similar library, but with a much smaller focus than async
• q or bluebird are promises librarys implementing promises/a+. This provides a different concept behind flow control (if you're familiar with jQuery's deferred object, this is the idea that they were trying to implement.

You can read more about promises here, but a quick google will also help explain the concept.