degrunt.net

batman.js

Sat, 14 Jan 2012 01:01:00 GMT

Quite some time ago (May 2011), I first heard about batman.js. It's homepage was still a bit empty, but gave a pretty good example of we're the framework was headed. It's written in CoffeeScript and so far it's been pretty amazing. It's concise and once you understand how it works, pretty simple to use. This is also where some of the pain is: the documenation leaves a lot to desire, but the development team's helpfulness more than compensates for it. I'm planning to put some useful snippets on this site as I go about discovering and continue working with batman.js. I'll start off with a small snippet for a Regular Expression Validator I wrote:

Use with:

BitSets and Metrics

Sun, 04 Dec 2011 01:12:00 GMT

After reading an article on Fast, easy, realtime metrics using Redis bitmaps and seeing they used a Java implementation of BitSet, I really wanted a native JavaScript implementation.

Looking at what they did for Java it wasn't too difficult to implement this for JavaScript. The result is up on GitHub.

Some example JavaScript code:

var bs = new BitSet();

for(var n = 0; n < 12; n++) {
  bs.set(n);
}

console.dir(bs);

Ported Aristo to stylus

Thu, 19 May 2011 02:05:00 GMT

Aristo or on github Aristo is a beautiful theme for web applications. I had seen a Compass plugin for it, but I wanted a "native" node.js port.

Stylus seemed like the right tool for the job, so I just did it. The result is called stylus-aristo and available on github.

A small demo can be found here

node.js and zeromq, part 4 (XRequest/XReply)

Fri, 06 May 2011 02:05:00 GMT

Today, after a long wait is part 4 of the node.js and ZeroMQ series. This part is about XRequest and XReply sockets also called XREQ and XREP sockets.

There isn't a lot of documentation about this. As I understand it, these socket types allow you to asynchronously implement the request response pattern. Pretty much like REQ/REP actually, but I've found XREQ/XREP to be more stable.

Without further ado, here's xrequestxreplyclient.js:

var zeromq = require("zeromq");

var counter = 0;
var socket = zeromq.createSocket('xrequest');
socket.identity = "client";

socket.connect("tcp://127.0.0.1:5502");
console.log("Connected to port 5502!");

setInterval(function(){
  var value = Math.floor(Math.random()*100);
  socket.send('', ''+value);
}, 10);

socket.on('message', function(data) {
  console.log("Answer data: "+data);
  counter += 1;
});

socket.on('error', function(error) {
  console.log("Error: "+error);
});

Here's xrequestxreplyserver.js:

var zeromq = require("zeromq");

var socket = zeromq.createSocket('xreply');
socket.identity = "server";

socket.bind("tcp://127.0.0.1:5502", function(err) {
  if (err) throw err;
  console.log("bound!");

  socket.on('message', function(envelope, blank, data) {
    console.log("Received: "+envelope+" - "+data.toString('utf8'));
    socket.send(envelope, ''+data*2);
  });

  socket.on('error', function(err) {
    console.log("Error: "+err);
  });
});

Here again the server part is actually a value duplication service (times two service).

Moving to static site

Thu, 05 May 2011 02:05:00 GMT

Though Wordpress is a good product, I decided to move away from it for this site. I'm still using it on other sites of mine though. This site is now generated from a series of Markdown files, currently using a product called Jekyll. Currently it provides pretty much the same functionality website wise, ofcourse I now lost the administration interface. The site is content wise complete, though the theme could use a little more.

Using VirtualBox with the command line

Wed, 04 May 2011 02:05:00 GMT

For quite a while now I use VirtualBox as the virtualization software of my choice. I've used others, but the fact that it's free is a big benefit. It's also possible to use VirtualBox from the commandline. Assume that I have a VM called 'ubuntu-server', which uses 'ubuntu' as hostname. To start the VM I do the following:

alias vbm=VBoxManage
vbm startvm --type headless ubuntu-server
ssh ubuntu

To shut the VM down you can do the following:

shutdown -H now
exit
vbm controlvm ubuntu-server poweroff

Note that I've aliased VBoxManage to vbm, so that it's a little easier to use.

Installing nodejs on Ubuntu without compiling

Sat, 16 Apr 2011 02:04:00 GMT

Since I wanted to run a nodejs site on a small Ubuntu machine, without any compile tools installed, I had two options: pre compile it and try to transfer it binary, or see if someone already did this. Browsing for a solution for the latter I came across this launchpad page.

All in all it's as simple as:

sudo add-apt-repository ppa:chris-lea/node.js
sudo apt-get update
sudo aptitude install nodejs

The only thing to note, is that the executable it installs is called nodejs, so I made a softlink as follows:

cd /usr/bin
ln -s nodejs node

All done!

node.js and zeromq, part 3 (Request/Reply)

Tue, 05 Apr 2011 02:04:00 GMT

Today, in part 3 of the series on node.js and zeromq: Request & Reply. This pattern is meant for clients asking multiple requests to (multiple) servers. Contrary to TCP/IP, in zeromq it doesn't matter whether the server or the client does the bind. In the below case, the servers do the connect and the client does the bind. The most stable part of your architecture needs to do the bind.

requestreplyserver.js:

var zeromq = require("zeromq");

// reply = server/service
var socket = zeromq.createSocket('reply');
socket.connect("tcp://127.0.0.1:12345");

socket.on('message', function(data) {
  console.log("Received: "+data.toString('utf8'));
  socket.send(""+2*data);
});

The server in the above example will multiply every received value with two. In real life situations this doesn't make sense, so use this for expensive operations.

requestreplyclient.js:

var zeromq = require("zeromq");

// request = client 
var socket = zeromq.createSocket('request');
socket.bind("tcp://127.0.0.1:12345", function(err) {
  if (err) throw err;
  console.log("bound!");

  setInterval(function() {
    var value = Math.floor(Math.random()*100);
    socket.send(""+value);
    console.log("Asking: "+value);
  }, 100);

  socket.on('message', function(data) {
    console.log("Answer data: "+data);
  });

});

node.js and zeromq, part 2 (Publish/Subscribe)

Mon, 04 Apr 2011 02:04:00 GMT

While I'm at it, evaluating zeromq that is, I might as well publish examples for all usage patterns, so today follows Publish/Subscribe. The pattern is used to distribute data from one publisher to many subscribers. Both sockets are again uni-directional.

publishsubscribeserver.js:

var zeromq = require("zeromq");

// publisher = send only
var socket = zeromq.createSocket('publisher');

var stocks = ["AAPL", "GOOG", "YHOO", "MSFT", "INTC"];

socket.bind("tcp://127.0.0.1:12345", function(err) {
  if (err) throw err;
  console.log("bound!");
  setInterval(function() {
    var symbol = stocks[Math.floor(Math.random()*stocks.length)];
    var value = Math.random()*1000;
    socket.send(symbol+" "+value);
    console.log("Sent: "+symbol+" "+value);
  }, 100);
});

The server sends out messages, for five different stock symbols and their value (all random).

publishsubscribeclient.js:

var zeromq = require("zeromq");

// subscriber = receive only
var socket = zeromq.createSocket('subscriber');
socket.connect("tcp://127.0.0.1:12345");
socket.subscribe("AAPL");
socket.subscribe("GOOG");

console.log("connected!");

socket.on('message', function(data) {
  console.log("received data: " + data.toString('utf8'));
});

The client subscribes only to receive updates for GOOG (Google) and AAPL (Apple) stock. Please note that the data consists of both the stock symbol and the stock value, exactly what was sent.

zeromq.node is available from GitHub

node.js and zeromq (Push/Pull)

Sun, 03 Apr 2011 02:04:00 GMT

While trying to evaluate zeromq and it's use with node.js, I quickly put together the following small experiment, which shows two unidirectional sockets. One is a "server" and can only push (send) messages, the other is a "client", which can only pull (receive) messages:

pipeline_server.js:

var zeromq = require("zeromq");

// push = downsteam = send only
var socket = zeromq.createSocket('push');
socket.bind("tcp://127.0.0.1:12345", function(err) {
  if (err) throw err;
  console.log("bound!");
  setInterval(function() {
    socket.send(new Date().toString());
  }, 500);
});

The server creates the push socket, connects to port 12345 of localhost and sends a message every half a second (containing the current date/time).

pipeline_client.js:

var zeromq = require("zeromq");

// pull = upstream = receive only
var socket = zeromq.createSocket('pull');
socket.connect("tcp://127.0.0.1:12345");
console.log("connected!");

socket.on('message', function(data) {
  console.log("received data: " + data.toString('utf8'));
});

Mind you that these specific socket types are used in the pipeline pattern. The pushing socket will load-balance requests over the pulling sockets. If you start more clients, you'll see that the messages are fairly distributed over all clients.