By applying a unique value to each rank (Ace, 2, 3, 4, 5, and so on), you can determine the total value of the entire deck:

Knowing that the entire deck equates to 364, by removing any one card, the deck’s value will lower by the value of that card. For example, if an Ace (1) is removed, the deck’s value will fall to 363.

So by getting a friend to remove a card, you can determine their card by simply adding the remaining cards. It takes a few minutes and will only tell you the rank of the card, not the suit, so it’s probably best to run through the deck again and take out the remaining three cards of that rank to “prove” you know what card they had. This trick works a treat but you can very easily mess up your count, so be sure to take your time otherwise you may end up with the wrong card.

If that’s too easy, you can always make things a little more difficult by applying a unique value based on the bumps/points its suit has:

In practise:

Note that with this system, the deck’s value will be 1378, as proven below:

A simple method to memorize each card might be to minus 1 from the rank, multiply by 4, then add the bumps/points (for example: 4 of Diamonds is 3 multiplied by 4, add 4; this equals 16).

With both systems, it might be wise that whilst counting, to reset every time you hit 100 (for example: with a count of 96, a 6 would cause the running count to fall to 2 instead of 102). This way, keeping count should be a lot easier. Good luck.

Element.querySelectorAll

A browser-native selector engine that allows you to select element nodes based on a CSS selector (for example: div p a).

var a = document.getElementById('a');

a.querySelectorAll('div.post > p a[class]');

Element.firstElementChild / Element.lastElementChild / Element.previousElementSibling / Element.nextElementSibling

Selects the first/last element child or the previous/next element sibling. Saves on extrenuous code like:

var previous = document.getElementById('example');
while((previous = previous.previousSibling) !== null && previous.nodeType !== 1) { }

var a = document.getElementById('a');

a.firstElementChild;
a.lastElementChild;
a.previousElementSibling;
a.nextElementSibling;

Element.children

Similar to the childNodes method, but without text nodes and comments.

var a = document.getElementById('a');

a.children;

Element.compareDocumentPosition

Allows you to compare one node’s position to another. Returns a bitmask.

var a = document.getElementById('a');
var b = document.getElementById('b');

a.compareDocumentPosition(b);

Element.contains

Returns a boolean whether or not an element is contained within another.

var a = document.getElementById('a');
var b = document.getElementById('b');

a.contains(b);

Unfortunately, it requires some additional code:

indexOf

Returns the first index where a value (searchStr) appears. startIndex allows you to begin the search at a predefined index.

Array.prototype.indexOf = Array.prototype.indexOf || function(searchStr, startIndex) {
	for(var i = startIndex || 0, thisLength = this.length; i < thisLength; i++) {
		if(searchStr === this[i]) {
			return i;
		}
	}

	return -1;
};

inArray

Returns either true or false if a value (searchStr) is in an array. startIndex allows you to begin the search at a predefined index.

Array.prototype.inArray = function(searchStr, startIndex) {
	return this.indexOf(searchStr, startIndex) > -1;
};

flatten

Flattens a multi-dimensional array to a one-dimensional array.

Array.prototype.flatten = function() {
	for(var i = 0, thisLength = this.length, b = []; i < thisLength; i++) {
		if(this[i].constructor === Array) {
			this[i] = this[i].flatten();

			for(var j = 0, thisILength = this[i].length; j < thisILength; j++) {
				b.push(this[i][j].constructor === Array ? this[i][j].flatten() : this[i][j]);
			}
		}
		else {
			b.push(this[i]);
		}
	}

	return b;
};

tidy

Tidies up an array by removing dupe values and flattening it to a one dimensional array.

Array.prototype.tidy = function() {
	var a = this.flatten();
	var b = [];

	for(var i = 0, aLength = a.length; i < aLength; i++) {
		if(!b.inArray(a[i])) {
			b.push(a[i]);
		}
	}

	return b;
};

All this code has been tested on the following browsers and works perfectly:

• Firefox 1.5, 2, 3, 3.5
• Chrome 1, 2, 3
• Opera 7, 8, 9.5, 9.64, 10
• Safari 3, 4
• Internet Explorer 6, 7, 8

Function.prototype.benchmark = function(iterations) {
	if(iterations === null || isNaN(iterations) || iterations < 1) { throw new TypeError(); }

	var begin = (new Date()).getTime();

	for(var i = 0; i < iterations; i++) {
		this();
	}

	var end = (new Date()).getTime();

	return (end - begin) / iterations; // in milliseconds
};

Use it like this:

var example = function() {
	// run some code
};

var benchmark = example.benchmark(100); // run example 100 times

In a nutshell, example is executed 100 times and benchmark contains the average time it took in milliseconds to execute it. Obviously more iterations gives a better average but could potentially crash if the number is too high. For big functions and libraries, I’d recommend starting off low (maybe 100) and then ramping it up but for small functions, you could easily start at up to 10,000 or maybe even 100,000. Make sure there isn’t any code in there that could potentially ruin the benchmarking — particularly alerts.

Remember to take into account slow machines and portable devices, as not every browser and computer will do it at the same speed.

Unfortunately, these images are only 870 pixels wide (the originals range from 5,500 to 8,500 pixels wide).

The thing that I like most about the Windows 7 beta is that it actually works. You can use it as an everyday operating system almost flawlessly. All the hardware worked from out of the box, with the exception of the Ethernet port and the webcam. Just download the XP Ethernet driver from the Asus support website (the webcam is still something I’m figuring out). Perhaps I should note that installing Windows 7 on the 8GB SSD is not a good idea — stick just a few applications on there and you’ll find you’ve got no space left.

Battery life is about 5 hours from a full charge.

Considering the size of this netbook, it is remarkably easy to type on — even easier than most full-size laptops I’ve used. If you read the articles on the internet, though, there are complaints about the right shift key position. Now considering that I didn’t think I even used the right shift key, let me tell it really is atrocious as I keep hitting the up key instead — almost every time. Most of the other keys are well placed (although the Function keys are a little to the left). The trackpad is also good.

The microphone is OK. Considering that I’ll rarely be using it, it doesn’t really matter. And because the microphone is below the screen, typing is very loud.

Unfortunately, most other netbooks are smaller and although they are significantly cheaper, I wouldn’t recommend getting one with a screen of less than 10 inches. You might think £280 is a lot for such a small machine but it’s the portability, the battery and the quality you get — this thing looks absolutely stunning, the white version looks like a little Macbook. When I’ve got the funds, I’ll be modding it with a touch screen and a GPS dongle.

I should stress the importance of a Wind Surfer to help boost your Wifi signal. Mine went from 2 bars to 4 bars and all it took was a few minutes of printing, cutting and sticking.

If I was to own the car for 4 years, say, it would cost me somewhere in the region of £23,000 excluding tax and petrol. I could either buy the insurance or drive around uninsured in a fleet of 7 VW Golfs — one for every day of the week. Which one would you choose?

First thing’s first, the admin pages have seen a big redesign which nicely brings WordPress up to date with trendy drag-and-drop functionality. The new design has a very clean and simple look yet it packs in lots of information, stylishly. It’s not as colourful as 2.6 which worries me in a way as the colours they have used look garish and out of place.

What strikes me most is how integrated WordPress now feels. Once you’ve installed it, you may never need to use FTP again. Plug-in installs and updates can be done within the admin interface — very easily.

Of course, as with many big version overhauls, most plug-ins don’t work and there are quite a few things that I don’t think have been wisely placed. For example, whilst the new navigation strip is a welcome change to the old navigation bar, it is too long and there are quite a few things that I’ll never use. Of course, you can “minimise” it if you wish.

There’s been a big push towards making the interface more customisable and so you are able to remove panes that you don’t like and you can even transform it into a single column display just by dragging the panes into one single column. So in a sense, it feels a lot more like a desktop application.

QuickPress allows you to quickly bash out a post — Twitter–style — and whilst I probably won’t be using it, I can see many who will. Although, with the lack of category selection, its potential is seriously limited.

Added to all these new features, 2.7 also sees a huge number of security fixes and general bug fixes — essentially making this a must-upgrade situation.

Among all the seemingly Web 2.0 traits, 2.7 transforms WordPress into more than just a simple blogging platform. And I dare say that this new version will be one of the major evolutions of WordPress so far.

All the legacy programs like WordPad and Paint have been updated and are now in fitting with the new look of Windows. Notably, the calculator has received a large upgrade and it boasts features like conversions, a mortgage calculator and a gas mileage calculator. What previously took a few Google searches and a long-winded Excel spreadsheet can now be done with a few clicks.

Everything just seems to integrate better with Windows 7 as well: changing wireless networks just takes two clicks, the sidebar is no more but the gadgets can roam the desktop and things like Aero Shake suggest (nice but potentially annoying) Compiz Fusion–like effects.

Performance seems to be a lot better than Vista too: everything from shorter boot times to longer laptop battery life seems to be the way that Windows 7 is going. As Vista seemed sluggish compared to its predecessors, I’m excited that Microsoft have turned it back around. It can even run with a mere 1GB of RAM although considering memory is dirt-cheap nowadays, there needn’t be a tiff if it were to require more.

The taskbar has also been hugely redesigned and while I’m not too hot on it at the moment, I’m sure it’ll all fall into place in time. Essentially, the new taskbar makes better use of the space and takes the preview window to the next level.

There’s also promise that Windows 7, from day one, will be more stable than Vista SP1. Whilst I’m not so sure myself, as every new operating system faces numerous bugs, I’m fairly confident that Windows 7 will be a strong OS that should see us through for a good few years.

Oh! How could I forget that they’ve redesigned UAC to be insanely less intrusive? You may be able keep it enabled without losing your insanity. Individual applications can be allowed forever and you can also change the ferocity of UAC, presumably inside the depths of the Control Panel.

All in all, Windows 7 has shaped up to be what could be the best operating system the world has seen. I’m interested in what developments other operating systems will see as Windows 7 nears its launch in mid 2009.

It’s also given me a chance to play about with Ubuntu 8.10. Since the release of Ubuntu 8.04, I’ve been set on 8.10 being the definitive version and whilst it does feel a bit stronger and more capable than 8.04, I’m not so sure that it is what I had hoped. The UI is still ugly and OpenOffice is still lacklustre compared to the likes of Microsoft Office. In a nutshell, it needs to take a big step towards Windows in order for it to be a viable option for regular consumers. It is, however, definitively ready as a home server and I’ll definitively be incorporating it into a project. Details to follow…

I ordered a new heatsink (Akasa AK-965) and today I attempted to install it. Of course, uninstalling the old one was difficult and there’s always that little niggle that makes you think you’re doing it wrong. I continued, though, and managed to vacuum the incredible amount of dust that had amounted over the 2 years.

I was in the final throes of completion, I only had to place the new heatsink into its place, pop the screws and plug the fan in. Of course, in the final stages, something has to go wrong and for this little endeavour, everything did. First, I found that the heatsink didn’t line up the motherboard’s holes. Secondly, I found that the motherboard didn’t have a connection for the heatsink’s fan (rather, a different connection to what the new heatsink needed). Thirdly, I’d already taken all the old thermal paste off the processor at this point and it looked like I’d need to buy some more. And finally, no matter how hard I tried to be careful, I managed to get thermal paste all over my fingers. Sending back the heatsink will cost £5 — for a £10 product. To finish off, as I’ve had to dismantle half my computer, I’ve now got two screws and I don’t know where they went.

It’s not all bad though: I’ve managed to scrape some of the new thermal paste onto the old heatsink (and temperatures have fallen dramatically), I’ve been able to clean the fan and heatsink and I have a spare heatsink for a computer I hope to be building this autumn.

At least the Jag was in the drive, though.

I’ve now had a few months to adjust to AAC and I’ve had no hiccups at all. I’ve compressed my entire collection to 96kbps (variable) AAC and can’t distinguish it between CD quality. Of course, you may not have the same experience as me and I heavily recommend that you do a bit of ABX testing before you commit to any compression.

I recommend anyone who listens to their music collection on devices that do support AAC, to convert their collection to AAC.

Despite being only officially available to the Japanese market, I’ve seen several of these in England. It’s about as aerodynamic as a small village and is just devastatingly ugly.

You can use choose between a 1.4 litre or a 1.5 litre I4 engine — the 1.4 litre has a huge 84 horsepower.

The most positive thing that struck me about this car was what the size of the boot would be. Sadly, looking at it more closely, all that space is taken up by a second row of chairs.

To sum up: it has a poor engine, a tiny boot, ugly exterior, ugly interior and an import tax. Really?

var preloadImage = function(url, callback) {
	var image = new Image();
	image.src = url;
	image.onload = image.onabort = image.onerror = callback;
	return image;
};

Just specify the URL (url) and the callback function (callback) as so:

var callback = function(e) {
	alert(e.type);
};

var image = preloadImage('http://www.sidroberts.co.uk/image.gif', callback);

On the load event, the abort event or the error event, the callback function will be executed. You can distinguish these with the type property which is "load", "abort" and "error" respectively.

Now any image that points to that URL will load almost instantly.

Instead of dragging every single image into each slide, go to Insert in the ribbon and click the Photo Album icon. There you can select the images you want, order them and decide how many you want on each slide. It will make a new presentation with all these new slides so you will have to copy the slides back into the original presentation if you want them there.

First thoughts are very promising. You need to be a fairly active member of Digg to keep the recommendations relevant, I should add — it grows in strength with stories you Digg. If the compatibility between you and other users is low, then chances are you’ll get poor results. For me, though, most recommendations were fairly accurate. My compatibility percentages were between 7 % and 13%.

For somebody who rarely uses the Upcoming feature, this brings a welcome change and I’ve already Dugg many stories that I probably wouldn’t have seen otherwise. When the feature hits mainstream, I dare say it’ll be used heavily and the recommendations will be very accurate.

RegExp.prototype.modifiers = function() {
	return /^\/(.+)\/([gim]+?)$/i.exec(this.toString())[2].split('');
};

Don’t say I didn’t warn you.

In short, that method converts the expression to a string and then executes another regular expression with it. This new regular expression takes away the main pattern and leaves the modifiers in a string. That string is then split into individual characters so you have an array of them (for example: ['g', 'i']).

This magic regular expression can also be used for extracting a pattern, which, in turn, allows you to rebuild it with the RegExp constructor — modifiers included. This is the method for extracting the pattern:

RegExp.prototype.pattern = function() {
	return /^\/(.+)\/([gim]+?)$/i.exec(this.toString())[1];
};

Rebuilding it is as simple as this:

var original = /\s+/g;

var pattern = original.pattern();
var modifiers = original.modifiers().join('');

var better = new RegExp(pattern, modifiers);

So, putting two and two together, if we can extract the pattern and the modifiers, and rebuild it, what’s stopping us from changing it along the way? Enter addModifiers and removeModifiers:

RegExp.prototype.addModifiers = function(modifiers) {
	return new RegExp(this.pattern(), this.modifiers().join('') + modifiers.join(''));
};

RegExp.prototype.removeModifiers = function(modifiers) {
	return new RegExp(this.pattern(), this.modifiers().join('').replace(new RegExp(modifiers.join('|'), 'i'), ''));
};

With the addModifiers method, you may have noticed that I haven’t bothered to check for the existing modifiers. This is because you can duplicate a modifier on a regular expression and it won’t matter as it’ll only be counted once. Both of these methods allow multiple modifiers and require them to be an array (['g', 'i']):

var original = /\s+/g;

original = original.addModifiers(['i']); // /\s+/gi
original = original.removeModifiers(['g']); // /\s+/i

pattern = original.pattern(); // '\s+'
modifiers = original.modifiers(); ['i']

For images that you know the width and height of, you can set the dimensions so that the image is not distorted:

img.widescreen {
	width: 16em;
	height: 9em;
}

For unknown image sizes, one side must be set to auto — this will force the correct aspect ratio upon the image, avoiding any skewness:

img.scale {
	height: auto;
	width: 75%;
}

Scaling images are great because you can prevent them from ruining your layout by going over an edge. If they are set in percentages and have limitations, it also means that they won’t go larger than the boundaries of the page and still remain undistorted, even when the browser is resized:

img.scale {
	height: auto;
	max-width: 100%;
	width: 30em;
}

Using the max-width/max-height property, you can also prevent everyday images from ruining your layout as well.

Computers count in base two – that is, binary. In binary, a kilobyte is 1024 bytes (2 to the power of 10). Normal people considered a “kilo” to mean a thousand so a kilobyte, to them, was 1000 bytes. If you sell hard drives, the obvious choice is to use the measurement that sounds like more value – the non-geek 1000 was therefore used (1MB = 1,048,576 bytes in binary or 1,000,000 bytes in metric – less is cheaper to make although less in usable capacity). In 1998, the IEC defined 1GB as 1,000,000,000 bytes – using the non-geek/manufacturer method. To avoid confusion, they also decided to rename measurements of binary by replacing the last two letters with “bi” to represent “binary” (kibibytes, mebibytes, gibibytes, tebibytes). The thing is, though, these new names sound terrible and they will never be picked up. In reality, everyone uses the original names and ignores the stated capacities on hard drives.

If you’re mathematically inclined, you’ll notice that the difference is 7%; to find out the real capacity of any hard drive, just take off 7%.

There can be good things said about the wide compatibility of iPods that it can connect to and the ability to still use the headphone jack whilst transmitting is an added bonus. However, if you appreciate music (and by that, I mean listen), you should avoid it completely.