• 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
  
  
• 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 "fs" (file system) module from Node.js core
var fs = require('fs');


// Import the "async" module from Node.js userland
//   (after running `npm install async`)var async = require('async');

// Import a module relative to the app/module you're working onvar awesomeUtil = require('./util/awesome');

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

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

// Contents of "util/awesome.js"module.exports = {
  awesome: function() {
    console.log("AWESOME!");
  }
};

// Contents of "app.js"var awesomeUtil = require("./util/awesome");awesomeUtil.awesome();

# Scaffold your new Node module (mainly "package.json")npm init

# Code your module up! Tweak "package.json" 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 (value1) {
  step2(value1, function(value2) {
    step3(value2, function(value3) {
      step4(value3, function(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
  })
  .done();

async.waterfall([
  function (callback) {
    callback(null, 'one', 'two');
  },
  function (arg1, arg2, callback) {
    callback(null, 'three');
  },
  function (arg1, callback) {
    // arg1 now equals 'three'
    callback(null, 'done');
  }
], function (err, result) {
  // result now equals 'done'    
}); 

• 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$(".priamry-btn").on("click", handlerFn);

// Unhandled exception handlers (sort of)window.onerror = function(msg, file, line, col, err) {  return true;};

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

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

// Create your own Emitters
function MyClass() {}
var util = require('util');var EventEmitter = require('events').EventEmitter;util.inherits(MyClass, EventEmitter);

var instance = new MyClass();instance.on("ping", function(e) {  instance.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, 'data.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, 'data.txt');

    // Open a readable stream
    var stream = fs.createReadStream(file);

    // Stream chunks of bytes as they come
    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