A Detailed Introduction to Node.js

Aaron Wang 2013/3/30

My purpose is bring things up so you can dig into if you are intrested

Agenda

• Think Node.js in the Perspective of Back-end Engineers
• Think Node.js in the Perspective of Front-end Engineers
• The Disadvantages and Solutions
• JavaScript Everywhere!
• Summary

Think Node.js in the Perspective of Back-end Engineers

• Concurrency Model of Net Servers
• High Concurrency of Net Servers
• High Performance
• Inner Structure and Running Process of Node.js

Concurrency Model of Net Servers

Two facts

• I/O is slow! Numbers Every Programmer Should Know By Year
  

  And one of a net server's main job is: dealing with I/O

• Context Switch is expensive!

The most primitive net server, iterative server with blocking I/O

• var socket = new Socket();
  socket.bind(80);
  socket.listen();
  while (true) {
      var client = socket.accept();   // blocking
      ...
      queryDB();                      // blocking
      ...
  }

• One client a time, no concurrency, barely used!

The most popular model, multiple processes/threads with blocking I/O

• var socket = new Socket();
  socket.bind(80);
  socket.listen();
  while (true) {
      var client = socket.accept();   // blocking
      fork();
      ...
      queryDB();                      // blocking
      ...
  }

• One process/thread per client
• Improved version: pre-fork, processes/threads pool, like Apache + PHP, IIS + APS.NET
• This model has some down-slides

• 
• One process/thread consumes a lot memory, but most of the time, they are just waiting!
• Context Switch and lock wast a lot CPU!
• In addition for multi-threaded: dead lock, race condition... complicated!
• There are several less popular but more efficient models out there...

Event-driven, single-threaded, and non-blocking I/O

• var socket = new Socket();
  socket.bind(80);
  socket.listen(function (client) {   // Non-blocking
      ...
      queryDB(function () {           // Non-blocking
          ...
      }):
  });

• This is good!

• Consume much lesser memory!
• No massive Context Switch, lock, 100% CPU utilization!
• Asynchronization makes CPU and I/O go in parallel, makes better use of hardware, increase throughput
• Single thread, sequential, simple!
• This is based on an event loop, and all clients are handled in one single thread with non-blocking I/O, very suitable for I/O intensive application
• Event loop? GUI application UI thread: WinForm/WPF/Android...
• Nginx, HAProxy, Netty... and Node.js

Multiple threaded with non-blocking I/O

one more model: lightweight/micro process/thread, coroutine(协程), fiber(纤程)...

• A means of creating code blocks that can be paused and resumed, much like threads.
• Computer multitasking: preemptive VS cooperative
• Native supported by Lua, ruby
• Supported by 3-party libraries in python(greenlet, stackless), Node.js(Fiber)
• Erlang, go, more advanced
• There still is Context Switch, but it's in user-level, much cheaper than system-level
• Evolution direction: multiple processes/threads => event-driven => coroutine?

High Concurrency of Net Servers

• 10K => 1000K
• HTML5 WebSocket, HTTP2.0
• Real Time Applications?
• long connections
• One process/thread per client doesn't fit in
• ASP.NET can handle this situation with IAsyncHttpHandler + Asynchronous I/O(still based on thread poll), also c/c++, Erlang with their own ways
• But we choose Node.js, why?

A compare from 朋友网

A compare from 朋友网

A compare from 朋友网

A compare from 朋友网

Speak with test data: 推送宝A2DM

High Performance

• V8 is fast, faster than python/ruby/php
• c++ extension

Inner Structure and Running Process

Inner Structure

Event loop?

• while there are still events to process:
      e = get the next event
      if there is a callback associated with e:
      call the callback
  

Asynchronous I/O?

• *unix
  • sockets: I/O multiplexing, epoll, kqueue
  • regular files: threads
• windows
  • IOCP, kernel thread pool

Running process

• Node.js is single-threaded in JavaScript level, but under the hood is a different world
• 
• Node.js keeps a single thread for your code
• Everything runs in parallel except your code

Think Node.js in the Perspective of Front-end Engineers

• Full Stack JavaScript
• Web Developing Revolution

Full Stack JavaScript

One language to rule them all

What's a stack?

• User interface
• Business logic
• Data store

Impedance mismatch

• User interface <-> Business logic
• Business logic <-> Data store

ASP.NET

• Javascript <-> c#
• c# <-> sql

J2EE

• Javascript <-> java
• java <-> sql

PHP

• Javascript <-> php
• php <-> sql

You may have get used to it, but does it have to be this way?

Now you have a better choice:

• JavaScript <-> JSON <-> JavaScript
• User interface: JavaScript
• Business logic: Node.js
• Data store: MongoDB, CouchDB, RavenDB...
• Even search engine: Apache Solr, ElasticSearch...

Benefits

• Monoglot programming
• It's enough!!!

Web Developing Revolution

• SPA is getting popular
• New way to write css: less, stylus...
• New way to write javascript: backbone.js, knockout.js, angular.js, Ember.js...

Meteor - A better way to build apps

• Clean, powerful data synchronization
  Write your client code as if it were running on the server and had direct access to the database. No more loading your data from REST endpoints.
• Live page updates
  Just write your templates. They automatically update when data in the database changes. No more boilerplate redraw code to write.
• Sensitive code runs in a privileged environment
• Based on Node.js and MongoDB.

Why So Popular On Earth?

• Back to the beginning
• Reinvent the Wheel?
• It Put Cool Things Together!

Back to the Beginning

• Ryan Dahl, wants a completely asynchronous net server
• Ruby VM was slow...
• C/C++ is too complicated
• Lua is perfect except it has existed synchronous I/O libraries
• Here JavaScript comes:
  • natural single-threaded/event-driven model, asynchronization
  • almost blank area on the server side, so no issues of breaking old habits

Reinvent the Wheel?

• Is server side JavaScript new?
  • Rhino - Java
  • IronJS - .Net
  • Javascript.NET - V8 - .Net
• Is event-driven programming new?
  • EventMachine - ruby
  • Twisted - python
  • libevent - c

It Put Cool Things Together!

The Disadvantages and Solutions

• Multi-cores, Parallelism?
• Computation Intensive Task?
• JavaScript Is Not Perfect!
• Callback Hell and Asynchronous Programming Patterns
• How to Debug and Handle Exception
• Pitfalls

Multi-cores, Parallelism?

• Share socket: official Cluster module
• Multiple processes listen on different ports

Computation Intensive Task?

• One long computation will block all other requests
• Don't do computation intensive task in your web server
• setTimeout(function () {}, 0) ===> process.nextTick(function () {})
• edge.js
• Write c++ extension

JavaScript Is Not Perfect!

• Compile-to-JavaScript languages:

  • GWT
  • CoffeeScript
  • TypeScript
  • ClojureScript
  • More: http://altjs.org/#altjs

• Alternatives:

  • Google Dart

Callback Hell and Asynchronous Programming Patterns

• 
• Continuation Passing Style

Problems:

• Doing things in sequence is hard
• Doning thisng in parallel is harder
• 
• Error handling is a disaster

Use named function

Wind.js - 赵劼(Jeffrey Zhao)

• 
• Much better!
• Like c# 5.0 async/await keywords, syntax sugar powered by compile tech

Promise and Deferred

• Un-inverts the chain of responsibility: instead of calling a passed callback, return a promise
• jQuery 1.5+, $.ajax, $.get, and $.post

  var fetchingData = $.get(url);
  fetchingData.done(doneCallback);
  fetchingData.fail(faildCallback);
  

• var aDreamDeferred = new $.Deferred();
  aDreamDeferred.done(function(subject) {
      console.log('I had the wonderful dream about', subject);
  });
  aDreamDeferred.resolve('the JS event model');
  

• A Deferred is a Promise! More precisely, it’s a superset of Promise with one critical addition: you can trigger a Deferred directly.
• CommonJS Promises/A spec
• Q.js, Futures
• 

Coroutines

• node-fibers
• ECMAScript6(harmony):generators
• 

Has to be so complicated?

• async.js, the most popular control flow helper in node.js community
• 
• What would you do to implement this functionality?
• No additional concepts, it just works!
• Different approaches with differnt abstractions, choose what you prefer

How to Handle Exception

• You can not try catch async handlers

  try {
      setTimeout(function () {
          throw new Error('You can not catch me!!!');
      }, 1000);
  } catch (ex) {
      console.log(ex);
  }

• Manully handle, carefully
• With helpers mentioned before
• Official Domain module
• process.on('uncaughtException', function (ex) { console.log(ex); });

How to Debug

• Debug is important and debug is an art
• node --debug option
• webkit-dev-tools with node-inspector
• Logger

Pitfalls

• setTimeout and setInterval

  var start = new Date();
  setTimeout(function(){
      var end = new Date();
      console.log('Time elapsed:', end - start, 'ms');
  }, 500);
  while (new Date() - start < 1000) {};
  

• Implementation by hands is better than third-party modules, in particular scenarios

JavaScript Everywhere

• Browser side
• Server side
• Mobile Platforms: HTML5 APP, Hybrid APP, FirefoxOS
• Game engines: Unity3D, Cocos2D HTML5
• Desktops: Win8, GNOME, ChromeOS, WebOS
• Embeded: MongoDB, CouchBase
• Atwood's Law: any application that can be written in JavaScript, will eventually be written in JavaScript. - Jeff Atwood, the founder of stackoverflow.com
• JavaScript is not a toy language anymore, it's time to take it seriously

Summary

• Node.js is gifted at I/O intensive task
• It also has its downsides and corresponding solutions
• You may don't use it for now, but may need it some day later, better you know than you don't know

References

Thanks!