node.js Hosting : Compare Hosting

What is Node.js Hosting?

Node.js is an event-driven runtime environment and development framework. It can be used to build server-side web applications, and its architecture allows for massive scalability.

In most conventional web server environments, requests are handled as single, discreet events: A request is made to the server, the server does something, and a response is sent back. This makes it difficult to get ongoing feedback about any kind of process (like a file-upload progress bar), or to do any kind of push notification.

The usual way these sorts of things were done was essentially a hack: send a series of frequent requests over and over to check on progress of fetch new notification.

Node.js was invented to provide a different way of handling client-server I/O (input/output).

JavaScript on the server?

JavaScript was originally designed as a scripting language for web browsers. It provides a way to add logic and computation to what is otherwise (in essence) a document-reading application.

But it is a fully-featured programming language and can be used in other contexts as well.

The inventor of Node.js discovered that its I/O handling capabilities (or lack of them, actually), and some of its other characteristics, made it ideal for writing an environment capable of asynchronous, event-driven I/O.

Event Driven Architecture

Event driven architecture is a way of orchestrating the way software components interact with each other and their environment.

In a conventional, non-event-driven approach, if you want one action to cause another action, you usually would have to write an explicit connection between those two actions. This had to be done inside the causal agent.

That is: if I want A to trigger B, I have to add some code to A.

Event-driven architecture abstracts this to an environment that contains triggers and listeners. You can add event triggers to any action (even if you don’t know yet that it will be meaningful later) and add listeners to components (even if there is nothing yet to trigger them). Listeners wait for triggers, and launch some action when a trigger happens.

Event-driven programming is typically used in user-interface situations: the system listens for events such as mouse-clicks or key strokes. JavaScript already had easy support for event-driven architecture because of its in-browser event-listening usage.

Node.js took advantage of this built-in characteristic to create an event-driven development framework for creating applications.

Non-blocking I/O and Single Threading

In Node.JS, I/O operations don’t block other I/O operations, allowing multiple connections to be made simultaneously without disrupting each other. All connections operate in a single thread, so there is no performance drag from context-shifting between multiple concurrent processes.

Because of these characteristics, Node.js is highly useful for real-time, highly concurrent applications, such as gaming.

Reasons to use Node.js

Everyone can write JavaScript

Okay, maybe not everyone, but every web developer has written JavaScript, at least once or twice. The talent pool for decent JavaScript developers is very large.

It is very fast

Under the hood, Node.js uses the V8 JavaScript engine developed by Google (and those people care about speed). V8 was designed to run JavaScript as fast as possible; it compiles JS directly to machine code.

Node Package Manager

Plugins are great. Libraries are great. You know what isn’t great? Installing things. Also, dependency management. The Node.js Package Manager (npm) solves those problems by creating a rich, easy-to-use installation and deployment ecosystem. Each project can use specific versions of packages, without creating conflict with other applications that might need a different version. It handles installation, updating, and dependencies.

Full stack, one language

Typically, you write client side code in JavaScript, server-side code in something like PHP or Ruby, and then you have to know SQL to deal with the database. With Node.js and the advent of JSON-based document-oriented databases like MongoDB, you can write the entire application “â€? from client to server to database “â€? in JavaScript.

Real time computing

The event loop and its support for multiple, concurrent connections makes Node.js perfect for real-time interaction between multiple clients. This makes it a good choice for applications like gaming, chat, and command-and-control.

Reasons not to use Node.js

Node.js is not a “cure-all”Â? development framework. There are certainly some applications where it isn’t the best option.

Heavy data computation and processing

Node.js is really fast at handling I/O, but it only does one thing at a time. Throwing output at various connections and taking in requests is relatively fast, and the event loop lets Node.js switch between them much faster than if they were separate processes. So the speed is gained by never trying to do two things at once.

The problem with that is that if any single thing does take a long time, everything else has to wait. So doing computational heavy-lifting isn’t a great idea. (Although “â€? this could be handled by outsourcing the computation to another process or machine, turning it into an asynchronous I/O operation.)

Relational Database Application

Unlike Ruby on Rails and several PHP frameworks (Laravel, CodeIgniter, Symfony), Node.js does not have fully mature support (yet) for relational database (SQL) interaction. You can do it, but it’s easier in other environments. (Also, there isn’t much to be gained by using the Node.js concurrency model in a transactional database setting.)

Node.js Hosting

Node.js is still relatively new, so most web hosts don’t support it yet. On the other hand, it’s also very trendy, so there are a number of specialized web hosting providers that are well-optimized for Node.js applications. Be sure to compare hosting options in detail before committing to one.