for(var i = 0; i < maxLineNumber; i++) {
	DoSomething(fileName,i);
}

var lineReader = require('line-reader');
var async = require('async');
//...
lineReader.eachLine(fileName, function(line,last,next) {
  loaderQ.push({data: line});
  next();
});

var loaderQ = async.queue(function (data,next)
{
  StoreDataInDB(data,next)
}, queueConcurrency);

var restify = require('restify');

function OnTest(req, res, next) {
  res.json({status: 'ok', name: req.params.name});
}

var server = restify.createServer();
server.get('/test/:name',OnTest);

server.listen(13000);

var Hapi = require('hapi');
var apiConfig = 
{
  handler: function (request) {
    request.reply({status: 'ok', name: req.params.name});
  },
  validate: { 
    payload: {
      userdata: Hapi.Types.String().required()
    }
  }
};
var apiServer = Hapi.createServer(port);
apiServer.route({
  method: 'POST',
  path: '/test/data',
  config: apiConfig
});
apiServer.start();

var Hook = require('hook.io').Hook;

var hook = new Hook({name:'MyHookService1'});

hook.on('hook::ready', function (data) {
  console.log('MyHookService1 started');
});

hook.on('*::DoStuff', function(data,callback){
  console.log('event=%s => data=%s',this.event,data);
  callback(null,'ok');
});

hook.start();

var Hook = require('hook.io').Hook;

var hook = new Hook({name:'MyHookService2'});

hook.on('hook::ready', function (data) {
  hook.emit('DoStuff','data to process',
    function(error,result){
    console.log(result);
  });
});

hook.start();

var dnode = require('dnode');

var server = dnode(function (remote, conn) {
    this.DoStuff = function (data, callback) { 
      console.log('data=%s',data);
      callback('ok'); 
    };
});
server.listen(13000);

var dnode = require('dnode');

dnode.connect(13000, function (remote, conn) {
    remote.DoStuff('data to process', 
      function (result) {
          console.log(result);
          conn.end();
    });
});

var zmq = require('zmq');

var sock = zmq.socket('req');
sock.connect('tcp://127.0.0.1:13000');

var msgId = 1;
setInterval(function(){
  sock.send('msg#' + msgId++);
}, 500);

socket.on('message', function(rep) {
  console.log('reply => ' + rep);
});

var zmq = require('zmq');

var sock = zmq.socket('rep');
sock.bindSync('tcp://127.0.0.1:13000');

sock.on('message', function(msg){
  sock.send('rep: ' + msg);
});

var zmq = require('zmq');

var sock = zmq.socket('pub');
sock.bindSync('tcp://127.0.0.1:13000');

var msgId = 1;
setInterval(function(){
  sock.send('msg#' + msgId++);
  sock.send('other#' + msgId++);
}, 500);

var zmq = require('zmq');

var sock = zmq.socket('sub');
sock.connect('tcp://127.0.0.1:13000');
sock.subscribe('msg');

sock.on('message', function(msg){
  //will not see messages prefixed with 'other'
  console.log(msg.toString());
});

var zmq = require('zmq');

var sock = zmq.socket('push');
sock.bindSync('tcp://127.0.0.1:13000');

var msgId = 1;
setInterval(function(){
  sock.send('msg#' + msgId++);
}, 500);

var zmq = require('zmq');

var sock = zmq.socket('pull');
sock.connect('tcp://127.0.0.1:13000');

sock.on('message', function(msg){
  console.log(msg);
});

package feeds;
message Feed 
{
  optional string title = 1;
  message Entry {
    optional string title = 1;
  }
  repeated Entry entry = 2;
}

var fs = require('fs');
var msgpack = require('msgpack');
var Schema = require('protobuf').Schema;
var schema = new Schema(fs.readFileSync('feeds.desc'));
var Feed = schema['feeds.Feed'];
var o = {title: 'something'};

//Protobufs:
var pbSo = Feed.serialize(o);
var pbDo = Feed.parse(pbSo);

//MsgPack:
var mpSo = msgpack.pack(o);
var mpDo = msgpack.unpack(mpSo);

//JSON:
var jsSo = JSON.stringify(o);
var jsDo = JSON.parse(jsSo);

var Producer = require('Prozess').Producer;
var producer = new Producer('demotopic', {host :'kafkaBrokerServer'});
producer.connect();

producer.on('error', function(err){console.log("Error: ", err);});
producer.on('brokerReconnectError', function(err){
  console.log("could not reconnect: ", err);   
});

var msgId = 1;
setInterval(function(){
  producer.send(JSON.stringify({"id": msgId++}), function(err){
    if (err){ console.log("[%d] send error: ", msgId,err);} 
    else { console.log("[%d] sent",msgId); }
  });
}, 1000);

var Consumer = require('Prozess').Consumer;
var consumer = new Consumer({
  host : 'kafkaBrokerServer', topic : 'demotopic', 
  partition : 0, offset : 0});

consumer.connect(function(err){
  if (err){ throw "Kafka connection failure";}
  console.log("consuming: " + consumer.topic);

  setInterval(function(){
    consumer.consume(function(err, messages){
      if(err) {console.log('Error => %j',err);}
      else {
        messages.forEach(function(m){
          //m: bytesLengthVal,magic,compression,checksum,payload
          console.log(m.payload.toString('utf-8'));
        });
      }
    });
  }, 3000);
});

var Storm = require('./storm.js');
var util = require('util');

function TestSpout() 
{
  Storm.Spout.call(this);
  var self = this;
  self.on('ack',function(id){});
  self.on('fail',function(id){});

  self.on('next',function(done){
    var sentences = 
        ["the cow jumped over the moon",
            "an apple a day keeps the doctor away",
            "four score and seven years ago",
            "snow white and the seven dwarfs",
            "i am at two with nature"];      
  self.stormEmit([sentences[Math.floor(Math.random() * sentences.length)]]);
  done();
  });
}
util.inherits(TestSpout, Storm.Spout);

var test = new TestSpout();
test.run();

var Storm = require('./storm.js');
var util = require('util');

function TestBolt() 
{
  Storm.Bolt.call(this);
  var self = this;

  self.on('tuple',data,function(done){
    var words = data.tuple[0].split(" ");
  
  words.forEach(function(word,idx,all){
    self.stormEmit([word],self);
    if((all.length - 1) == idx) {
      done(); //'acks' this tuple
    }
  });
  });
}
util.inherits(TestBolt, Storm.Bolt);

var test = new TestBolt();
test.run();

public static class TestSpout extends ShellSpout implements IRichSpout {
    public TestSpout() {
        super("node", "storm-spout.js");
    }
    
    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("line"));
    }
    
    @Override
    public Map getComponentConfiguration() {
        return null;
    }
}

public static class TestBolt extends ShellBolt implements IRichBolt {
    public TestBolt() {
        super("node", "storm-bolt.js");
    }

    @Override
    public void declareOutputFields(OutputFieldsDeclarer declarer) {
        declarer.declare(new Fields("word"));
    }

    @Override
    public Map getComponentConfiguration() {
        return null;
    }
}

TopologyBuilder builder = new TopologyBuilder();
builder.setSpout("spout", new TestSpout(), 5);

builder.setBolt("split", new TestBolt(), 8)
         .shuffleGrouping("spout");

builder.setBolt("count", new WordCount(), 12)
         .fieldsGrouping("split", new Fields("word"));

SpoutConfig spoutConfig = new SpoutConfig(
    SpoutConfig.fromHostStrings(
        //Kafka brokers
        ImmutableList.of("kafkaBrokerHost1", "kafkaBrokerHost2"),
        8), //Number of Kafka partitions
        "sentences", //Kafka topic to read
        "/kafkastorm", //Zookeeper root path to store consumer offsets
        "wordcounter"); // an id for this consumer (group)

TopologyBuilder builder = new TopologyBuilder();
builder.setSpout("spout", new KafkaSpout(spoutConfig));