Node.js is a relatively new platform and is still evolving; however, it's already had a huge impact on the way we develop applications for the web, and it is becoming more popular by the day. You maybe surprised to know that Node is currently powering web services for some of the Internet's largest companies. What are the reasons behind its success?

The first and most important advantage of Node.js is JavaScript. If you know how to program in JavaScript and you're comfortable with its syntax, you already know how to program in Node.js. The only thing you need to do is learn all about APIs and modules. Node.js is based on simplicity—the core functionality is kept to a minimum, and the existing APIs are simple and easy-to-use. If you want to build something more complex, you can easily choose, download, and install any of the third-party modules.

If you think about it, the fact that Node is based on JavaScript is highly convenient because we've been programming software frontends in JavaScript for years, and now, we can build an entire web application, backend and frontend, in JavaScript. The cherry on the cake is that we can also use JavaScript to interact with the database now.

One of the other reasons that have contributed to making Node.js so popular is that many large companies have invested heavily in Node in the past years. Starting from Joyent, many other companies have invested and built software on Node, assuring it a stable future.

Since the very beginning, Node.js has focused on the performance, and this is reflected in the way it is designed. Typical network applications are based on "blocking" operations and multithreading. In practice, what this means is that in the traditional network programming, the processing of a request cannot continue until the previous operation finishes.

The problem with this programming model is that it doesn't scale well, so the problem was originally solved with multithreaded programming. Threads are light-weight processes that share memory with all other threads in the same process, and a network application based on this model means that when a thread is waiting for an I/O operation to complete, another thread can start serving a new request. The problem with this type of approach is that, although it is much more efficient than traditional single-threaded programming, creating new threads adds a great layer of overhead. This is particularly evident when you need to handle thousands of concurrent connections. Node.js to the rescue!

Node.js adapts a different model called event-driven programming. In this model, the flow of execution is determined by events. Events are handled by event handlers and callbacks functions that are invoked as a response to an event. If you already know how to program in JavaScript, you may already be familiar with the concept of listening for events. Node.js uses this same approach in every aspect of its platform. In practice, I/O operations, server requests, and interactions with a database will all be handled using a callback function attached to an event listener.

If you don't have any previous experience with Node.js or event-driven programming, this approach may seem confusing at the beginning. Let's try to clarify it with an example.

Consider how a sample query is executed in traditional blocking programming to a database:

var queryResult = database.query("Example query");
do_something_with_result(queryResult);

As you can see from this example, this query requires the thread or process that runs the query to finish processing it before saving the result.

In an event-driven environment, this query can be performed like this:

var queryFinished = function(result) {
    do_something_with_result(result);
};
database.query("Example query", queryFinished);

The first thing defined is what will happen when the query has finished. This is saved as a function in the queryFinished variable, but it could also be provided as an inline callback function. This variable is then passed as an argument to the query function. In practice, when the database finishes processing the query, the queryFinished function will automatically be called.

As you can see from this simple example, instead of using a return value, we define a function that is called when something interesting happens—in this case, when the query completes. This style of programming is called the event-driven or asynchronous programming and is at the base of Node.js.

By now, you must have understood why Node.js is such a popular choice when developing web applications; being based on an event-driven design means that the Node.js process will never block when it performs I/O and, more importantly, multiple I/O operations can occur in parallel without using threads.

The fact that Node.js works in an asynchronous manner makes it a perfect match for RethinkDB, as the combination of these two technologies allow us to develop web applications with the capability of handling a very high load and exploiting some of RethinkDB's unique features, such as Changefeeds, which we will take a look at further on in this chapter.

Now that we know a little more about Node.js, it's time to install it and start using it to run queries on our database!