Looks like I'll be out in NYC this March for the first time ever and I'm really looking forward to seeing the city. However, I'll be working while I'm out there (at least through the day) so where is the best place to get that done? Some standard options include frequenting cafes but I'd also like to explore options like co-working spaces and any friendly offices that someone has a spare desk at.

I'd also like to meet up with anyone out there who'd be kind enough to show me some of the sights and/or talk about the Web and gaming. I'd also love to use this opportunity to do an evening talk or two if there are any local events happening mid-March. I'm basically open to anything really!

Oh, and where is a good area of the city to stay?

Let me know if you or anyone you know might be able to help me make my stay in NYC a fun one.

What better way to bring in the new year than with a fantastic Rawkes Weekly. It's been a pretty quiet fortnight since the last update, I certainly enjoyed the time off.

Yesterday I took the time to write about 2011 and all the crazy things that happened within it. Needless to say that 2012 is going to be mental if last year was anything to go by!

In other news, GitHub now serve .webapp manifest files with the correct content-type, meaning you can host your Mozilla Labs app or game using GitHub pages! The first game hosted using this method is MarbleSoccer.

Some great news just before the festive break was that Mozilla and Google have renewed their search deal. 2012 is going to be a great year for the Web now that this is out of the way!

And on the open Web game development scene I was interviewed for an article for .net magazine about Mozilla's position on open Web games. It's worth a read.

Links of the week

• node-compute-cluster
  • This Node.js library allows you to distribute computation across multiple processes. I'm fascinated by all the multi-process stuff happening in Node right now.
• 360° MP3 player UI demo: Javascript + Canvas
  • I love this radial visualisation of audio data using HTML5 canvas. It's a shame that the audio data isn't grabbed using HTML5 though, I'd love to see that put into this demo.
• Ender
  • Described as the no-library library, Ender is effectively NPM for front-end JavaScript libraries like jQuery.
• About the @mention constellations
  • An insight into a beautiful data visualisation of 10 minutes of conversation on Twitter. I can't believe how many tweets there are!
• Faster Canvas Pixel Manipulation with Typed Arrays
  • Andrew Baker walks you through how to manipulate pixels in canvas as fast as possible using Typed Arrays.
• Service Discovery Comparison
  • I didn't realise quite how many methods of service discovery were out there. I'm massively interested in mDNS/zeroconf and the possibilities that it brings for open Web games.
• Travis CI
  • I've seen a lot of continuous integration services around lately but the cool kid on the block seems to be Travis CI. I'd love to try out CI myself.
• Dochub
  • Ever wanted instant search on MDN? If so then look no further than Dochub. I'm intrigued to see how this little service progresses.
• Testing with Mocha
  • I'm currently giving test-driven development a try on the re-write of Rawkets. So far I'm really enjoying Mocha as the platform of choice for writing my tests for Node.js and the browser.
• MotionCAPTCHA
  • This is like normal CAPTCHA but instead of typing stuff you draw something. I love the concept but I worry about the accessibility of drawing specific shapes.
• Quake 3 demo with the Mouse Lock API
  • Brandon Jones has updated his Quake 3 WebGL demo with support for the Mouse Lock API. No more sub-par mouse interaction disrupting the experience!

Track of the week

Let The Sunshine by Labrinth. This kind of music isn't usually my cup of tea but I've really grown to like it recently.

This time last year I had enough trouble working out where to start when rounding up 2010. So how on earth am I meant to start the best bits of 2011 when it was easily the most insane year of my life, ever? And how the hell do you follow the Google balls phenomenon?

As always, please excuse the self indulgent nature of this yearly round-up. It is one of the only moment where I can truly reflect on everything that has been achieved in the space of a single, eye-blinkingly-quick year.

Notable events in 2011

In all honesty I can barely remember the first part of 2011 as it was spent mostly with my head down working, writing, and travelling. The second half is still a little blurry as well but I'll try my best to round it all up nicely.

Publishing my first book

Finishing Foundation HTML5 Canvas was massively relieving, particularly because I wrote it while in my final year at university so I was pretty drained when I submitted the final chapter in March. I still can't believe that I actually wrote an entire book by myself, all 75,000+ words and 358 pages of it!

Writing it was really only half the battle, my half of the battle. What really made me happy was seeing the physical book in the hands of other developers, especially the ones who were on the other side of the world and who I didn't know. It's a surreal feeling knowing that someone many thousands of miles away is holding and reading something that you poured months of your life into.

Since publication I've received two royalty statements from Apress which outline how many copies have been sold and how big the pile of money is for me to dive into. Needless to say that you need a degree to work out these statements (they have a 6-page FAQ for one page of statement) but it's my understanding that at the year end about 1,250 physical copies of the book have been bought. Now back in 2010 I said that I wanted 500 copies of the book to be bought, so when combined with digital sales and online subscription services (like Safari Books) the number of people with a copy of the book far surpasses my wildest expectations. Mind-blowing.

One moment related to the book that particularly stands out was when a nice lady approached me at a conference in San Francisco and asked me if I was the guy who wrote Foundation HTML5 Canvas. Just that alone was enough to make the whole writing process worthwhile but she then proceeded to tell me how much she enjoyed the book and how much it has helped her. I must say that hearing those words from someone I've never met before in a country thousands of miles from home was quite overwhelming. I absolutely love hearing from people that have taken the time to read the book.

Getting a job at Mozilla

If having the opportunity to write a book wasn't enough I then received the chance to work for Mozilla. To this day I still don't quite understand how I managed to land the job, but I did!

It all start back in December of 2010 when I was given the chance to talk about my multiplayer HTML5 game Rawkets at Mozilla's Game On event. As a result of that talk and a blog post I wrote about my future plans I was pointed in the direction of an opening at Mozilla that seemed to have my name written on it, so I applied. I still find it funny when I think back to the moment that I realised that people could be employed to experiment with and talk about cool Web technologies.

Fast forward a few weeks and I was flown out to Mozilla's headquarters in Mountain View, California for an interview. I don't know what was more exciting, the interview or flying on a plane covered in graffiti. I jest, the interview was obviously more exciting (but the plane was cool).

Fast forward a couple more weeks and a few phone interviews and I heard the words that I'd been hoping for, I'd been offered the job. I'm not even going to try to describe that feeling but I'm pretty sure I stood up and walked around the house before sitting down again to make sure that I really heard those words.

Make no mistake, getting the job as a Technical Evangelist at Mozilla is by far the most proudest moment of my entire life. Full stop. End. Finito. It set the scene for the rest of the year and will continue to do so for many more to come.

Finishing my university degree

I still don't quite understand how I managed to fit in my final year of university alongside writing a book and interviewing for the job at Mozilla. What I do know is that I wouldn't have been able to do it without the unending support from my lovely lady-friend Lizzy Robins.

What rounded off the year nicely was achieving a first class level degree, it really was the cherry on top of the cake and made the past 3 years feel all the more worthwhile.

My final year of university also saw the release of Rawkets as well as the publication of my research into Twitter sentiment analysis. I was amazed to see just how profound Twitter sentiment analysis can be when applied to global events like the passing of Steve Jobs. Truly awe-inspiring stuff.

Moving into a flat with Lizzy

My favourite non-Web moment of the year was moving into my first proper flat with Lizzy. I've really enjoyed settling down with her and the view from our place is beautiful, albeit only a "glimpse" (the words of the estate agent). There's something about being just a few minutes walk from an 8-mile beach that's good for the soul.

Speaking and travelling

The second half of the year flew by equally as quickly as the first, especially because my 3-year university degree was over and I'd started working full-time at Mozilla. Part of my job includes travelling in and out of the UK to give talks and meet awesome people and doing that accounted for a large chunk of the past 6 months.

I won't list everywhere that I've been to and spoken this year but here are a few of my favourites. It's safe to say that I've travelled more in the past 6 months than I have in my entire life!

Heart & Sole

Back in January I spoke at the inaugural Heart & Sole event in the UK. I had an awesome time talking about HTML5 canvas and the venue was absolutely stunning, particularly the view from the 150-metre high viewing deck.

State of the Browser

In March I spoke about canvas at State of the Browser in the UK. What was special about this event for me is that it was the first time I spoke about my new job at Mozilla in public, which was made even sweeter by the Mozilla employees who were in the room at the time.

SF HTML5 & Google Tech Talk

In July I was invited to give a talk at the San Francisco HTML5 User Group about the state of HTML5 gaming as well as another talk later the same week at the Google Mountain View headquarters about Rawkets.

Being able to speak in San Francisco was an awesome experience and very different to speaking in the UK. As for the Google talk, I can barely describe the geeky sense of epicness that I felt when talking at their headquarters in front of engineers way more intelligent than myself.

ASSEMBLY

It's safe to say that I have never experienced anything like ASSEMBLY in Finland this August, I'm fully confident that the Finnish geeks and gamers are absolutely insane (in a really good way). I really enjoyed giving a talk about creating visualisations with new Web technologies, meeting the mr.doob, and generally taking in the atmosphere.

onGameStart

Being invited to attend and speak at the first large-scale HTML5 gaming conference in the world this September was pretty special. I had great fun catching up with old friends and making a whole bunch of new ones. The developers in Poland are pretty awesome I have to say.

Web Developer Conference

Another event that was personal to me was WDC in the UK. It was at this event the previous year that I decided that I wanted to start speaking in public more, so being invited to speak at this year's event was pretty special. I talked about all the future Web technologies that developers should be keeping an eye on, with the WebVibrator API going down particularly well. No idea why!

Winning at the .net awards

In November I was fortunate enough to be nominated and chosen as the winner for Brilliant Newcomer of the Year at the .net awards. I've not really got much to say that I haven't already apart from thank you to those who nominated and voted for me. I'm mega-chuffed to be in this position.

Celebrating 3 wonderful years with Lizzy

This past December I celebrated 3 years with Lizzy, without whom I would have achieved practically nothing this year. I'm so happy to be with her and I owe her so much. I look forward to our future together.

Playing with awesome technologies

In 2011 I was massively surprised by the sheer amount of amazing technologies that were starting to see the light of day. I was particularly interested in how the open Web gaming industry was coming on leaps and bounds.

The follow are by far my favourite technologies that I played with this past year:

• Gamepad API
• Mouse Lock API
• Open Web Apps
• WebSockets
• Node.js

Goals from 2010

So did I meet my goals from 2010? Let's find out.

Improve my public speaking

Yes, yes and yes. Mainly as a result of my job at Mozilla although I'd still. 2011 has been a massive year for improving my confidence and abilities in regard to speaking in public.

Release the beta version of Rawkets and gain a base of 500 players

Ish. I certainly released Rawkets but I never counted the amount of regular players and I'm confident that it would be no where near 500 people. Maybe 5.

Sell 500 copies of my book on HTML5 canvas

Yes, and then some. 500 would have made be incredibly happy but I had to settle with a measly 1,250 in the end.

Find a source of income that allows me to continue experimenting

Yes, although not where I expected it. I can safely say that I never considered a role of Technical Evangelist with a large player in the Web scene. I'm still counting the Mozilla job as meeting this goal though, so there!

Wishes and predictions for 2012

I don't do resolutions and I've given up on trying to guess exactly what will happen so instead I'm going to state a few wishes and rough predictions for the following year.

Improvements in open game development on the Web

If this past year is anything to go by then 2012 will be a good year for open game development using Web technologies. I'd love to see the industry gather more steam and for some high-profile success stories to arise.

More praise and focus for hidden talent

It's no secret that I want hidden talent within the Web industry to be highlighted more. I'd love for 2012 to be the year when some viable solutions to this start to see the light of day.

Foundation HTML5 Canvas to be stocked in educational libraries

This is a much more personal wish but I aim to get Foundation HTML5 Canvas stocked in libraries at universities and colleges within the UK. Keeping up-to-date with the latest technologies is notoriously hard in education and I'm hoping this will help students get their first footing with animation and graphics with HTML5 and JavaScript.

Relaunch Rawkes with a better focus on content

I hope that 2012 will be the year that Rawkes gets updated with a much better focus on the content and the people that use it. This wish is already in the early stages of development and I'm confident that it will start bearing fruit very soon indeed.

Some interesting facts about 2011

As always, here are a few facts and figures about the past year. I've added a +/- comparison to the previous year on metrics that are similar.

It's been a busy time at Mozilla since the last update. The biggest news being that we launched the developer preview of the Mozilla Labs Apps project. This project is our vision of how applications should be on the Web; open and distributed. You should definitely read the announcement and the documentation, the functionality promised is mouth-watering.

Since the apps announcement I posted on the Mozilla Hacks blog about how gaming relates to our work with apps. In the post I detail all the APIs and functionality that we're working on at Mozilla that will directly benefit game developers.

I also wrote about ways that we can recognise the young and hidden talent within our community. It's an issue that I think deserves some time and effort to solve.

Links of the week

• Node.js now includes NPM
  • Node Package Manager is now included within the latest 0.6 builds of Node. This is a logical and practical step, I like it.
• The Relationship Between Firebug and Mozilla Developer Tools
  • The question about the relationship between Firebug and Mozilla's own Developer Tools comes up time and time again. Hopefully this post by the Developer Tools team will help make things clear.
• CNN Ecosphere
  • Pretty WebGL visualisation of tweets about the COP17 Conference. Just a pretty WebGL visualisation would have been enough for me!
• Blis - A blitted isometric system for AS3
  • This is a fascinating method of collision detection in games by giving every game object a different colour value. So simple, yet so clever.
• Let's have a look at some recently landed Web APIs for Firefox
  • WebAPIs are something I absolutely can't wait to see cross-browser. In the meantime, this post by John Hammink gives an overview of the WebAPIs that have already landed in Firefox.
• GLSL Sandbox Gallery
  • Anything to do with WebGL still blows my mind. This site lets you add your own GLSL code and share it with the rest of the community, all with a nice visual preview.
• DNS Service Discovery browser extension
  • This Firefox and Chrome extension is absolutely amazing. In a nutshell it allows you to access services on the local network or the Internet that have been broadcast using multicast DNS, like Apple's Bonjour technology. Imagine using this to look for local HTML5 game servers within the browser.
• node_mdsns
  • This Node.js package allows for multicast DNS/zeroconf/Bonjour service discovery and broadcast. Coupled with the browser extension above there really is nothing holding you back from creating services with Node.js that you can discover within the browser. Very cool!
• Fun with <video> and <canvas>
  • This little demo changes the colour of a page background based on what is showing in the video. I've seen something like this before, however this implementation seems neater and prettier.
• Move The Web Forward
  • Described as a "guide to getting involved with standards and browser development." Definitely worth a read.
• SublimeVideo Unleashed!
  • HTML5 video UI service SublimeVideo has unleashed its offering to everyone. It's such a well-designed experience and one that should be considered if you're hosting your own HTML5 videos.
• Spotify developer resources
  • Guidelines and documentation for the Spotify Apps JavaScript API. I'm yet to play with this yet but I'm excited to see what apps come out of it.

Track of the week

One (Logistics Remix) by Sky Ferreira. A bit poppy, but oh so awesome once you get into it.

Disclaimer: Although I talk about young people a lot I believe these problem and solution applies to people of any age. My intention is not to skew focus on young people but rather focus on people who are hidden within the community and don't have the opportunities to be rewarded. My focus on young people is merely from personal experience and the fact that young people generally don't have the same opportunity as those who are older (life experience, income, age-restrictions, etc).

It's no secret that the majority of award ceremonies in our industry are won by the people who are most well-known. It's just reality really, you can't nominate and vote for someone that you don't know, can you?

The problem with this is that there are a whole swath of talented individuals who just aren't getting the recognition that they deserve. It's mainly young people, and it's mainly because they're relatively unknown within the industry. I don't think that it's right to reward the loudest most prominent people and affectively ignore those without a voice.

Even just 2 years ago I would never have had the opportunity to win Brilliant Newcomer at the .net awards, but that is exactly what happened last month.

So why did I win this award now and not then? Well, partly because I've done a lot of well-publicised work in the last year, but mainly because I've been very vocal and deliberately trying to get myself in front of people within this industry. Not because I want to win awards but rather because it's my job and it's the only way I've been able to achieve one of my never-ending goals in life, sharing my knowledge with others.

If I hadn't been active at getting myself recognised within this industry I am under no doubt that I would not have won the award. In fact, I probably wouldn't have even been nominated in the first place! We're very good at recognising the people who are already well-known and vocal, but we're shockingly bad at recognising those who aren't so vocal and who might not have the ability to put themselves in front of the right crowds.

This has made me come to the conclusion that we need to start actively searching out these hidden gems within our community and also celebrating our young talent. I'd much rather read about someone new and exciting within this industry than read about another award that well-known Person X has won (although, I'm sure Person X deserved it). And by constantly highlighting the same well-known people we're systematically preventing the new talent from rising up and sharing the spotlight that we're encouraging them to aim for.

Now this is all well and good highlighting the issue, but it's an obvious one and I'm certainly not the first to be vocal about it — we need to be proactive about it.

What can be done about it?

After speaking to a friend of mine we've come up with a couple of potential solutions to the problem. Neither are simple but both can be achieved if someone truly passionate about the issue gets involved.

Creating a new type of awards ceremony

One avenue to explore is that of creating a new type of awards ceremony, one that solely focuses on the young and hidden talent within our community.

The problem with this idea is that this young and hidden talent is hard to find, that's kind of what happens when something is hidden. However, there is a potential solution to that problem. Neutral talent scouts.

These scouts, recruited by the awards panel, will scour their local communities and events for young and hidden talent. Anyone that is found to be showing initiative and skill will be put forward for nomination in the next awards. These scouts could be anyone from teachers, speakers, other young people, to anyone else with deep connections within the Web community.

What is nice about this concept is that the nomination process is no longer about who gets the most votes. Instead, the nomination process is about who in their local communities the scouts believe have shown the necessary qualities for nomination.

I truly believe that the only way awards ceremonies are going to improve is if the concept of public nomination, while a nice idea, is removed entirely. It is exactly the cause of the problems within these kinds of ceremonies, and the same is the case when a panel of judges selects people at a single point in the year. These methods just don't work.

Now, the scouts idea still isn't ideal but it's certainly a start. We'd still have to work out how to choose these people and how to make sure nomination is fair for all.

We also still need to work out how the voting process works. I believe that the public should definitely vote for these awards but I don't necessarily believe that the public should be part of the selection process.

In all, we can certainly do something to improve awards ceremonies but I don't think we'll ever be able to truly remove the biased nature of recognising the loudest people within the community.

We need something that isn't a one-off event. Something more regular. Something that can reward every talented person within this community instead of just one. With that comes the next solution.

Our Community Is Awesome (.com)

Ok, so that isn't a real name but hopefully you get the idea. It would be a website the celebrates all the talented people within our community who are doing awesome things.

How the website finds out about these people is still up for the discussion but I've had a few ideas:

• A scout system like the one I described for the award ceremonies
• User-submissions
• An automated system

All three have their pros and cons. The scout system means that little to no moderation will have to be done before highlighting someone on the website, however people could still be missed if they aren't seen by the scouts.

The user-submissions are a good idea because anyone who knows about the website can submit a friend or colleague that they feel deserves recognition. However this method will require extensive moderation and will leave people out who don't have friends who know about the website.

My favourite idea is to create an automated system of highlighting awesome people within this community. Perhaps this is my favourite because I like impossible tasks, who knows.

The general idea for the automated system would be to initially scrape the large creative outlets (Dribbble, Forrst, etc) for young and relatively unknown people. The system would then generate a daily report of the most interesting people and work.

This type of system would still leave out a lot of people (anyone who doesn't use the services it scrapes) so, until I learn how to create self-learning machines, perhaps combining this solution with one of the other two will be a good compromise for the time being.

I think that having something working and doing something good is better than having nothing at all. We can always improve upon the procedure over time.

So what next?

These are just ideas right now, nothing more. I know that myself and a few of my friends would love to see something like this, as I'm sure many others in the community would.

I'd love to hear about any similar projects around (I'm sure I'm not the first to come up with these ideas) and I'd also be interested to hear your opinions on the solutions raised in this entry.

Hopefully we can make 2012 the year that we put our egos aside and celebrate how amazing our community really is. Are you with me?

I'm looking forward to this functionality maturing and getting supported by the other browsers. For now you can play with this today in experimental Nightly builds of Firefox or download the Chrome Dev build for Windows support, or Chrome Canary for Mac support (Linux coming soon).

Since the last update there has been further progression with the Gamepad and Mouse Lock APIs within Firefox. In fact, there is now an experimental build of the browser that contains both APIs for you to play with.

Also, not long ago I started integrating the Mozilla Open Web Apps API, Gamepad API, and Full Screen API into Rawkets. This is the future, people!

The coolest thing about the Open Web Apps API is that it allows players to install the game (or any Website with an application manifest file) as a native OS app with a desktop/dock icon and no browser UI.

Links of the week

• Ilmari Heikkinen
  • Ilmari is part of the developer relation team at Google and part-time experimenter. His website contains some awesome examples of HTML5 and JavaScript; particularly Runfield and Missile Fleet.
• Socket.IO and firewall software
  • Useful research into the issues surrounding WebSockets and firewalls. Turns out there isn't such a problem so long as you're aware of the issue use the right ports.
• Building the Game
  • Source code and tutorials for Brandon Jones' series on building a game with WebGL.
• Introducing Flatiron
  • Yet another interesting initiative from the guys at Nodejitsu to make Node.js development a little easier.
• Report from the W3C Games Community Group Summit Nov 2011
  • Just after New Game Conference the W3C Games Community Group met up in San Francisco to discuss the state of creating games with open Web technologies. This report is the result of that meeting.
• HTML5 Game Lab
  • This partnership between Bocoup and Atlas Ventures aims to fund projects related to the open Web games industry.
• Developer Tools in Firefox Aurora 10
  • We're working hard at Mozilla to bring built-in developer tools to Firefox. Right now they are pretty damn awesome and this post highlights what can be done with them.
• ThreeNodes.js
  • This is apparently a vvvv clone for JavaScript, HTML and WebGL. I don't really know what that means but it looks amazing!
• HTML5 2D gaming performance analysis
  • The guys at Scirra have taken the time to do some performance tests on HTML5 canvas and WebGL. The results are interesting.
• Probe.io
  • A little tool that visualises the various transport platforms that Socket.IO supports. The aim is to help you determine which transports to support in your application.

Track of the week

Unlike Me by Kate Havnevik. I'm a massive fan on Imogen Heap, and that combined with the new Spotify resulted in me finding out about Kate Havnevik. Such soothing music.

I'll be assuming some experience with Firefox extension development, or at least the ability to follow this tutorial.

Being able to run Node.js within a Firefox extension is integral to my concept working. The idea is that anyone with this extension installed will have the ability to run a local Rawkets game server. So how do you run Node.js within an extension then?

Discovering nsIProcess

I didn't know where to start. I'd previously had some experience with bundling NPAPI plugins within a Firefox extension and assumed I'd need to build a plugin to run executable programs like Node.js. Fortunately I was wrong, there is a wonderfully simple interface called nsIProcess that sits within Firefox and allows you to run a binary executable.

nsIProcess has three methods in particular that you'll need; init(), runAsync() and kill(). They allow you to initialise your Node.js process, run it asynchronously, and kill it, respectively.

Bundling the Node.js executable

Before you can run Node.js you need to bundle the executable within your extension. The way you can this is to download and unpack the Node.js source then run the following commands within the terminal:

cd REPLACE_WITH_PATH_TO_THE_NODE_SOURCE_DIRECTORY
./configure
make

Do not run make install as you'll install the executable to your computer and overwrite any version of Node.js that you currently have installed.

Once the make process is complete you'll see a little note in the terminal output that states where the executable was placed. For me this was within the build/default/ directory within the Node.js source you just downloaded and unpacked.

The final step is to create a directory within your extension called components (or whatever else you see fit) and copy the node executable (it's just called node, no extension) from the build/default directory.

Note: You'll probably need to set the unpack flag to true within your install.rdf manifest file to make sure the Node.js executable is unpacked on the user's machine.

Initialising the Node.js process

Now that the Node.js executable is bundled you can set it up within your extension.

Copy the following code within your extension:

(function() {
    // Create an nsILocalFile for the Node executable
    var file = Components.classes["@mozilla.org/file/local;1"].createInstance(Components.interfaces.nsILocalFile);  
    file.initWithPath("REPLACE_WITH_ABS_PATH_TO_NODE_EXECUTABLE");

    // Check for Node executable
    if (!file.exists()) {
        // Node executable is missing
        return;
    };

    // Create an nsIProcess to manage the Node executable
    var process = Components.classes["@mozilla.org/process/util;1"].createInstance(Components.interfaces.nsIProcess);
    process.init(file);
})();

The first line initialises the file variable as an instance of the nsILocalFile interface. You'll be using this to grab the file of the Node.js executable.

On the second line you call the initWithPath() method of nsILocalFile and pass it a string defining the absolute path of the Node.js executable within your plugin.

The following if conditional statement checks to see that the executable was found and actually exists.

Lastly, you set the process variable as an instance of the nsIProcess interface that I mentioned earlier and call the init() method with the executable (referenced via file) as the only argument.

Running and monitoring the process

After initialising the Node.js process you're ready to run it.

Add the following code under process.init(file):

var ObserverHandler = {
    // subject refers to the process nsIProcess object
    observe: function(subject, topic, data) {
        switch (topic) {
            // Process has finished running and closed
            case "process-finished":
                break;
            // Process failed to run
            case "process-failed":
                break;
        };
    }
};    

// Run the Node process and observe for any changes
var args = ["REPLACE_WITH_ABS_PATH_TO_NODE_SCRIPT"];
process.runAsync(args, args.length, ObserverHandler);

There are two things happening here. Let's ignore the ObserverHandler for now and concentrate on the last two lines.

The first of those two lines defines an args variable as an array of strings. This array contains all of the command-line arguments that you want to pass to the Node.js process when you run it. In your case you want to run a Node.js script so just add one string to the array that is the absolute path to a script you've already put together.

The second of the lines calls the runAsync() method of the nsIProcess interface that I described earlier and actually runs the process. The first two arguments passed to this method are the array of arguments you want to pass to the Node.js process and the number of those arguments. The third argument is a nsIObserver interface that will receive notifications about the process, which we'll touch on now.

Your nsIObserver interface is the ObserverHandler object that is defined above the call to runAsync(). It has one method named observe() that is called whenever it receives a notification. This method receives three parameters; subject, topic, and data. They are described in detail on the nsIObserve documentation. For now, you're only interested in the topic parameter.

A simple switch statement checks the topic parameter of any notifications about the process. The only topics available for now are process-finished and process-failed, which occur when the process has finished running and when the process failed to run, respectively.

You won't be using this nsIObserver just yet but it's useful to have here as you'll need it later to deal with issues surrounding the start up and shutdown of the process.

Testing your handiwork

If all went well then you should be able to run your extension and have your Node.js script execcuted by the bundled node executable.

You can check to see if this works by either putting a delay in your Node.js script, or keep it running forever, then checking the Activity Monitor application on OS X (or likewise on other operating systems).

Type "node" into the search bar and you should see a Node.js process running from your extension.

Killing the process

It's all well and good that you've managed to get Node.js running within your extension (yippee!) but it's kind of running forever (not yippee). To fix this you're going to add some functionality that checks for Firefox shutting down and, if so, kills the Node.js process.

Before we continue, you should kill the current Node.js process if it's still running. On OS X you can click on it within the Activity Monitor and then click on the "Quit Process" button at the top left.

The first thing to do is include the Services module by placing the following line above var file, right at the top of your extension:

// Import Services module (startup and shutdown events)
Components.utils.import("resource://gre/modules/Services.jsm");

This module gives you access to a whole bunch of functionality, however all you're interested in at the moment is it's obs property that acts as a reference to the nsIObserverService interface.

Add the following code to the bottom of the extension, just below the call to runAsync():

Services.obs.addObserver(ObserverHandler, "quit-application-granted", false);

This will add a listener for the quit-application-granted event (that is fired just before Firefox closes) and will use the ObserverHandler object you created earlier to handle it.

Finally, add the quit-application-granted handler to the ObserverHandler switch statement and set it to run the kill() method of the Node.js process:

var ObserverHandler = {
    // subject refers to the process nsIProcess object
    observe: function(subject, topic, data) {
        switch (topic) {
            // Process has finished running and closed
            case "process-finished":
                break;
            // Process failed to run
            case "process-failed":
                break;
            case "quit-application-granted":
                // Shut down any Node.js processes
                process.kill();
                break;
        };
    }
}; 

This will kill the process when Firefox quits. I wouldn't rely on this to kill the process all the time as it won't run if the browser crashes (as if) or if the extension is uninstalled. I'll let you add in that extra functionality.

Testing it all one last time

Now if you run Firefox the Node.js process will be created (yippee!) and if you quit Firefox the process will be killed (double yippee!).

If this isn't the case then you have a problem and I would dig around the Error Console (Shift-Cmd+J) to check for obvious issues.

Doing this in Chrome

Please get in touch if you know how to do this within a Chrome extension, I'm yet to look into that and would love to know for future reference.

Working extension and code download

The full code as a working Firefox extension is up on Github. Feel free to download it, fork it, and generally do whatever you want with it.

The Web is proving to be a valuable and capable platform for games, particularly those produced using open technologies baked into the browser. These HTML and JavaScript games are beginning to shine, all thanks to the amazing APIs and functionality that come with Firefox and other modern browsers.

The Gamepad and Mouse Lock APIs are just two of the new additions coming to Firefox that are going to help mature this platform. We’ll be posting more about them as they develop but let’s take a quick look at them today.

I've included a video of the Gamepad API below, but definitely read more about these APIs on the Mozilla Hacks blog and download the experimental builds of Firefox to play for yourself.

At the beginning of November I attended New Game Conference, North America's first HTML5 game conference. It was organised by Bocoup and Google and was a resounding success, it even had great WiFi! The only downer to the trip was that I got hit in the head by falling hand luggage on the plane, again…

The videos from New Game are online now. I'd definitely check out Richard Hilleman's keynote, his experience at EA and general thoughts are exactly what the open Web gaming industry needs to hear.

Just after New Game was Mozilla Festival London, where I put on a multiplayer HTML5 gaming workshop.

More recently I've been playing with the brand new and terribly awesome Gamepad API in Firefox. Check out this little demo I made, the possibilities are endless!

Links of the week

• Fieldrunners HTML5 & WebGL
  • A recent port of the hit iOS game Fieldrunners to HTML5. Unfortunately it doesn't run in Firefox even though Firefox supports all the functionality that the game requires. Still, it's a great example of what kind of games can be made in HTML5.
• Canvas.fm
  • I love data visualisation. This little web service creates a radial visualisation of tracks on Soundcloud. So beautiful.
• Sticky Thing
  • Totally pointless but utterly addictive HTML5 demo. Bonus points if you can stick it to the top of the window by only throwing it.
• WebGL Inspector
  • Debug WebGL using this tool, fantastically useful!
• HTML5 game resources
  • A whole selection of resources related to HTML5 games, curated by Andrew Wooldridge.
• Dynamic procedural terrain in three.js
  • A beautiful example of what can be achieved with WebGL.
• Facebook documentation on HTML5 games
  • Facebook are spending quite a lot of time and effort around HTML5 at the moment. This set of notes and documentation on HTML5 games is full of useful tips and tricks.
• Are we fun yet?
  • This is the page that will be updated with the progress of technologies related to open Web games, particularly within Mozilla.
• Let Your Content Do the Talking: Fullscreen API
  • Overview and tutorial of the new Full Screen API that lets you expand any HTML element outside of the browser dimensions to fill the entire screen.
• HTML5 games list from Fleeting Fantasy
  • List of HTML5 games being worked on by members of the #bbg (browser-based gaming) channel on irc.freenode.net.
• HyperAndroid's coding experiments
  • Awesome selection of HTML5, JavaScript and CSS3 experiments.

Track of the week

Landed (Strings Version) by Ben Folds. I've always been a fan of Ben Folds but it was only recently that I stumbled across his music again. You should definitely check out the rest of his work.