UPDATE: This is a great answer to this post.

var routes = [

    /* / */
    function(request){
        if(/^\/$/.test(url.parse(request.url).pathname)){
            return {
                controller:'index',
                action:'index',
                data:{}
            };
        }else{
            return false;
        }
    },

    /* /about */
    function(request){
        if(/^\/about$/.test(url.parse(request.url).pathname)){
            return {
                controller:'index',
                action:'about',
                data:{}
            };
        }else{
            return false;
        }
    },

    /* /news/story/[0-9] */
    function(request){
        var test = /^\/news\/story\/([0-9]+)$/
                    .exec(url.parse(request.url).pathname);

        if(test){
            return {
                controller:'news',
                action:'showStory',
                data:{
                    storyId:test[1]
                }
            };
        }else{
            return false;
        }
    }
];

As you can see, I’ve written the same function twice at the top, more or less. Now there are a couple of ways to refactor this. The obvious one of course is to have the function which acts on this array check if the input is an object or a function and act accordingly, so that the route could just be an object with a regex and info about the action and controller. I decided not to go with this option because I like to avoid code with lots of switching and cases if possible, just running the function seems much cleaner to me.

So instead I created a function that would create the most common case functions. That way I could write my routes like this:

var routes = [

    /* / */
    r(/^\/$/, 'index', 'index'),

    /* /about */
    r(/^\/about$/, 'index', 'about', {foo:'bar'}),

    /* /news/story/[0-9] */
    function(request){
        var test = /^\/news\/story\/([0-9]+)$/
                    .exec(url.parse(request.url).pathname);

        if(test){
            return {
                controller:'news',
                action:'showStory',
                data:{
                    storyId:test[1]
                }
            };
        }else{
            return false;
        }
    }
];

Much cleaner, just as flexible, and to the caller it looks exactly the same, because the function ‘r’ returns a function that looks like the one I created for the news story, like so (I also added the feature that query variables would be added to the data object):

function r(regex, controller, action, data){
    var exp = regex,
    d=data || false,
    ret = {
        controller:controller,
        action:action || 'index'
    };

    return function(request){
        var uri = url.parse(request.url, true);
        if(exp.test(uri.pathname)){

            //get the query string and add it to the data
            var retData = uri.query || {};
            if(d){
                for(var i in d){
                    retData[i] = d[i];
                }
            }

            ret.data = retData;

            return ret;

        }else{
            return false;
        }
    };
};

People like to steal iphones. Its a fact of life. For the most part they just want to sell the phone without your sim card or your data. However, if you are like me you keep a lot of stuff on your phone…a contact list of course, but more importantly you keep your email on it. Also of course a thief could use it to call their best friend far away for free. To prevent this phones have always had the feature of a passcode, which you should be using already on your iphone. At some point in the recent past apple added an even more useful feature: you can set it so that the phone erases itself after 10 incorrect passcode entries.

To enable this setting follow these steps:

Go to general settings:

Click on “Passcode Lock”

Enter a passcode you won’t forget, then set “Erase Data” to on.

Then you should be pretty much only out an iphone when it gets stolen. Still sucks, but not as bad.

The results annoyed the crap out of me. I want to hate php. I want to break free of php. But it keeps pulling me back in. In a battle between php and python in the field of coin tossing, php mops the floor with python. The php script was six times faster (587ms vs 3075ms). But the python script was much more pleasant to write, for what its worth.

I wasn’t at all surprised by how well JavaScript (running in Node/V8) performed. The js script did the job in 123ms, better than 2x the php script. The C program took 40ms.

Obviously this is not a real test in any way, but the results were interesting:

> time ./toss.php
Heads: 501211
Tails: 498789

real	0m0.587s
user	0m0.555s
sys	0m0.015s

> time ./toss.py
{'tails': 500309, 'heads': 499691}

real	0m3.075s
user	0m2.989s
sys	0m0.052s

> time ./a.out
heads=  499798, tails= 500202

real	0m0.040s
user	0m0.027s
sys	0m0.002s

> time ./flip.js
{"heads":500140,"tails":499860}

real	0m0.123s
user	0m0.111s
sys	0m0.009s

Anyway, here is the code, my apologies if the C and python are ugly, I’m new to both:

PHP:

#!/usr/bin/php
<?php
function getRandom(){
	return rand(0,1);
}
$num = 1000000;
$heads = 0;
$tails = 0;

for($i=0; $i < $num; $i++){
	$t = getRandom();
	if($t){
		$heads++;
	}else{
		$tails++;
	}
}
echo("Heads: $heads\nTails: $tails\n");

And in Python:

#!/usr/bin/python
import random
rand = random.Random()
results = {"heads":0, "tails":0}
num = 1000000
def toss():
	return rand.randint(0,1)

for i in range(0, num):
	if toss():
		results['heads'] += 1
	else:
		results['tails'] += 1

print results

C:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main (int argc, char *argv[])
{
  unsigned int iseed = (unsigned int)time(NULL);
  srand (iseed);

  int i, num, heads, tails;
  for (i=0; i<1000000; i++)
  {

	num = rand() %10;
	if(num > 4){
		tails++;
	}else{
		heads++;
	}

  }
	printf ("heads=  %d, tails= %u", heads, tails);
  return 0;
}

Javascript:

#!/usr/local/bin/node
var sys = require("sys");

var i, len=1000000, floor=Math.floor, rand=Math.random;

function toss()
{
  return floor(rand() * 2) % 2;
}

var results = {heads:0,tails:0};

for(i =0; i < len; i++ ){
	if(toss()){
		results.tails++;
	}else{
		results.heads++;
	}
}

sys.puts(JSON.stringify(results));

(Isaac contributed a few performance suggestions for c and javascript. I had a bug with the c one, so I ignored it)

Timepicker available on YUI Gallery

First things first, my YUI Timepicker widget is now part of the gallery. That means you can use it straight of the Yahoo CDN with a Y.use() statement. Please check it out and file bugs, feature requests, or go ahead and fork on github and add the features yourself!

YUI Doc Talk on Slideshare

My talk on YUI Doc from YUI Conf is now on slideshare. Please check it out, I have a video of the talk, but I am going to wait until its uploaded to the YUI Gallery before I post it.

Still looking for a few good Javascripters

We haven’t filled all our openings yet, but we have been getting great responses from the YUI Blog post. If you want to work at yahoo, please, send us those resumes!

UPDATE

Video is available here.

I cover the tool, some pest practices, etc. I’ll post the video as soon as its available, but in the meantime I have create a project on github that shows you a simple example of using YUI Doc as part of your build.

Get it here.

Check it out, send a resume, come work for us!

So I am always looking for ways to improve this situation. Lately two (or rather three) great tools have changed things quite a bit. First is Isolator, an incredibly useful little app that hides everything but the app you are using behind a little screen, which can be activated with a keyboard shortcut.

I have also been converted to the joys of a tiling window manager by a coworker. I installed awesomewm on my mac via macports, and Ratpoison on my RHEL 5 box (awesome is not available from yum for rhel 5). That way I can do all my terminal stuff with no distraction, and its great to have multiple terminals running together. Here is my workspace at work now:

If your app sends largish amounts of data upstream (excluding images, which are already compressed), consider implementing client-side compression. It’s possible to get 1.5:1 compression with a simple LZW+Base64 function; if you’re willing to monkey with ActionScript you could probably do real gzip compression.

So to try this out I implemented LZW compression in javascript, except instead of using Base64, which adds more complexity to encoding and inflates the file size quite a bit, I used a trick I’ve seen elsewhere: use the unicode character equivalent to the decimal code output by the LZW algorithm. For the example I used the first 256 first characters in the unicode set as the allowed characters. This breaks any non-latin script for this example, but this proves the concept. I was able to get decent compression. Using the 800 byte example string I got the output down to 705 bytes. In firefox encoding took around 2.38ms, and decoding took a little less. In safari encoding only took .83 milliseconds.

Not sure if this is really worth it or not, but its a cool thing to try out. I think in general just reducing the size of upstream data when possible is probably worth it, but like everything only testing will really say for sure.

Checkout my example here. And get the code here.