Hi, I'm Dominic Tarr. I am a Mad Scientist from New Zealand. I live in a tree, sail around in a boat and hack Node.js. Historically, I've only worked for ninja themed companies, and recently I have started contracting for Nodejitsu. Here at Nodejitsu, there are always a couple of Mad Science projects on the go. Normal people might call these "side projects", but Mad Scientists don't do "side projects".
We do Mad Science.
First there is the Science part, a Mad Science project has to be a bold idea about how some big problem might be solved. Then there is the Mad part. This is the way that once you've thought of your mad science idea, you can't forget it. It niggles away at you, and whenever you encounter your problem again you remember it, thinking, this problem could be solved with some Mad Science.
The only option you have left is to try and build it.
One mad science project associated with nodejitsu is Marak's Hook.io. Hook.io is a generic implementation of "web events". Events are happening everywhere on the internet, all the time. But how do you listen to them? And what amazing applications could you build if you could easily connect all these different events together in an organized way?
Marak did a talk on hook.io at JsConf 2010. since then hook.io has been on the back burner as nodejitsu has been ramping up, but it has recently reemerged with a new approach, based on a marriage between dnode (substack's RPC protocol), socket.io (cross browser websocket support) and EventEmitter2 (another nodejitsu Mad Science project which is a reworking of node's native EventEmitter, but with proper namespaced events)
I also have a mad science project, Meta-Modular. Meta-Modular is based on the idea that version numbers are wrong, and are not the way your dependencies should be specified.
Instead, you should declare your dependencies by specifying what tests a dependency should pass. Then, in theory, any implementation of a dependency that passes the test should work in that slot. However, implementing a system like this needs not just a way to dynamically inject dependencies into a test run, but also to analyze large amounts of multi-dimentional data, to see what combinations of dependencies work with what tests.
Imagine the time that could be saved if there was a service that could tell you what forks passed a particular test. And imagine what could then be done with that time, and that knowledge!
As you explore a mad science idea you inevitably encounter difficulties. Success usually feels like it is a month away, and that the new approach it the one, but you never know.
To illustrate this problem I like to use the example of the three parallel rivers in Yunnan province in China. In South West China the Yangtze, Mekong, and Salween rivers, three of the largest rivers in Asia, emerge from the Tibetan Plateau and flow parallel through three gorges between four mountain ranges. Suppose you are the plucky adventurer at one side of this, and you want to know whats on the other side...surely it is a lush fertile plain. So you climb the first mountain range, and what do you find? A gorge, and another mountain range. Surely the plain is on the other side of that, so you cross the river and the next mountain range. By now many members of your party have died of exposure or drowned in dangerous river crossings. You get to the top of this range...only to see another gorge, and another mountain range. This is when you start to ask yourself, just how many gorges are there?
Should you give up? Or push on into the unknown?
For the truly heroic adventurer, this is not even a question.
So far, Marak has attacked the evented web problem three times in node.js, with two other attempts using Python's Twisted and even Coldfusion. I've tried meta-modular in Java, Ruby, and now Node.js. Currently it manifests itself as testbedjs.org which is an open-source community based continuous integration system.
There are many Mad Scientists working in Node.js. Infact, Node is a mad science project. Ryan has been working on the idea of a tinyclouds framework for years. Ultimately, the idea is many lightweight asynchronous evented servers, which communicate by message passing. Before Node got popular, Ry tried out many solutions using Ruby, C, Haskell, Lua, Nginx, whatever he thought would be the best way to solve his problem. Check out some of ry's older work at http://tinyclouds.org/libebb/ and https://github.com/ry/ebb/.
Ryan's hard work and Mad Science has enabled other Mad Scientists to expand on their own visions. Just imagine what the next generation of Mad Science will yield. I predict that hook.io will make Ruby on Rails look like PHP and the concepts behind Meta-Modular will make Github style code hosting look like SourceForge.
The only question now is, what is YOUR mad science project?