@me&java&life

I feel butterfly in my stomach everytime I try new technology or language, it’s like love at first sight and I had this kind of feeling last night when I decided to learn more about node.js. I’ve always been fascinated with cross languages and their boundaries and how different programming language works together running on different level, this is the same reason why I venture into the world of Java 9 years ago. I’ve been meaning to learn more about Google v8 Javascript engine as I’m interested how this will be useful in times to come for me and for the greater good.

While reading through v8 information on it’s website I start thinking of looking around for samples that will show the power of v8 on all different aspects and I managed to find a very interesting framework caled node.js. At first I thought that this might be just another Javascript framework but boy I was wrong!. Apparently it’s a whole lot more of a framework, it really dig deep into v8. node.js really shows you how to really integrate with v8 inside and outside and this was perfect for me as I could learn more that I was hoping for, it was a dream come true, let’s move on.

Following are the steps that I did to venture into this new journey.

1. First I checked out v8 source code from their source code repository and start building it. I followed the instruction as per what is written in the following link http://code.google.com/apis/v8/build.html. My home dev machine is Ubuntu 10.04 so it was straight steps to follow from that website

2. After building v8 I started looking node.js website http://nodejs.org/ and check out their source code as well. The node.js source code includes the v8 source so my setup look as below

3. Now I need to build node.js. Now, node.js is not only a bunch of .js files that you can use straight away into your Javascript code it is a combination of .js, .cc and .h files, what this means is it is basically an application that ‘hooks’ into the v8 engine to run it’s internal Javascript code and you can ‘hook’ into, if you are confused don’t worry you can read up on node.js website and you will understand what I mean. So what I need to do now is build node.js which is a straight forward process and it’s outlined in their wiki page https://github.com/joyent/node/wiki/Installation. For me basically I just need to run the following command

cd /home/nanik/v8
export JOBS=2 # optional, sets number of parallel commands.
mkdir ~/local
./configure --prefix=$HOME/local/node
make
make install
export PATH=$HOME/local/node/bin:$PATH

After running the above command I can run the application from anywhere as it’s include in my local environment

4. Now that I have node.js installed I need to run a sample application to use it so that I can walk through the code into node.js and into v8 to understand how the whole thing glue together, for this I pick up a simple application that you can find in node.js website, the code is as follows

var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen(1337, "127.0.0.1");
console.log('Server running at http://127.0.0.1:1337/');

so now I run node.js using the above sample as shown on the screenshot below

ignore the other messages that are shown on the console as those are the log messages I put inside the node.js code to understand the flow, what you should be getting is the message that is surrounded by the blue line. This particular sample code is running as a server that uses port 1337 and ready to accept incoming request. The response that will be send back will be a string ‘Hello, World’ as you can see below

5. After successfully run the code I was very curious to understand how the whole thing works, so following is breakdown of my finding. The explanation below is a walkthrough the executing path of running the server sample code

a. The node.js life starts from the source file node_main.cc which will bootstrap node.js itself and also v8 engine. The calling of v8 engine code resides inside node.cc file :

		    int Start(int argc, char *argv[]) {

		      v8::V8::Initialize();
		      v8::HandleScope handle_scope;

		      argv = Init(argc, argv);

                      ....
                      ....
                      ....

		    }

b. After v8 is successfully initialize the engine will start executing the server sample code and this is where things get interesting (I’m not going to go through the Javascript syntax or flow).

c. The code http.createServer ( .. ) is calling the js function inside the http.js which is located inside the /lib directory of node.js source code. The http.js source is using net.js code extensively which takes care of the socket housekeeping. The crux of the socket housekeeping code is inside the .cc code (C++ code) which is called by the node.js Javascript code which is possible because v8 allows us to do this.

d. For our sample the main function that we are interested in is the Server function which is shown below

		function Server(/* [ options, ] listener */) {
		  if (!(this instanceof Server)) return new Server(arguments[0], arguments[1]);
		  events.EventEmitter.call(this);
		  var self = this;

                      ....
                      ....

		  self.allowHalfOpen = options.allowHalfOpen || false;

		  self.watcher = new IOWatcher();                                      (*)
		  console.log('setting wathcer....');
		  self.watcher.host = self;
		  self.watcher.callback = function( val,val2,val3,val4) {	       (**) this code is the code that I modify from the original source code to show how parameter is pass back from v8

The Server( ) function is the main function that will create a socket process that will receive connection for the port that we specify which in our example is 1337. This function utilize callback mechanism where this callback will be called from v8 from node.js, the question that come to our mind now is how does the Javascript knows which C++ function to call and how it is called, this is the magic of v8

e. In order to understand this part you need to read and understand the internal working of v8 integration that you can read in here http://code.google.com/apis/v8/embed.html (especially the Templates and Accessors section). The way node.js works it’s magic is by registering the function that it can called from Javascript and mapped it to the C++ function which is shown in the code below

		  void InitNet(Handle<Object> target) {
		    HandleScope scope;

		    NODE_SET_METHOD(target, "write", Write);
		    NODE_SET_METHOD(target, "read", Read);
		    NODE_SET_METHOD(target, "sendto", SendTo);
		    NODE_SET_METHOD(target, "recvfrom", RecvFrom);

                      ....
                      ....

		    NODE_SET_METHOD(target, "connect", Connect);
		    NODE_SET_METHOD(target, "bind", Bind);
		  }

The above code snippet was extracted from node_net.cc, what this means is that when you want to use the function connect automatically v8 will know that it need to call the C++ function called Connect inside this call. The way node.js register this call to v8 is using the following macro

		  NODE_MODULE(node_net, node::InitNet);

which resides in the last line of the node_net.cc

f. To use the function inside node.js Javascript code it define the following variable

		var socket = binding.socket;
		var bind = binding.bind;
		var connect = binding.connect;
		var listen = binding.listen;
		var accept = binding.accept;
		var close = binding.close;
		var shutdown = binding.shutdown;
		var read = binding.read;

which is found inside the net.js, what the code is saying is basically I can use the variable accept to accept the socket connection which is used as follows

		var peerInfo = accept(self.fd);

g. node.js is an evented I/O framework so it uses the libenv framework http://software.schmorp.de/pkg/libev.html. Inside the Javascript Server(..) function you will see the following code

		self.watcher = new IOWatcher();

		self.watcher.callback = function( val,val2,val3,val4) {

The IOWatcher is an internal C++ node.js code that it uses as a timer to interact with the libev framework. In order for the socket connection to start listening the watcher variable will need to be initialize using the set( ) method as shown in the below code

		Server.prototype._startWatcher = function() {
		  this.watcher.set(this.fd, true, false);
		  this.watcher.start();
                      ....

		};

the this.watcher.set( ) function is calling the following C++ function inside the node_io_watcher.cc

		Handle<Value> IOWatcher::Set(const Arguments&amp; args) {
		  HandleScope scope;

		  IOWatcher *io = ObjectWrap::Unwrap<IOWatcher>(args.Holder());

		  if (!args[0]->IsInt32()) {
		    return ThrowException(Exception::TypeError(
			  String::New("First arg should be a file descriptor.")));
		  }

		  ....
		  ....
		}

The function of the IOWatcher::Set(..) code is to obtain the parameter that is being passed along and use it to call the libev function to listen to the connection

h. Remember the callback function inside node.js Javascript code ?

	       self.watcher.callback = function( val,val2,val3) {
		    .....
		    .....
	       }

This callback function will be called from node_io_watcher.cc code when it a client connect to the socket and the code responsible to call the Javascript callback function is as follows

	      void IOWatcher::Callback(EV_P_ ev_io *w, int revents) {
		IOWatcher *io = static_cast<IOWatcher*>(w->data);
		assert(w == &amp;io->watcher_);
		HandleScope scope;

		Local<Value> callback_v = io->handle_->Get(callback_symbol);
		if (!callback_v->IsFunction()) {
		  io->Stop();
		  return;
		}

		Local<Function> callback = Local<Function>::Cast(callback_v);

		TryCatch try_catch;

		Local<Value> argv[3];
		argv[0] = Local<Value>::New(revents &amp; EV_READ ? True() : False());
		argv[1] = Local<Value>::New(revents &amp; EV_WRITE ? True() : False());
		argv[2] = Local<Integer>::New(Integer::New(33));

		callback->Call(io->handle_, 3, argv);

		if (try_catch.HasCaught()) {
		  FatalException(try_catch);
		}
	      }

I’ve modified the code slightly as the callback is expecting 3 parameter pass to it (val1, val2, val3) which is represented by argv[0],argv[1] and argv[3]. In this example if I connect to the server I will see a print out of 33 for val3 as that is what being passed from the C++ code as can be shown below

6. The integration work is bit tedious and error prone I must say if you are not careful but once you understand how to do it you can appreciate the power in terms of what you can develop using v8. Happy v8-ing !

During the early years arriving to Australia I never had thoughts of buying a house or even looking for house but as time passes by and being part of the Australian community you tend to get carried away with the vibe that is happening in the society. One of this vibes is the obsession of Australians to own a house. Owning a house is everbody’s dream and goals in life, why is this ? well, sadly that’s how society measures our individual success. If you don’t have a house indirectly they labelled you as not a successful person on the other hand if you have a house regardless what your profession is they think you are successful. This is the irony of life being smart sometimes does not mean you are rich or you can afford something especially something major such as owning a house.

I compared the situation I’m in and my father’s. He bought his first house in the 80′s and he bought is cash and it was a brand new home and life keeps on going on after that. Never ever he bought something may that be a house, car, etc by taking out finance, he bought everything cash. His principle was if you can afford go for it but if you can’t afford stay put as there must be a reason
why you can’t afford it. Nowadays everywhere you see people have everything from games consoles, latest gadgets, cars, house, etc, even people who earns annually $30,$40 or $50k, all this thanks to the innovation in finance and it’s called DEBT. Without taking debt there is no way in hell people can buy anything, why ? because what people earns and what they spend are totally imbalance. The simple rules of spending is you spend what you earn but societies since the 90′s have been in spending spree, they spend more than they earn.

It is surprising to see how people whose earning is not considered as high earner are willing to buy a house carrying huge debt. Taking into consideration their style of living they won’t be able to survive if something goes wrong with their jobs or if all basic needs prices shoots up. Since the year 2000 house prices have shoot up because of the availability of credits provided by banks, mortgage brokers and other institutions and people have jumped the bandwagon regardless whether they can afford or not. This situation have been seen more obviously the last 3 years where a whoel bunch of new first time buyers with the help of government grants jumped into the housing market carrying with them huge amount of debt. If you asked anybody a simple questions such as “How many
percent of your monthly repayment goes to interest and principal ?” and you will for sure get a blank stare. I’ve seen this before and asked several people the same questions and they haven’t got a clue. Try another question – “How much do you spend every month for cost of living ?” you will get the same blank stare as well or if you do get an answer they will tell you “I don’t save as I put
everything into mortgage and living”, so in other words they have no clue at all!.

Coming back to the principle what you earn is what you spend, if initially you are already spending more than what you are earning how will you be able to repay your mortgage if some of the factors that life depends on changes substantially case in point – unemployment. Take for example interest rates – it have been going up ever since last year and it will keep on going up until the end of the year and most probably next year. Another case in point is cost of living – electricity, water, gas, food, medicine, insurance all these are the bare essentials of life and they have gone up substantially (we are talking in the vicinity of 15-18% annual rise). If your earning is not going up by that much how are you going to survive if you have major debt. Money management discipline is very important before taking any steps in taking debt, if you are able to manevour your lifestyle than you will be ok but if you are a person who hates changes than you are all alone.

Another thing that you have to remember when taking out mortgage is what is the split between interest and principal does your monthly repayments covers, let’s take a simple example:

Loan – $300,000
Mortgage Rates – 7.5% (fixed rate)
Monthly Repayment – $2000
Breakup Percentage – 90% interest and 10% principal ($200 for principal and $1800 for interest)
Year 1 Payment – 12 x $200 = $2400 paid for principal and 12 x $1800 = $21,600

As you can see from the simple calculation your after paying $24,000 for your debt basically you have only paid $2400 off from your principal so by the end of year 1 your debt will be down to $297,600 !. As you can see it’s a looong way before you can even pay down $100,000 off from your initial debt. The question that sometimes people don’t asked is what happen to the $21,600 we are paying every year, well that supposedly will be something you can “hope” to gain from the value of your house. So this means that if your house price is $350,000 you are “hoping” that every year your house price will go up by around 6% so that the interest you pay to the bank you will get it back in terms of your house price appreciation if one day you decided to sell.

If we assume that you have been paying for the last 10years this means that you are hoping house prices will go up by 6% x 10yrs = 60%, so you are “hoping” that your home will be valued at $560,000 or you will be able to sell around that much. If you are able to sell your house by that amount than you will get all your money back but if you don’t than you will lose money. This is taking into consideration that for the last 10 years you are spending any amount of money on renovations or fixing your house.

As you can see taking a debt is not a kid’s game if you are not smart enough in maintaining your household balance sheet than you will experience a stressful and bumpy rides in your life. Make sure if you take debt it’s something you are comfortable carrying with you, don’t take something that you can’t afford no matter how beautiful the house might be.