2012 US Politics

This is a a Saturday night jot, so feel free to skip right on past this.

Now, I’m not American or any of that nonsense, but it seems the 2012 US elections are already heating up, especially with all this talk of SOPA, PIPA etc.

After all the hope (or hype?) that was Obama there are some new contenders for the presidency. Out of all of these, Ron Paul seems to be the only one making any sort of sense (caveat, I may very well be wrong about this, but he actually talks about the bad things the US has done!). Mitt Romney sees to have that strange chiselled jaw only Americans aspire. And Senator Rick Santorum? Well, let’s just say in my own tiny way, I’m doing my bit.

NodeJS: Experiments with Middle End Part 3

In this post, we’re going to make that example slightly more complex by introducing dependencies within the modules. Now the code must be able to handle these dependencies for both the client side and the server side.

In the last post, we built a simple module consisting of a single function that returned a greeting:

var Greetings = function() { }
Greetings.prototype.hello = function(who) {
   return "Hello "+who;
}
module.exports = Greetings;

At this point, it would be very useful to sanitize and validate the parameter passed to the “hello” function. We could obviously build this functionality directly into the code, but this is exactly the sort of thing that should be abstracted into its own module(s).

For the purpose of this example, we’ll simply include the functionality to give the parameter passed a “trim”; after some hacking and snippet-borrowing from node-validator by Chris O’Hara, we can build another simple module called Tidy:

var Tidy = {
   whitespace: '\\r\\n\\t\\s',
 
   trim: function(str) {
      var whitespace =  '\\r\\n\\t\\s';
      str = str.replace(new RegExp('^['+this.whitespace+']+|['+this.whitespace+']+$', 'g'), '')
      return str;
   }
}
module.exports = Tidy;

We can now improve our Greetings module, including the dependency and functionality:

var Tidy = require('./tidy');
 
var Greetings = function() { }
Greetings.prototype.hello = function(who) {
   who = Tidy.trim(who);
   return this.hello(who);
}
module.exports = Greetings;

To see if this will work as expected, let’s add some spaces to the parameter passed in the NodeJS script:

var Greetings = require('./greetings');
var greetings = new Greetings();
console.log(greetings.hello('  Node   ')+"!");

When we run it, this is what we see:

$ node runner.js
Hello Node!

Good, so this works on the server side, but let’s test its behaviour on the client side. Again, we should add some spaces to the parameter passed to ensure that it is working:

<script type="text/javascript"> </script>
<script src="greetings.js" type="text/javascript"> </script>
<script type="text/javascript"> </script>

Unfortunately, we now see the following error:

require is not defined
[Break On This Error] var greetings = new Greetings();

Our attempt to “require” the dependency in the Greetings module has broken the client side. To fix this, we need to define our own require() function, much like we had to for the module object. We do this by creating a new front end-only script, which we’ll call “middle-end.js”.

var require = function(module) {
   document.write('<script src="'+module+'.js" type="text/javascript"> </script>');
}
 
var module = {
   exports: undefined
};

(Obviously we should include much more error checking, but this will be enough for our example).

We modify our html as follows:

<script src="middle-end.js" type="text/javascript"> </script>
<script type="text/javascript"> </script>
....

Now when we reload the page in the browser, all should work as expected. Huzzah!

This is just a very simple example of what can be done when JavaScript code is shared between the client and server sides—the “Middle End”. This concept becomes really exciting when you start thinking about potential approaches to form validation, session management, and even display logic. This is definitely something worth playing around with.

All of the code is available as a Gist.

NodeJS: Experiments with Middle End Part 2

In my previous post, I talked about Kyle Simpson’s concept of a Middle End—a layer between the front end and back end. Today, I’m going to sketch out my very simple experiments with constructing such a layer.

What I am focusing on here is simply a means of sharing JavaScript code between the client side and the server side.

Let’s start with a very simple NodeJS Module, greetings.js:

var Greetings = function() { }
Greetings.prototype.hello = function(who) {
   return "Hello "+who;
}
module.exports = Greetings;

Next, let’s create a very simple NodeJS script that imports this module, and uses it:

var Greetings = require('./greetings');
var greetings = new Greetings();
console.log(greetings.hello('Node')+"!");

When we run it, this is what we get:

$ node test.js
Hello Node!

All very simple stuff.

Now, suppose we want to use the Greetings module in our front end web app. 

<script src="greetings.js" type="text/javascript"> </script>

Well, it runs and we get the desired output. However, Firebug reports an error within the greetings.js file:

module is not defined
[Break On This Error] module.exports = Greetings;

The solution to this issue is to “mock up” the module object so the error isn’t thrown:

var module = {
   exports: undefined
};

Run it again, and now we see no errors.

Great, so it’s working. We can share simple modules between the client and the server sides.

But what if we want to have a more complex module? One that has some dependencies?

That will be discussed in the next post.

All of the code is available as a Gist.

Arch Linux Virtualbox Update

Again, this is one of those posts more for me, but hopefully other people might find it useful.

Recently I updated my Arch Linux box

# pacman -Syu

and during this update a new kernel was added – which meant that my VirtualBox installation didn’t work any more, chucking out the following message

The VirtualBox Linux kernel driver (vboxdrv) is either not loaded or there is a permission problem with /dev/vboxdrv. Re-setup the kernel module by executing

‘/etc/init.d/vboxdrv setup’

NodeJS: Experiments with Middle End Part 1

Back in October last year (2010) a bunch of us fled Berlin and made for Warsaw. Not just for the Vodka you understand, but more specifically for the Front-Trends conference.

One of the talks was discussing the concept of the Middle End, by Kyle Simpson. This really made an impression on me, and I think I probably bored Kyle in the bar afterwards with my drunken enthusing. When we arrived back home, my aim was to start playing around with the idea of a Middle End as soon as possible. Unfortunately, as is life, events took over (such as discovering one is going to become a dad!) and these thoughts were consigned to the back of my mind.

Until now

Read the rest of this entry »

Note to self: Node Deployment

This is really a note to me as since Delicious has “jumped the shark” I don’t really know where else to put it.

I’ve been researching automated deployment of NodeJS applications, and found this excellent blog post to help me out:

Deploying Node.JS Apps, by Ben Gourley.

Plus this question on stack overflow on nginx proxying should help me out.

That’s it. now I just need some time to play around with this stuff!

Also, if anyone knows of a really simple, easy to organize bookmarking site please let me know!

JSConf EU – Day 1

Back home now after a busy day at JSConf EU, brain is pretty melted due to a lot of good talks, so will make this a quick one.

Three things really stood out for me today.

Firstly, Cloud9 IDE. This is a browser based JavaScript IDE, and it looks fantastic. With no setup or configuration needed it lets you just start writing NodeJS directly from your browser. The lovely guys even gave me a premium account free for 1 year! I am going to sign up and start hacking away as soon as I get a chance.

Secondly, even though the Arduino talk was a bit, er, ramshackled, they did talk about the Raspberry Pi. This is a tiny (and I mean tiny) ARM box running Linux. It should be available in November some time, which will be perfect timing for a birthday present to myself!

Finally, Emscripten is very exciting. Emscripten is a compiler that takes bitcode and turns it into JavaScript. From what I understood, this is what made repl.it possible, which I saw yesterday in Hacker News and thought was so cool I bookmarked it!

As there were two tracks I did miss a bunch of talks, but I’m sure they will be availble on the website soon.

All in all, good stuff, tiring (especially as some little madam decided to wake up at 5am) but brain is now firing off with a bunch of possibilities!

JSConf.eu Tomorrow = Huzzah!

This is just a quick post as I’m off to bed for an early night’s sleep. JSConf EU is tomorrow and am one of the lucky few who have in their posession a “golden ticket” to attend. It’s  a jam-packed event starting at an unaturally early 8am! Do they know this is Berlin?! You can’t even buy breakfast at 8am on a Saturday here!

I have high hopes for the conference. Last year I didn’t even attend the main event, just the pre-party on the Friday night and still came away with a load of ideas! One conversation lead me to completely rewrite major parts of the Jabbakam system. Who knows what new thoughts will spark in my head when I actually go to the real thing?

For updates, follow me on Twitter.

NodeJS: Experiments with Processes

I’ve been hacking about with NodeJS a lot recently, and lately my attention has turned towards spawning child processes. Luckily NodeJS makes this very easy to do, and also the documentation is pretty good.

What I have been working on is having a single parent process that runs constantly in the background, and this parent is responsible for child processes which actually do the work. One thing I found particularly interesting was how the parent can handle a child crashing, and also what happens to the children when the parent is killed. Below is the culmination of my hackings, it comprises of two simple scripts, a child script, and a parent. I have committed them to my GitHub account, so feel free to clone, fork, hack or whatever.

Read the rest of this entry »

PHP: It’s not you, it’s me

This is a minor whinge, and I apologise for that. I don’t post for weeks, and when I do: whinge; moan; complain (not that I’d particularly happy about conforming with the whinging pom sterotype).

Anyway. this is about PHP.

Frankly PHP, you’ve served me well. I remember being pried away from Perl when you were only 3. With 4 you had me, and 5 I thought it couldn’t get better. But after 13 years of you being my primary language, I’m sorry to say that I’m going to have to move on.

It’s not you, it’s me.

Yes I know you have some spangly new namespaces and finally ridding yourself of your childish toys, but that’s not enough for me anymore. I’ve been dabbling with other languages. Node, Python, Lisp, Haskell and indeed Lua* and, well, frankly they are more fun. Sure, I’ll visit, especially as Jabbakam, Live Unsigned and Doolali are all mainly written in PHP, but I’m sorry to say, and how do I put this delicately… you’re just not exciting any more.

So, whilst this is not goodbye, it is an auf wiedersehen.

To paraphrase: so long PHP, and thanks for all the fish.

* Footnote: my brand spanking new daughter is called Lua!