What was once only considered a language to add enhancements and widgets to a web page has since evolved into its own fully-fledged ecosystem. As of the beginning of 2015, it stands as the second most popular language in terms of questions tagged on stack overflow, next to only Java, with around a million questions tagged on it. There are tons of frameworks and environments to make it possible to run JavaScript almost anywhere. I believe Atwood's law says it best:
While this quote dates back to 2007, it's never been more true than today. Not only can you use JavaScript to develop a complete single-page application such as Gmail, but you will also see how we can achieve the following projects with JavaScript in the coming chapters of the book:
With the introduction of Node.js, JavaScript has officially gone in a direction that was never even possible before. Now you can use JavaScript on the server and you can also use it to develop full-scale, enterprise-level applications. When you combine this with the power of MongoDB and its JSON-powered data, you can work with JavaScript in every layer of your application.
Let's quickly go through some basic concepts of Node.js and MongoDB, which would be helpful for you to follow the rest of the chapters in this book.
One of the most important things that people get confused about while getting introduced to Node.js is to understand what exactly it is. Is it a different language altogether, is it just a framework on top of it, or is it something else? Node.js is definitely not a new language, and it is not just a framework on JavaScript. It can be considered as a runtime environment for JavaScript built on top of Google's V8 engine. So, it provides us with a context where we can write JavaScript code on any platform where Node.js can be installed. Anywhere!
Now a bit about its history! Back in 2009, Ryan Dahl gave a presentation at JSConf that changed JavaScript forever. During his presentation, he introduced Node.js to the JavaScript community. After a roughly 45-minute talk, he concluded it, receiving a standing ovation from the audience in the process. He was inspired to write Node.js after he saw a simple file upload progress bar on Flickr, the image-sharing site. Realizing that the site was going about the whole process the wrong way, he
decided that there had to be a better solution.
Now let's go through the features of Node.js, which makes it unique from other server-side programming languages.
The V8 engine was developed by Google and was open sourced in 2008. As we all know, JavaScript is an interpreted language and it will not be as efficient as a compiled language, as each line of code gets interpreted one by one while the code gets executed. The V8 engine brings in an efficient model here, where the JavaScript code will be compiled into machine-level code and the executions will happen on the compiled code instead of interpreting the JavaScript.
With the advent of web, the traditional JavaScript was intended for adding simple functionality and minimal runtime in browser. Thus, JavaScript was kept single threaded scripting language. Now just to get a brief idea regarding single threaded models, lets consider the following diagram.
A single threaded model creates a single callstack in an execution context. In preceding code, when the function getData() is invoked, the function is pushed in stack for execution sequentially.
In context of Node.js, JavaScript is the base scripting language, hence Node.js is single threaded.
You might be asking, how does a single threaded model help? Typical PHP, ASP.NET, Ruby, or Java-based servers follow a model where each client request results in the instantiation of a new thread or even a process. When it comes to Node.js, requests are run on the same thread with even shared resources. A common question that is often asked is what will be the advantage of using such a model? To understand this, we should understand the problem that Node.js tries to resolve. It tries to do asynchronous processing on a single thread to provide more performance and scalability for applications that are supposed to handle too much web traffic. Imagine web applications that handle millions of concurrent requests; if the server makes a new thread for handling each request that comes in, it will consume a lot of resources and we would end up trying to add more and more servers to increase the scalability of the application. The single threaded asynchronous processing model has its advantage in the previous context, and you can process much more concurrent requests with less number of server-side resources. However, there is a downside to this approach; Node (by default) will not utilize the number of CPU cores available on the server it is running on without using extra modules like pm2.
One of the most powerful features of Node is that it is event-driven and asynchronous. So how does an asynchronous model work? Imagine you have a block of code and at some nth line you have an operation that is time consuming. So what happens to the lines that follow the nth line while this code gets executed? In normal synchronous programming models, the lines that follow the nth line will have to wait till the operation at that line completes. An asynchronous model handles this case differently. Let us visualize this scenario with help of following code and a figure.
In preceding case the setTimeout method is provided by JavaScript(Node.js) api. Hence, this method is recognized as synchronous and is executed in different execution context. According to functionality to setTimeout it executes the callback function after specified duration in our case after three seconds.
Further, the current execution is never blocked for a process to complete. When node api determines that the completion of event has been fired, it will execute your callback function at that moment.
In a typical synchronous programming language, executing the preceding code
will yield the following output:
Writing applications with Node is really enjoyable when you realize the sheer wealth of information and tools at your disposal! Using Node's built-in package manager npm, you can find literally tens of thousands of modules that can be installed and used within your application with just a few keystrokes! One of the reasons for the biggest success of Node.js is npm, which is one of the best package managers out there with a very minute learning curve. If this is the first ever package manager
that you are getting exposed to, then you should consider yourself lucky!
On a regular month, npm handles more than a billion downloads and it has around 150,000 packages currently available for you to download. You can view the library of available modules by visiting www.npmjs.com. Downloading and installing any module within your application is as simple as executing the npm install package command. Have you written a module that you want to share with the world? You can package it up using npm and upload it to the public www.npmjs.org registry just as easily! If you are not sure how a module you installed works, the source code is right there in your projects' node_modules/ folder waiting to be explored!!
In this chapter, we reviewed what is to be expected throughout the rest of this book. We discussed the amazing current state of JavaScript and how it can be used to power the full stack of a web application. Not that you needed any convincing in the first place, but I hope you're excited and ready to get started writing web applications using Node.js and MongoDB! Next up, we will set up your development environment and get you up and running with Node, MongoDB, and npm as well as write and launch a quick Node app that uses MongoDB!