When You Forward Webpage and Then Go Back Js Executes Again

Introduction

JavaScript'due south rising popularity has brought with it a lot of changes, and the confront of web development today is dramatically different. The things that we can do on the web present with JavaScript running on the server, as well equally in the browser, were difficult to imagine only several years ago, or were encapsulated within sandboxed environments like Wink or Coffee Applets.

Before digging into Node.js solutions, you lot might want to read up on the benefits of using JavaScript beyond the stack which unifies the language and data format (JSON), allowing y'all to optimally reuse programmer resources. Every bit this is more than a do good of JavaScript than Node.js specifically, nosotros won't hash out it much here. Merely it'south a key advantage to incorporating Node in your stack.

Equally Wikipedia states: "Node.js is a packaged compilation of Google'southward V8 JavaScript engine, the libuv platform abstraction layer, and a core library, which is itself primarily written in JavaScript." Beyond that, it'south worth noting that Ryan Dahl, the creator of Node.js, was aiming to create real-time websites with push adequacy, "inspired by applications like Gmail". In Node.js, he gave developers a tool for working in the not-blocking, event-driven I/O paradigm.

Subsequently over 20 years of stateless-web based on the stateless asking-response paradigm, we finally take web applications with existent-time, two-way connections.

In one sentence: Node.js shines in real-time spider web applications employing push technology over websockets. What is so revolutionary about that? Well, subsequently over 20 years of stateless-spider web based on the stateless request-response paradigm, we finally accept web applications with real-time, two-way connections, where both the customer and server can initiate advice, allowing them to commutation data freely. This is in stark contrast to the typical web response prototype, where the customer always initiates communication. Additionally, it'southward all based on the open up web stack (HTML, CSS and JS) running over the standard port 80.

I might argue that we've had this for years in the form of Flash and Java Applets—but in reality, those were but sandboxed environments using the web as a send protocol to be delivered to the client. Plus, they were run in isolation and often operated over not-standard ports, which may take required extra permissions and such.

With all of its advantages, Node.js now plays a disquisitional role in the technology stack of many high-profile companies who depend on its unique benefits. The Node.js Foundation has consolidated all the best thinking around why enterprises should consider Node.js in a brusque presentation that can be found on the Node.js Foundation'southward Case Studies page.

In this Node.js guide, I'll hash out non simply how these advantages are accomplished, only also why you might want to utilize Node.js—and why not—using some of the classic web application models as examples.

How Does It Work?

The master idea of Node.js: use non-blocking, event-driven I/O to remain lightweight and efficient in the confront of data-intensive real-fourth dimension applications that run across distributed devices.

That'southward a mouthful.

What information technology really means is that Node.js is not a silvery-bullet new platform that will boss the web development world. Instead, it's a platform that fills a particular need.

What it really means is that Node.js is not a silver-bullet new platform that will boss the web evolution globe. Instead, it'due south a platform that fills a detail need. And agreement this is absolutely essential. You definitely don't want to utilize Node.js for CPU-intensive operations; in fact, using information technology for heavy computation volition annul nearly all of its advantages. Where Node really shines is in building fast, scalable network applications, as it'south capable of handling a huge number of simultaneous connections with high throughput, which equates to high scalability.

How information technology works under-the-hood is pretty interesting. Compared to traditional web-serving techniques where each connectedness (request) spawns a new thread, taking upwardly organization RAM and eventually maxing-out at the amount of RAM available, Node.js operates on a single-thread, using non-blocking I/O calls, allowing it to support tens of thousands of concurrent connections held in the outcome loop.

A quick adding: assuming that each thread potentially has an accompanying 2 MB of memory with information technology, running on a system with viii GB of RAM puts usa at a theoretical maximum of 4,000 concurrent connections (calculations taken from Michael Abernethy'south article "Just what is Node.js?", published on IBM developerWorks in 2011; unfortunately, the article is not available anymore), plus the cost of context-switching between threads. That'due south the scenario you typically bargain with in traditional spider web-serving techniques. By avoiding all that, Node.js achieves scalability levels of over 1M concurrent connections, and over 600k concurrent websockets connections.

There is, of course, the question of sharing a single thread between all clients requests, and information technology is a potential pitfall of writing Node.js applications. Firstly, heavy computation could choke up Node's unmarried thread and cause issues for all clients (more on this later) as incoming requests would be blocked until said ciphering was completed. Secondly, developers need to be really careful not to allow an exception bubbles up to the core (topmost) Node.js upshot loop, which will cause the Node.js instance to terminate (finer crashing the program).

The technique used to avert exceptions bubbling upwards to the surface is passing errors back to the caller as callback parameters (instead of throwing them, like in other environments). Fifty-fifty if some unhandled exception manages to bubble up, tools accept been developed to monitor the Node.js process and perform the necessary recovery of a crashed instance (although y'all probably won't be able to recover the electric current state of the user session), the most common being the Forever module, or using a different approach with external organisation tools upstart and monit, or fifty-fifty just upstart.

NPM: The Node Package Manager

When discussing Node.js, one thing that definitely should not be omitted is congenital-in back up for package management using NPM, a tool that comes by default with every Node.js installation. The idea of NPM modules is quite similar to that of Ruby Gems: a set of publicly available, reusable components, bachelor through easy installation via an online repository, with version and dependency management.

A full listing of packaged modules can exist institute on the npm website, or accessed using the npm CLI tool that automatically gets installed with Node.js. The module ecosystem is open to all, and anyone tin publish their ain module that will exist listed in the npm repository.

Some of the most useful npm modules today are:

• express - Limited.js—or simply Limited—a Sinatra-inspired web development framework for Node.js, and the de-facto standard for the majority of Node.js applications out there today.
• hapi - a very modular and unproblematic to apply configuration-centric framework for edifice web and services applications
• connect - Connect is an extensible HTTP server framework for Node.js, providing a collection of high performance "plugins" known equally middleware; serves as a base foundation for Express.
• socket.io and sockjs - Server-side component of the two most common websockets components out in that location today.
• pug (formerly Jade) - One of the pop templating engines, inspired by HAML, a default in Express.js.
• mongodb and mongojs - MongoDB wrappers to provide the API for MongoDB object databases in Node.js.
• redis - Redis client library.
• lodash (underscore, lazy.js) - The JavaScript utility belt. Underscore initiated the game, but got overthrown past one of its two counterparts, mainly due to better performance and modular implementation.
• forever - Probably the most mutual utility for ensuring that a given node script runs continuously. Keeps your Node.js process up in production in the face of any unexpected failures.
• bluebird - A full featured Promises/A+ implementation with exceptionally good performance
• moment - A JavaScript date library for parsing, validating, manipulating, and formatting dates.

The list goes on. There are tons of actually useful packages out in that location, available to all (no offense to those that I've omitted here).

Examples of Where Node.js Should Be Used

CHAT

Chat is the most typical existent-fourth dimension, multi-user awarding. From IRC (back in the day), through many proprietary and open up protocols running on not-standard ports, to the power to implement everything today in Node.js with websockets running over the standard port lxxx.

The chat application is really the sweet-spot case for Node.js: information technology's a lightweight, loftier traffic, data-intensive (but low processing/computation) application that runs across distributed devices. Information technology'south also a great apply-case for learning as well, as it'due south unproblematic, yet it covers nigh of the paradigms you'll ever use in a typical Node.js application.

Permit'due south effort to depict how it works.

In the simplest example, we have a unmarried chatroom on our website where people come and tin can exchange messages in one-to-many (actually all) fashion. For instance, say nosotros accept iii people on the website all connected to our message lath.

On the server-side, nosotros have a simple Express.js application which implements ii things:

1. A GET / asking handler which serves the webpage containing both a message lath and a 'Send' button to initialize new message input, and
2. A websockets server that listens for new letters emitted by websocket clients.

On the client-side, we have an HTML folio with a couple of handlers ready upwards, i for the 'Send' button click result, which picks upwards the input message and sends information technology downwards the websocket, and another that listens for new incoming messages on the websockets client (i.due east., messages sent by other users, which the server now wants the client to display).

When ane of the clients posts a message, hither'south what happens:

1. Browser catches the 'Send' button click through a JavaScript handler, picks up the value from the input field (i.eastward., the message text), and emits a websocket message using the websocket customer connected to our server (initialized on web folio initialization).
2. Server-side component of the websocket connection receives the bulletin and forwards it to all other continued clients using the broadcast method.
3. All clients receive the new bulletin as a push bulletin via a websockets client-side component running within the web page. They then pick up the bulletin content and update the web page in-identify by appending the new bulletin to the board.

This is the simplest example. For a more than robust solution, you lot might use a simple cache based on the Redis store. Or in an even more advanced solution, a bulletin queue to handle the routing of letters to clients and a more robust delivery mechanism which may cover for temporary connection losses or storing messages for registered clients while they're offline. But regardless of the improvements that you brand, Node.js will yet be operating under the aforementioned basic principles: reacting to events, handling many concurrent connections, and maintaining fluidity in the user feel.

API ON TOP OF AN OBJECT DB

Although Node.js really shines with real-time applications, it's quite a natural fit for exposing the data from object DBs (e.g. MongoDB). JSON stored information allow Node.js to role without the impedance mismatch and data conversion.

For instance, if you're using Rails, you would catechumen from JSON to binary models, and then expose them back as JSON over the HTTP when the data is consumed by Backbone.js, Athwart.js, etc., or even plain jQuery AJAX calls. With Node.js, you can simply expose your JSON objects with a REST API for the client to consume. Additionally, you don't need to worry most converting between JSON and whatever else when reading or writing from your database (if you're using MongoDB). In sum, you can avoid the demand for multiple conversions by using a uniform information serialization format across the customer, server, and database.

QUEUED INPUTS

If you're receiving a high amount of concurrent data, your database tin can become a bottleneck. As depicted higher up, Node.js can easily handle the concurrent connections themselves. Just considering database admission is a blocking functioning (in this case), we come across trouble. The solution is to admit the client's behavior earlier the data is truly written to the database.

With that arroyo, the system maintains its responsiveness nether a heavy load, which is specially useful when the customer doesn't demand firm confirmation of a the successful data write. Typical examples include: the logging or writing of user-tracking data, processed in batches and non used until a later fourth dimension; as well as operations that don't need to exist reflected instantly (like updating a 'Likes' count on Facebook) where eventual consistency (so often used in NoSQL world) is acceptable.

Data gets queued through some kind of caching or message queuing infrastructure—similar RabbitMQ or ZeroMQ—and digested by a separate database batch-write process, or ciphering intensive processing backend services, written in a better performing platform for such tasks. Similar behavior can be implemented with other languages/frameworks, but not on the same hardware, with the same high, maintained throughput.

In brusk: with Node, you can push the database writes off to the side and deal with them subsequently, proceeding as if they succeeded.

DATA STREAMING

In more traditional web platforms, HTTP requests and responses are treated like isolated event; in fact, they're actually streams. This observation can be utilized in Node.js to build some absurd features. For example, it's possible to process files while they're still beingness uploaded, as the information comes in through a stream and we can procedure information technology in an online mode. This could be washed for existent-time audio or video encoding, and proxying between different information sources (see next section).

PROXY

Node.js is hands employed as a server-side proxy where it can handle a big amount of simultaneous connections in a not-blocking fashion. It's especially useful for proxying different services with unlike response times, or collecting data from multiple source points.

An example: consider a server-side awarding communicating with third-political party resources, pulling in data from different sources, or storing assets similar images and videos to third-political party cloud services.

Although dedicated proxy servers practice exist, using Node instead might be helpful if your proxying infrastructure is non-real or if you demand a solution for local development. Past this, I mean that y'all could build a client-side app with a Node.js development server for assets and proxying/stubbing API requests, while in production you'd handle such interactions with a dedicated proxy service (nginx, HAProxy, etc.).

BROKERAGE - STOCK TRADER'Southward DASHBOARD

Let'southward get dorsum to the application level. Another case where desktop software dominates, but could be easily replaced with a real-time web solution is brokers' trading software, used to track stocks prices, perform calculations/technical analysis, and create graphs/charts.

Switching to a real-fourth dimension spider web-based solution would let brokers to easily switch workstations or working places. Presently, we might start seeing them on the embankment in Florida.. or Ibiza.. or Bali.

Application MONITORING DASHBOARD

Another common use-instance in which Node-with-web-sockets fits perfectly: tracking website visitors and visualizing their interactions in real-time.

Y'all could exist gathering real-time stats from your user, or fifty-fifty moving it to the next level by introducing targeted interactions with your visitors past opening a communication channel when they reach a specific point in your funnel. (If you're interested, this idea is already being productized by CANDDi.)

Imagine how you could improve your business if you knew what your visitors were doing in existent-time—if you could visualize their interactions. With the real-fourth dimension, two-mode sockets of Node.js, at present yous tin.

SYSTEM MONITORING DASHBOARD

Now, let's visit the infrastructure side of things. Imagine, for example, an SaaS provider that wants to offering its users a service-monitoring page, like GitHub's status page. With the Node.js event-loop, we can create a powerful web-based dashboard that checks the services' statuses in an asynchronous manner and pushes data to clients using websockets.

Both internal (intra-visitor) and public services' statuses tin exist reported alive and in real-time using this engineering science. Button that idea a picayune farther and endeavor to imagine a Network Operations Eye (NOC) monitoring applications in a telecommunications operator, deject/network/hosting provider, or some financial institution, all run on the open up web stack backed by Node.js and websockets instead of Coffee and/or Java Applets.

Note: Don't endeavor to build hard real-time systems in Node (i.e., systems requiring consistent response times). Erlang is probably a meliorate choice for that course of awarding.

Where Node.js Can Be Used

SERVER-SIDE Spider web APPLICATIONS

Node.js with Limited.js can also be used to create classic web applications on the server-side. Yet, while possible, this request-response paradigm in which Node.js would be conveying around rendered HTML is not the most typical utilize-case. There are arguments to be made for and against this approach. Here are some facts to consider:

Pros:

• If your awarding doesn't have any CPU intensive ciphering, yous can build information technology in Javascript top-to-bottom, fifty-fifty downwards to the database level if you lot utilize JSON storage Object DB similar MongoDB. This eases development (including hiring) significantly.
• Crawlers receive a fully-rendered HTML response, which is far more than SEO-friendly than, say, a Single Page Application or a websockets app run on meridian of Node.js.

Cons:

• Any CPU intensive computation will block Node.js responsiveness, and then a threaded platform is a better arroyo. Alternatively, you could attempt scaling out the ciphering [*].
• Using Node.js with a relational database is nonetheless quite a pain (see below for more detail). Do yourself a favour and choice up any other environment like Rails, Django, or ASP.Cyberspace MVC if you're trying to perform relational operations.

[*] An alternative to these CPU intensive computations is to create a highly scalable MQ-backed environment with back-stop processing to proceed Node as a front-facing 'clerk' to handle customer requests asynchronously.

Where Node.js Shouldn't Be Used

SERVER-SIDE WEB APPLICATION West/ A RELATIONAL DB Backside

Comparison Node.js with Limited.js against Cherry-red on Rails, for case, in that location used to be a clean determination in favor of the latter when information technology came to accessing relational databases similar PostgreSQL, MySQL, and Microsoft SQL Server.

Relational DB tools for Node.js were still in their early stages. On the other manus, Rails automatically provides data access setup correct out of the box together with DB schema migrations support tools and other Gems (pun intended). Rails and its peer frameworks accept mature and proven Active Record or Data Mapper data access layer implementations.[*]

But things have changed. Sequelize, TypeORM, and Bookshelf have gone a long mode towards becoming mature ORM solutions. It might also be worth checking out Join Monster if you're looking to generate SQL from GraphQL queries.

[*] Information technology's possible and not uncommon to utilize Node solely equally a front-cease, while keeping your Rails back-cease and its easy-admission to a relational DB.

HEAVY SERVER-SIDE COMPUTATION/PROCESSING

When it comes to heavy computation, Node.js is not the best platform around. No, you definitely don't want to build a Fibonacci computation server in Node.js. In full general, any CPU intensive performance annuls all the throughput benefits Node offers with its event-driven, non-blocking I/O model considering any incoming requests volition be blocked while the thread is occupied with your number-crunching—bold you lot're trying to run your computations in the aforementioned Node instance you're responding to requests with.

As stated previously, Node.js is single-threaded and uses only a unmarried CPU core. When it comes to adding concurrency on a multi-cadre server, at that place is some work being done past the Node core team in the form of a cluster module [ref: http://nodejs.org/api/cluster.html]. Yous tin can also run several Node.js server instances pretty easily behind a contrary proxy via nginx.

With clustering, yous should nevertheless offload all heavy computation to background processes written in a more appropriate environment for that, and having them communicate via a bulletin queue server like RabbitMQ.

Fifty-fifty though your groundwork processing might be run on the same server initially, such an approach has the potential for very high scalability. Those background processing services could be hands distributed out to carve up worker servers without the need to configure the loads of front-facing web servers.

Of course, you'd use the same approach on other platforms too, only with Node.js yous go that high reqs/sec throughput we've talked about, as each request is a modest task handled very chop-chop and efficiently.

Conclusion

We've discussed Node.js from theory to practise, beginning with its goals and ambitions, and ending with its sweet spots and pitfalls. When people run into problems with Node, it almost e'er boils down to the fact that blocking operations are the root of all evil—99% of Node misuses come as a directly consequence.

In Node, blocking operations are the root of all evil—99% of Node misuses come up equally a direct consequence.

Recall: Node.js was never created to solve the compute scaling problem. It was created to solve the I/O scaling trouble, which it does actually well.

Why use Node.js? If your use case does not contain CPU intensive operations nor access any blocking resources, you lot can exploit the benefits of Node.js and enjoy fast and scalable network applications. Welcome to the real-time spider web.

ouresseechivers.blogspot.com

Source: https://www.toptal.com/nodejs/why-the-hell-would-i-use-node-js