• a "server-side JavaScript engine"
  
  
• that runs on all major operating systems
  
  
• and excels at asynchronous I/O

• A  web browser
  
  
• A  panacea  (well, almost...)
  
  
• A "toy" that isn't production ready
  
  
• A  fad

• Long-running synchronous processing
  
  
• CPU-intensive operations

• Walmart
• Netflix
• PayPal
• eBay
• Dow Jones
• LinkedIn
• New York Times
• Uber
• airbnb

• 8 MB memory leak per day
  
  
• 1 Node.js process (VM, 3GB RAM)
  
  
• 4 byte memory leak per session disconnect
  

• CommonJS-esque module system
  
  
• Intentionally small set of core modules
  
  
• Empowers "userland" modules
  
  
• Also allows for native "userland" modules
  
  
• Encourages application composition
  

// Import the file system module from Node core
var fs = require('fs');

// Import the "async" module from Node userland
//   (after running `npm install async`)var async = require('async');
// Import a module relative to the current filevar awesomeUtil = require('./util/awesome');

module.exports = function() {  // A utility method or constructor
};

module.exports = {  // An "API" object};

# Install a dependency globally
npm install -g grunt-cli

# Create your new Node module/app's manifest
npm init

# Install a dependency locally, update manifest
npm install --save-dev grunt

# Publish a new module of your own to NPM
npm publish

# Create your new Node module's manifestnpm init
# Code your module up! Tweak manifest as you go# ...
# Share it with the worldnpm publish

• Express
• Flatiron
• Sails
• Koa
• Derby
• Total
• Meteor (sort of)

• commander
• cli
• nopt
• optimist
• minimist
• yargs
• nomnom

• node-webkit (i.e. "node-chromium")
• AppJS

• Grunt
  
• Gulp
• Broccoli
• Jake
• etc.

• Primus
• SockJS
• Socket.IO
• Engine.IO
• faye-websocket
• etc.
  

• Programming in Node is event-driven
  
  
• Event-driven programming is asynchronous
  
  
• The Event Loop manages execution flow

• Does not wait for anything to "finish"
  
  
• Waits for everything to "finish"
  
  
• Umm... WAT?

// app.js
process.on("exit", function() {
  console.log("Exiting... asynchronous flow");
});

process.nextTick(function() {
  console.log("Next tick, asynchronous flow");
});

console.log("Synchronous flow");

# Results
$> node app.js
Synchronous flow
Next tick, asynchronous flow
Exiting... asynchronous flow

• So now we've seen Node's Event Loop.
  
  
• We know it's part of the runtime, not a library,
  which makes it different than Ruby's Event
  Machine and Python's Twisted.
  
  
• But is it truly unique, as claimed earlier?
  Or does this concept sound vaguely familiar
  to anyone?

step1(function (err, value1) {
  step2(value1, function(err, value2) {
    step3(value2, function(err, value3) {
      step4(value3, function(err, value4) {
        // Do something with value4
      });
    });
  });
});

• Don't do anything complex  :)
  
  
• Promises (e.g. Q)
  
  
• Asynchronous workflow libraries (e.g. async)
  
  
• Event emitters  (part of Node core)

Q.fcall(promisedStep1)
  .then(promisedStep2)
  .then(promisedStep3)
  .then(promisedStep4)
  .then(function (value4) {
    // Do something with value4
  })
  .catch(function (error) {
    // Handle any error from all above steps
  });

async.waterfall([
    function (done) {
      done(null, 'X', 'Y');
    },
    function (arg1, arg2, done) {
      // arg1 === 'X', arg2 === 'Y'
      done(null, 'Z');
    }
  ],
  function (err, result) {
    // result === 'Z'
  }
); 

• When discussing the Event Loop, we learned
  that Node follows an event-driven paradigm.
  
  
• As such, it only makes sense that events and
  EventEmitters are offered within Node's
  core modules.

// EventTarget interfaces
document.addEventListener(
  "DOMContentReady", handlerFn, false
);
// jQuery events$(".primary-btn").on("click", handlerFn);
// Unhandled exception handlers (sort of)window.onerror = function(msg, f, l, c, err) {  return true;};

// Global events
process.on("exit", function() {  console.log("Exiting...");});

// Individual objects' eventssocketClient.on("connect", handlerFn);

// Create your own Emitters
function MyClass() {}

require('util').inherits(
  MyClass,
  require('events').EventEmitter
);

var instance = new MyClass();
instance.on("ping", function(e) {
  this.emit("pong");
});
instance.on("pong", function(e) {
  console.log("Ping Pong!");
});
instance.emit("ping");

range.on("preheat", function() {
  pot.on("boil", function() {
    rice.on("cooked", function() {
      dinner.serve(rice);
    });
  });
}); 

• Relying on just the asynchronous  APIs for I/O will
  quickly highlight a potential problem: buffering
  
  
• To counter this potential problem, Node provides
  a battle-tested API for "Streams" to allow for
  streaming partial data
  
  
• The Stream interface provides a few basic methods
  and events (it's an EventEmitter) to use/extend

var http = require('http');
var fs = require('fs');
var path = require('path');

var server = http.createServer(
  function (req, res) {
    var file = path.join(__dirname, 'dat.txt');
    // BUFFERING BUFFERING BUFFERING...
    fs.readFile(file, function (err, data) {
      res.end(data);
    });
  }
);
server.listen(8000);

var http = require('http');
var fs = require('fs');
var path = require('path');

var server = http.createServer(
  function (req, res) {
    var file = path.join(__dirname, 'dat.txt');

    // Open a readable stream... stream bytes!
    var stream = fs.createReadStream(file);
    stream.pipe(res);
  }
);
server.listen(8000);

• Meteor
• Derby
• Flatiron
• Rendr

• Browserify
• webmake
• RequireJS (sort of)

# Installnpm install -g node-inspector

# Runnode-debug -p 8181 app.js