The door is everywhere. To call it common is an injustice – it is as ubiquitous as the air we breathe, the water we drink, the taxes we owe. It is in our homes, our offices, our transport. It keeps us safe while we sleep, while we drive. It is our protection against the room next door, and the world outside.

The door is part of our vocabulary, our language. We “open doors”, we “close a deal”. We have an “open door policy”. We swing them open, we slam them shut. The door is our slave and our servant. The door is our bitch.

But the door is also our enemy. It attacks us, it frustrates us, it makes us look like fools.

The Toilet Door

The toilet door is my nemesis, the number one on my list of dastardly doors. And I’m not even talking about the cubicle door, that never gives you enough room to close without brushing your legs against the outside of the toilet bowl.

Nor even, the American cubicle door, starting a mighty three feet from the ground to allow full thigh viewing from urinal alley, and the inch-wide gap between the door and walls. One wonders whether Americans in public toilets in England feel lonely in their out-of-sight claustrophobic boxes. But these are not my primary concern.

My target is the exit door. The exit door? you ask. The exit door, I nod.

When leaving the toilet, or bathroom, or restroom, or outhouse, or water-closet, or so forth, the typical gentleman (for this is all I am permitted to observe), will customarily choose one of the following options. He will either wash his hands, or he will not wash his hands.

I shall not question the wisdom of the non-washers. Presumably they believe their hands to be unsullied by their efforts, usually involved in a mere “reveal-tug-dangle” gesture followed by the “tug-shake-tuck”. An inspection of the spray-deck in the men’s urinals does not reassure me that hands are quite as sanitary as their conscience. But I do not judge, I shall simply note that this practice exists and is commonplace.

A washer, indeed myself, would avail himself of the facilities, providing of course, and this is not always the case, that the washing facilities are cleaner than the sewage facilities. Equipment provided is usually an unpleasant soap, scaldingly hot water in one tap, lukewarm water in another tap, based around a basin area. The controls on the taps are judged to encourage the maximum use of water, such that there will always be one tap running for no apparent reason, which is impossible to shut off.

Once hands are adequately washed, one would look for the hand-drying facilities. These are allocated on a ratio of one drying unit to every three washing units, on the basis of physics completely unknown to science: that it is quicker to dry your hands than to wet them. The drying units will have been provided further back into the toilet area, to encourage awkward confrontations with other toiletting members of the public, and to generally persuade the user into joining the wet-hands-exit, wipe-on-trousers masses.

Further encouragement into this camp is provided by the drying unit. This has a fifty percent chance of existing, a forty percent chance of working, and a ten percent chance of actually doing any drying, since models manufactured before 2005 seemed to be modelled on the average drunk’s morning breath. Of course, you may just have one of those clever Dyson units, which are really neat but still leave a few drops on the fingertips don’t they?

Doors, doors, I’m coming back to doors. The exit of a toilet is always, always, always a pull door. Always.

Why. Why why why. I’ve just spent four seconds exquisitely washing, and four hours slowly drying, my clean clean hands. And now you’re asking me to grab hold of a door handle that has been held by every “tug-shake-tugger” and “wet-hand-wiper” who’s ever been in here.

That handle is never cleaned either. When the attendant (not a cleaner, never a cleaner), when the attendant comes to check the facilities, he (or she) will wedge the door open with their mop-bucket, and give a quick wipe to the spray deck. But we know they never check behind the opened door. That’s why that cock you drew in 2005 is still on that cubicle door over there. Wasn’t funny then, isn’t funny now.

To make matters worse, there’s often two doors as well. In case you waited long enough for someone else to come in (don’t ever try that), you’d still have the second to contend with. Your hands will be soiled when you head back to your table, and your hamburger/nuts/asparagus/finger food. It’s disgusting.

It’s disgusting and the door is at fault. Remove the door. Or let them be pushed, so I can kick it open. Either way, when we all die of goldfish-flu, this blog post is my “I told you so”.

CorriDoors

See what I did there? Clever, isn’t it. But not as clever as the build regulations that state that fire doors must be installed throughout buildings, and that those doors need to be closed at all times.

Which gives us the corridor doors. Harmless enough, just a barrier between you and where you want to be. Just give them a push.

Or is it a pull?

Hope it’s a push anyway, I mean, I’m carrying an armful of stuff.

But, hey, it’s got a handle. It’s a pull. One of those simple, clear, obvious rules of life. Right?

Wrong. Fifty percent of the time, your average push door is going to have a handle. Why? We don’t know. Maybe they’re future-proofing against change. Maybe the unions are in on it. In fact, if the door swings both ways, it’s even more likely to have handles. And most people will pull the doors, which is both awkward, and inconvenient. And unbelieveably, even though they pull to go through it one way, and pull to go through the other way, most people will never realize the doors go both ways. At this point, the door is looking cleverer than we are.

And one more point lost by humanity, to the door, is locks. Not the bold padlock, or the fancy chubb. No, I mean the slot locks at the top and bottom of the door. For we all know that when opening a set of doors in any building, the caretaker, janitor, or security guy will only ever open one of the two. God knows why – maybe they only see the doors at night, when they’re used by one person at a time. Next thing you know, you’ve got a hundred people pushing on both sides, before trying to squeeze through, ten abreast. Certainly at my school it was a regular scrum to get between classes, there’d be a cry of “bundle!” and a whiff of Hillsborough in the morning. This is how I lost all my teeth. True story.

Automatic doors

What an amazing invention it is, the automatic door. Sliding briskly aside as we approach, it is hard to believe that this work-driven slave to our presence could be a bad omen.

It is more of a trojan horse. For you never know how long it’ll take to open. And it’s always slightly longer than you’d like. Maybe the sensors are just waiting for you to get close enough, so you have to pause, wait, and then go on. It’s winding us up, little by little.

Either that, or they’re waaay too sensitive. You want to hang around in the warmth of the hotel lobby? Sure, but you’ll get looks, because even a hundred yards into this room, and you’re keeping the doors open. The doors will alert other visitors to this faux-pas, by inching in slightly, as if to say “have you moved yet”, before opening again. They’re playing a game, and they always win.

Lift doors, or elevators to our American friends, are widely know to be evil incarnate. Who knows what will appear behind those doors? Will there be a lift car, or will we fall to oblivion? Will they close at all, without us squeezing uncomfortably backwards into a lawsuit from Debbie in Accounts? This is why we face forward. We need to keep an eye on the door, but we also need to be able to push backwards without going face to face.

Automatic doors may not be killers, but they will add to your stress levels in a thousand different ways.

Door Etiquette

In this brave new world of unwritten etiquette, it is the men who suffer most. Do we buy dinner without asking, or should we split it. The success of the date depends on it. If she suggests splitting it, do we refuse? And if so, how many times? And the only thing we know for certain is that we’re not going home without paying something. It’s a lose-lose situation.

And so it is with the door. In days gone by, it would be appropriate to hold the door for a lady. Nay, it would be appropriate to open the door with gusto, and to wave the lady through.

Now, we’re in a quagmire. We all try to hold the door. Even when it’s not actually convenient. Especially when it’s not convenient. We hold it for guys, girls, and in case we can’t see anyone, a passing breath of air. I am not even going to cover the long distance holders, for whom you must race to be helped, for I think they’ve been dealt with repeatedly.

But it’s madness. Every time someone opens a door for me and waves me through I feel like wrenching out his throat and hanging it from the door frame. It’s a door, not a ten tonne weight! I’ve got it. I’ve got it.

Am I carrying heavy bags? No. Am I in some way unable to open the door myself? No. Am I wearing a hot dress that you’ve like to check out from the back? Not usually! Let me handle the door myself, and get out of my way!

The worst cretins, the real bastards, are the guys who try to hold a door open from the wrong side, while standing in it. I don’t even credit them with a throat-ripping. I give them a “what kind of plant life are you” look, and send them straight to hell. Girls, it doesn’t just happen to you (though I bet it’s a lot more frequent), it happens to everyone.

Let’s just agree now. You want to go through a door, go through it. After you’ve gone through, if someone else is about, just hold it open a second longer (just one!), and let go. Your friend has it from there.

It’s a door. We can take it on alone. It won’t kill us (unless it’s a toilet door). It won’t hurt us (unless we’re getting slammed by an automatic). It can’t chop us into tiny little pieces (unless it’s a revolving door). It’s no obstacle (unless it’s a corridoor). And we can get through it together (unless you’re holding it for me).

Or we can just move to Hawaii, where they don’t need doors. Personally, I’m on the next plane.

Chaining is the much-hyped process of calling multiple methods upon an object, all in one line.

$('#cup').addMilk().frothMilk().addEspresso();

It’s a simple trick to build into your functions: all you need to do is return ‘this’.

function baristaAction() {
   // do stuff
   return this
}

Most jQuery plugins do this to enable chaining, albeit with slightly different syntax. While potentially confusing, it’s simple enough and common enough to be quickly learnt.

$.fn.pluginAction = function() {
   // declare stuff
   return this.each(function() {
      // do stuff
   });
};

jQuery plugins look like this because the plugin has to act on a jQuery object, which is always an array of elements. Even when you specify an identifier, jQuery will return an array of length one, and you usually need to do your stuff on each element before returning the same set to the next function in the chain.

Using the approach above, this is clearly never going to work:

$('#cup').giveToCustomer().waitForCoffeeToBeDrunk().takeBackFromCustomer();

If we’re chaining, then none of these methods can wait for other actions to take place before returning. There’s no threading and sleeping in JavaScript.

The most common way to feign concurrency in JavaScript is to use the setTimeout and setInterval methods, particularly for animation. Asynchronicity is also found when waiting for another asset to load, for example JSON data, AJAX content or large images. These methods often use a callback function, placed either on the “onload” event of your data load, or after the setTimeout and setInterval managers have completed.

Our code could look like this:

$('#cup').giveToCustomer(function() {
    $(this).waitForCoffeeToBeDrunk(function() {
         $(this).takeBackFromCustomer();
    });
});

Nasty, right? Right? Nasty.

Let’s head away from the coffee and re-enter jQuery land.

In jQuery land, we find THIS code DOES work as expected:

$('#special-offer').show().hide().slideDown('slow').slideUp('fast');

Each action will take place in turn, the next only starting after the previous has completed.

So why are they so special?

jQuery manages this by maintaining a queue. Queues are a common programming concept: simply an array where you push new items on the end, and take them off the beginning.

var queue = [ ];
// add some items to the queue
queue.push(function() {
     //shave the woooorld
});
queue.push(function() {
     //make it a better face
});
// take an item off the queue and process it
var nextFunc = queue.shift();
nextFunc();

jQuery has built-in queues, so we don’t need to build our own like this.

For an example, here’s a really simple asynchronous method, which will make an object yellow for five seconds.

$.fn.makeYellowForFiveSeconds = function() {
    // I'm only using actions which act on jQuery objects, so I don't need to use 'each' as above.
    this.css( { 'background-color' : 'yellow', color : 'yellow' } );
    // reset the colour in five seconds time
    var that = this;
    setTimeout(function() {
        that.css( { 'background-color' : 'none', color : 'inherit' } );
    }, 5000);
    // action the next method in the chain
    return this;
};

If we use the above function like so

$('#some-element').makeYellowForFiveSeconds().hide();

We’ll probably never see the yellow. It’ll go yellow and disappear immediately. Five seconds later, the yellow disappears, and we won’t know that either because it’s already hidden. We need to recode to use the queue:

$.fn.makeYellowForFiveSeconds = function() {
    // I'm only using actions which act on jQuery objects, so I don't need to use 'each' as above.
    this.css( { 'background-color' : 'yellow', color : 'yellow' } );
    // reset the colour in five seconds time
    var that = this;
    this.queue(function() {
        setTimeout(function() {
            that.css( { 'background-color' : 'none', color : 'inherit' } );
            that.dequeue();
        }, 5000);
    });
    // action the next method in the chain
    return this;
};

Now when we execute again,

$('#some-element').makeYellowForFiveSeconds().hide();

It works as expected: the element appears yellow for five seconds, and only then disappears.
How did we get there? Well, we just popped an item on the jQuery ‘fx’ queue. Then, when our action was completed, we called ‘dequeue’ on the same jQuery object to allow the next animation to take place.

jQuery is very smart about queues. Each queue is tagged to the specific object, so queued actions on one item won’t hold up actions on another object. Of course if we wanted to do that, we’d just need to pick a common object to hold the queue, like the body. And equally, if we wanted to run two queues on a particular object, we can do that too, because both queue and dequeue will accept a queueName as first parameter. The default queue is ‘fx’, which is where the animation occurs.

jQuery’s queuing is powerful and smart. I used it in the mclaren.com website build, to coordinate actions. And of course, if you don’t like their implementation, you can always roll your own.

Number 1:  moretrackstrackslikethis.com

A useful mashup of lastfm’s “similar tracks” service and Spotify gives a great way to find new artists and music matching your tastes.  What’s particularly good is that you can match single tracks, so even if you only like one track by a certain artist, you can find good matches.

Written in 100% Pure CSS3, HTML5 and JavaScript.

Number 2: admission that this is just shameless link-bait

There’s some other great mashups out there. Check Spotify’s list.

There is an island.

This certainly contains spoilers. If you haven’t done the Lost thang, you probably should, because they’re really good, so stop reading this and head off to Amazon. Otherwise, if you’ve seen it all, and read all about it on E!, and seen the deleted scenes on DVD and so on, then you are truly qualified. Do read on.

There is an island.

The island has various inherent powers. It has a light in the middle. It has a strong electromagnetic force which baffles compasses and is prone to explosion. It is able to move, if a wheel is turned. Should the wheel be dislodged, the island can also travel in time. It is able to send people to the middle of a desert somewhere using the same wheel.

It has a large statue of an egyptian looking deity, and a smattering of ancient temples.

The island cannot be approached except by submarine, shipwreck or plane crash. The island cannot be left except by wheel, or by following a single compass bearing. People heal quickly on the island, regardless of the ailment.

A woman lives on the island.

One day a boat crashes on the island. After helping the survivor give birth to two boys, she kills the mother and takes the boys as her own.

Time passes, the boys grow.

The fair haired boy is fairly happy with his lot.

The dark haired boy learns of his mother’s demise, and adoptive mother’s betrayal. He leaves the family and joins another small village on the island. He is keen to leave the island.

The other boy just shrugs. Maybe he’s stoned or something.

The mother kills the villagers, and in turn is killed by the dark haired boy. Before she dies, the mother gives her non-specific powers to the fair-haired boy, who throws his dark-haired-brother into a pool of light as punishment. The dark-haired boy dies, but lives on as a smoke monster. The smoke monster is able to take the form of dead people, and so becomes the dark-haired boy again. He is far from happy.

Time passes. One day, a tidal wave brings an old ship to the island, destroying the statue. The ship is the Black Rock, and contains a fragile amount of dynamite, which is mostly used by a crazy French woman from Babylon 5. The survivor of the shipwreck is offered eternal life by the fair-haired boy in return for eternal service. He leads a small group of villagers, trying to do the “right thing”, though none of them know what this is, as the fair-haired boy never actually says what it is he wants. Another group of villagers live in a temple not far away, but don’t seem to know any of this. They too, are big fans of the fair-haired boy. And karate. They love that stuff.

At some point the island is discovered by scientists (the “Drama Initiative”), who hope to use the island to mankind’s advantage, and breed polar bears. They achieve a peaceful standoff with the villagers, and establish a force-field to prevent the smoke monster killing people. The smoke monster does not attack the villagers outside the perimeter, for reasons unclear.

The scientists cause a problem, meaning the eletromagnetic field must be vented on a regular basis. They combine this with a psychological test by locking up the maintenance team, slap on some warnings of a virus outside, and then sit back and monitor them with video cameras. When the team forget to vent, they are shown scary symbols, and lights flash. Underwear is changd. When the system eventually explodes, it actually causes no damage, except to the venting system itself, proving the entire system was something of a timewaster.

Faced with the most ridiculous pseudo-scientific endeavours since the invention of homeopathy, the villagers outside the perimeter rise up against the harmless hippy scientists, headed by the poor son of a drunken employee who is unhappy with his lot. He leads the village and all are happy, though he does not permit them to leave.

The fair-haired boy decides to bring some new people to the island. He does this by crashing a plane on it. Many people are killed and injured. Of the survivors, many are then killed by the smoke monster. Of the survivors, many are killed by the villagers. Of those survivors, many are killed in attempts to leave the island. And of the few remaining survivors, some escape.

The majority of the escapees return to the island as soon as they are able, by crashing another plane on it. Of those people, most are killed by attempts to escape again, by villagers, and by the smoke monster, who has arbitrarily taken the form of one of the original plane crash survivors.

Of the handful of subsequent survivors, the leader of the villagers kills the fair-haired boy, for treating him poorly for most of his life. The fair-headed boy brushes it off like a bad smell, and still continues to plague the poor cursed humans he crashed on the place.

Some more people die.

The fair-headed boy offers the few remaining survivors the opportunity to take over the running of the island. One volunteers. He immediately does the opposite of everything he was meant to do. The smoke monster becomes vulnerable and is killed. He will never see Paris in the spring. Woo-hoo. The volunteer then dies. Aw. Someone else takes over, seconded by the leader of the villagers who has been accepted despite repeated killing and torture of other survivors.

The fair-headed boy is named Jacob. He is able to travel anywhere at whim. He brings people to the island knowing they will die. He is able to assist or even offer immortality, but he does not. He crashes planes for a bit of company. For some reason, he is know as the Good Guy.

The dark-haired boy simply wishes to leave the island. He cannot, for his brother killed him. He kills bad guys and good guys alike, but brings no people to the island. He seems no more morally corrupt than the survviors themselves, but is known as the Devil.

Is that fair?

Only Michael’s kid (“that’s MY boy”) and the Kwon’s kid (sob sob) leave the island in peace, and move on. I think probably, they win.

Of course, at the final judgement, they’re all dead. But they had a good time and made friends along the way. So that’s all ok then.

This time I’ve rewritten it to use SVG, whose arrival in IE9 promises to make HTML more interesting. In fact, I’m far more excited about animated SVG than CSS transforms and the fabled HTML5.

I used Keith Wood’s jQuery SVG library, which seems quite helpful, and simply replaced the ‘draw line’ commands with their equivalents.

Canvas is the bitmap to SVG’s vector, so while I have to clear the screen and redraw each time in canvas, I merely need to move the lines in SVG. Presumably the number of shapes on screen affects performance, so that was a big difference.

Here’s the result: JS-Fireworks in SVG. I’ve reduced the number of items in each explosion from 30 down to 10. You’ll see why.

It runs very quickly in Chrome (Mac), slowly in FireFox, and smoothly, though not excessively quickly, in IE9, which I’m quite excited about. Where’s IE9 Experiments?

I haven’t tried IE678. But then I haven’t tried Mosaic either.

Good man. But what of the rest? The “www.” that was so unpronounceable is already obsolete, and personally I think twitter can take credit for popularising the contemporary non-dubbed url form. Boffins in lab coats has worked tirelessly to make memory ubiquitous and cheap, but we’ve just stuck some character limits in there to be fashionable or something. Hey ho. But the “www” is gone.

Can anyone tell me why there’s a huhtetep, “http:”, still shown in my address bar? What’s it for? What does it tell me? I don’t actually have to type it in these days, but it appears there anyway. Why?

Is it to show that I’m looking at a document provided by HyperText Transfer Protocol? I don’t care about that!

Is it to show that I *could* be looking at an FTP site, using the same browser? Ok, fair call, but that’s so rare to do so, that you could default to not showing “http:”, and then only show “ftp:” when FTP sites are used. It’s not like every browser has a built-in FTP client anyway. Same goes for local files.

Is it to show the “s” when I look at an “https” page, meaning that the connection between my browser and the website is encrypted? Well, ok, but what was wrong with the padlock? Why is there such a strong connection between certificates and https anyway? They mean completely different things. I don’t need a certificate to know gmail.com is Google. Equally, a certificate costs about 20 bucks and has so few checks that I’m hardly reassured when dealing with a new site by the presence of the certificate. What I want to see is a padlock. Drop the “https” and show me a padlock.

Is it for future extensibility, to enable a future Internet to use new and unusual protocols? Like “about:”? Again, it would be simple enough to recognise a default of http. If you go to about:config, then display the protocol. Why is this hard? If a new protocol came along to overtake http, then I think a bigger browser update would be needed anyway.

I think browser manufacturers should take treat it like the port. Every web page is served by a port, and for most of the web, that’s port 80. You could look at this website by typing http://kenneth.kufluk.com:80. But mostly, the 80 is assumed. You only ever type in a port if you’re not using port 80, such as for local development. If you type “:80″ into a web browser like Chrome, it disappears. Let’s do that for “http://” as well. if you’re thinking there might be confusion between ports and protocols, you’re wrong. Protocols are letters-only, Internet domains need at least one dot, and ports are only numeric.

I’m using Chrome version 5, the latest in a long history of browsers. Surely it’s long past time to kill off the http://. And if you look closely, you’ll see the iPhone already has.

The exception is raised in /django/db/backends/util.py, line 19.
When I checked the local vars of the query.py step, line 2369, I got the following SQL:

'UPDATE "shop_order" SET "site_id" = %s, "contact_id" = %s, "ship_addressee" = %s, "ship_street1" = %s, "ship_street2" = %s, "ship_city" = %s, "ship_state" = %s, "ship_postal_code" = %s, "ship_country" = %s, "bill_addressee" = %s, "bill_street1" = %s, "bill_street2" = %s, "bill_city" = %s, "bill_state" = %s, "bill_postal_code" = %s, "bill_country" = %s, "notes" = NULL, "sub_total" = %s, "total" = %s, "discount_code" = %s, "discount" = %s, "method" = %s, "shipping_description" = %s, "shipping_method" = %s, "shipping_model" = %s, "shipping_cost" = %s, "shipping_discount" = %s, "tax" = %s, "time_stamp" = %s, "status" = %s WHERE "shop_order"."id" = %s

with the following params:

(1, 761, u'abc abc', u'abc', u'abcabc', u'abc', u'(UK32)', u'E17 8QG', u'GB', u'abc abc', u'abc', u'abcabc', u'abc', u'(UK32)', u'E17 8QG', u'GB', u'13.2500000000', u'15.0000000000', '', u'0E-10', u'Online', 'Dots Postage and Packing', <django.utils.functional.__proxy__ object at 0x24142d0>, 'dotship', u'1.7500000000', u'0E-10', u'0E-10', u'2010-05-05 14:13:07.134682', u'', 713)

You can see the __proxy__ that shouldn’t be there.

Looking back at my code that provides that particular value, I found I’d used the _() shortcut, which in this file, is bound to ugettext_lazy. Of course, this is the problem! The lazy evaluation isn’t being executed before the query is evaluated.

To fix, either use gettext directly, or change the shortcut for _ from gettext_lazy to gettext.

So my project urls.py looks a bit like this:

from django.conf.urls.defaults import *

from satchmo_store.urls import urlpatterns

from django.conf import settings
from satchmo_utils import urlhelper

urlpatterns += patterns('',
    #add my normal urls here
    (r'^blog/index/$', 'myblog.views.blogindex'),
    (r'^photos/', include('photoapp.urls')),
)

urlhelper.replace_urlpatterns(
    urlpatterns,
    [
        #add override urls here (match the name from satchmo's url files)
        url(r'^$', 'myblog.views.homepage', {}, name='satchmo_shop_home'),
    ]
)

Part six, the last part, covers the monitoring tools.

Of course, we’re using the standard Google Analytics monitoring, which is great at delivering summary stats for past events (or even earlier in the day if you go and move the dates to include today). I’ve implemented the newer asynchronous calls of course.

For real-time monitoring of stats, we’re using two tools. One, we merge the subscriber counts returned from nginx to show the number of viewers during the race.

Second, we use ChartBeat. It is awesome.

There’s a limited amount I can show here, since the dashboard screen is quite interactive. The stats show above are for a random weekday morning just before Easter, and so are quite low.

Click here to view live stats for this site (though it’s probably only you watching right now).

While our visitors are screen-switching between our website and the TV footage, we’re also toggling to ChartBeat. It’s been a great help to be able to watch the subscriber counts, mix in the twitter feedback, and see exactly where everyone is.

However, we found that while we can see visitors watching for up to two hours on ChartBeat, our “average time on site” recorded for Google Analytics was tiny – around two minutes!

Accounting for the Google Analytics “Time on Site” discrepancy

Checking through GA’s documentation reveals the reason for the difference.

In order to capture the length of a visit, Google Analytics tracks the elapsed time between pageviews. The last page of a visit will not be recorded (as there is no subsequent pageview).

http://www.google.com/support/googleanalytics/bin/answer.py?hl=en&answer=57044

So if you have a page which is viewed for a significant period of time, and is then closed without further interaction, your visit durations can be seriously compromised.

Our solution is to use Event Tracking to log an event every minute.

	// Ping google analytics every minute to show accurate figures for "time on site" and "length of visit".
	// this can also decrease "bounce rate" figures.
	// one minute is the recommended interval
	var gaPing = setInterval(function() {
		//using the async tracking calls
		_gaq.push(['_trackEvent', 'SomeSortOfCategory', 'SomeSortOfAction']);
	}, 60 * 1000);

Since implementing this code, we’ve had a lot less disparity between ChartBeat and GA figures, though there is still some (<10%).

The recommended view for Google Analytics for viewing something like a race, which lasts for just two hours, is to go to:
Visitors > Visitor Trending > Time on Site
Choose the day that you’re interested in.
Then click the little ‘hour’ icon in the top right (hadn’t noticed that had you?)

And we finally get some real stats. Our average visit length is now well over an hour during the race, which is huge.

A warning on tag expiry

Both ChartBeat and Google have an upper limit on views. Google will record a maximum of 500 tags per user session, which is fine is we keep our pings to a minute. ChartBeat has a limit of two hours, which causes a noticeable false dropoff towards the end of our races.

Wrapping up

Ok, I think that’s all that needs to be shared in this series. If you have any extra questions, let me know. If you’re working on a large-scale realtime data server, and need me for some consulting/development definitely give me a call. And if you think there’s a better way to do all of this, let me know as well.

I’ll be writing up what we’ve done here in several parts. Sign up for my RSS feed to keep updated.

Part five covers the setting up of broadcast servers using Amazon EC2.

If you’ve never worked with Amazon EC2 before, please follow my ‘Getting Started‘ guide first.

In a previous part, we covered nginx setup set-by-step, so this time we’re going to look at creating a set of cloud servers with a single line of code.

Setup using a script

Required: ec2 command line tools

Amazon AMIs allow you to pass ‘user-data’ into the image. The alestic AMIs are configured to allow this data to be executed as soon as the machine starts. For more on this, have a look at their article “Automate EC2 Instance Setup with user-data Scripts“.

I’m going to use a script called “install-nginx-mclaren“. Save it to your working folder now, and execute the lines below from the same folder.
This script was quite hard to write, due to various complications with the way the script gets passed in. Line breaks are particularly difficult, and it’s always hard to set values deep in a configuration file using a script.

ec2-run-instances -n 1 --key mclarenkey --user-data-file install-nginx-mclaren ami-bdc0ebc9 -t c1.xlarge

where 'n' is the number of instances to start.

This starts a 64-bit 8-core 7GB “High-CPU Extra Large” Server running an Ubuntu 9.10 Karmic AMI, from Alestic.com

Your server is now visible in the Amazon AWS Management Console.

After around a minute, your servers should be running. You can view them by typing:

ec2-describe-instances

Response:

[Deprecated] Xalan: org.apache.xml.res.XMLErrorResources_en_US
RESERVATION	r-66ca1711	893696797735	default
INSTANCE	i-ecde7c9b	ami-b3c0ebc7	ec2-12-345-67-89.eu-west-1.compute.amazonaws.com	ip-10-226-42-19.eu-west-1.compute.internal	running	mclarenkey	0		m1.small	2010-03-16T10:50:47+0000	eu-west-1a	aki-b02a01c4	ari-39c2e94d		monitoring-disabled	12.345.67.89	10.226.42.19			ebs
BLOCKDEVICE	/dev/sda1	vol-62967b0b	2010-03-16T10:50:57.000Z	

You can now see the Public DNS to connect.

When using ssh, connect as user “ubuntu” (this is related to the choice of AMI)

ssh -i ~/.ssh/mclarenkey.pem ubuntu@ec2-12-345-67-89.eu-west-1.compute.amazonaws.com

It will take a few minutes for the setup script to run. You can watch it in action like so:

tail -f /var/log/syslog

Our server is now running!

View it here:

http://ec2-12-345-67-89.eu-west-1.compute.amazonaws.com/

If all is well, you’ll be sent straight to mclaren.com!
More useful are the feed urls:

http://ec2-12-345-67-89.eu-west-1.compute.amazonaws.com/feed/publish

http://ec2-12-345-67-89.eu-west-1.compute.amazonaws.com/feed/subscribe

Remember to pop into your nginx conf file and configure your POST IPs!

In the final part in the series, I’ll cover monitoring.