First of all, are you dealing with a stripped screw or a broken one? A stripped screw is where the slots in the head have become worn and rounded so that the screwdriver can’t grip it and looks like this:

A broken screw is one where the head has sheared off, and looks like this:

If you have a broken screw then the techniques for dealing with a stripped screw won’t help you, so click here to jump down to the methods for broken screws. On the other hand, if you have a stripped screw, then you can use any of the techniques on this page so just start reading.

Methods for stripped screws

These mostly involve ways to improve the amount of grip that you can get on the screw head with a screwdriver. They often work well in combination – try heating the screw to loosen it, followed by using the rubber band trick.

Tap or heat the screw to loosen it

The idea here is to loosen the screw so that you can use what little grip remains in the head to unscrew it. Tapping can help to free a seized screw, while heating a metal screw can loosen it by making the metal expand then contract. To loosen the screw by tapping, place the tip of a screwdriver in the screw head (as if you were going to turn it) then tap the butt of the screwdriver with a hammer. To loosen it by heating, place the tip of a hot soldering iron in the screw head and press down for a few seconds.

Drill a small hole in the centre of the screw

By drilling a hole just a couple of millimetres deep in the middle of the screw head, you can allow the tip of your screwdriver to go deeper in the head and get a little bit more grip. Use a very small drill bit that will work on metal. A Dremel is perfect for this job, using a drill bit like this one.

Use a rubber band to get more grip

This one is simple; just place a rubber band over the screw head and unscrew it normally. The rubber can help to give just enough extra grip to get the screw to turn.

Use aluminum carbide or valve grinding paste

The idea here is the same as above – give the screwdriver a little more grip on the screw head. Just spread a little of the paste into the slots in the screw head and unscrew as normal.

Use a hammer to reshape the slots in the screw head

An unsophisticated trick Seat the tip of a screwdriver in the screw head and whack the base of the screwdriver with a hammer. This is only likely to work on screws made out of soft metal (but hey, maybe that’s the reason they get stripped in the first place!)

Use a flat-head screwdriver on a cross-head screw

Sometimes a flat-head screwdriver can get a better grip on a stripped cross-head screw than the correct screwdriver can get, due to the way that cross-head screws are designed to “cam-out”. Use plenty of pressure to keep the screwdriver seated.

Use a screwdriver bit that’s too big

Very similar to the trick above. Instead of using a flat-head screwdriver, use a cross-head screwdriver, but pick a size that’s too big for the screw. If the slots have been worn, this can often give a better grip than using the correct size.

Use a steel punch to hit the screw off-center

This is only likely to work on screws that have a large head. Take a small hardened steel punch and use it to hit the screw off-centre so that it rotates anti-clockwise. This sometimes works to start a screw moving; as soon as it’s loosened, move on to one of the other methods.

Methods for broken screws

Grip the screw with a pair of pliers and turn it

If the screw isn’t secured too tightly, and there’s enough of it protruding, you may be able to get enough purchase with a normal pair of pliers to remove it. Be sure to clamp the screw in the sample place with the pliers each time you grip it so you don’t round off the screw.

Of course, the more leverage you can get to grip the screw with the better, so if you’ve got a pair of pliers with long handles and an adjustable jaw like these ones, then use them.

And if you are lucky enough to have a pair of locking pliers (AKA vise grips, vice grips, or mole grips, depending on where you live) then you can use them to apply much more pressure and to clamp down on the screw while you turn it.

Clamp the screw shaft in a drill chuck and turn slowly

The chuck of a drill is designed to hold the shaft of a drill bit securely, so it often also does a pretty good job of holding the shaft of a broken screw. Tighten up the chuck of the drill as hard as you can around the screw – you will need both hands for this so get someone to help by holding the drill in place as you do it. Don’t plug the drill in until you’ve finished clamping the screw, and make sure it’s in reverse  before you turn it on. Any cheap drill should work for this, or you can also use an electric screwdriver if it has a chuck. Don’t try this trick with a rotary tool like a Dremel – they are designed for high-speed, low-torque so will be useless (but if you have a Dremel, see the next method!)

Use a Dremel to cut a slot in the screw

If there is enough of the screw protruding above the surface it’s screwed into, you can use a Dremel or other rotary tool with a cut-off bit to cut a slot directly into the shaft, which you can then unscrew with a flat-head screwdriver. Use this type of cutting wheel and make the cut as straight as you can.

If there is plenty of shaft visible, then you can do the same with a hacksaw, but it’s much trickier – you’ll need a very narrow blade and a steady hand.

Use epoxy to glue a nut onto the end

Two-part epoxy glue forms an incredibly strong bond, so you can use it to glue something onto the end of the screw that will give you enough grip to turn it. Use a type of epoxy designed for metal – J-B Weld is the strongest:

Weld a nut onto the end of the screw

Use a screw extractor

This is bottom of the list because it involves buying a special bit of equipment – a screw extractor set. However, it really belongs at the top because it is the quickest, most reliable solution.  Screw extractors have a left-handed thread, which means that you put your drill into reverse and then start drilling into the broken screw. When the extractor has embedded itself in the screw, the left-hand rotation will neatly unscrew it. If you’re going to the trouble of buying a screw extractor, then you might as well buy a set, because (1) you won’t have to try to guess which size you need and (2) you’ll have the correct tool on hand the next time you encounter a broken screw!

If you have a trick that’s not mentioned here, let me know in the comments and I’ll update this post!

I definitely wanted to make sure that my Roomba could fit underneath the new sofas – I have three dogs and hardwood floors, so hair will inevitably gather if it’s not being picked up. I started looking at chair raisers – there are some very nice hardwood ones available – but quickly realised that there were two problems. Firstly, I would need three sets, which would set me back the best part of $100. Secondly, there’s no way to adjust the height – I wanted to raise my sofas and chairs up by only the minimum amount necessary. So I decided to make my own.

Design

The basic plan is to use a hole saw to cut a bunch of circular wooden disks out of cheap timber planks, and then stack the disks together until they’re the right height. Then, to securely hold the legs of the sofa, you’ll cut a final disk with a cut-out section in the middle where the sofa leg will go. A photo of the rough finished product should make things clearer:

This one was made from 3/4 inch (18mm) planed timber, and I used three layers to give a total height of  2¼ inches (54mm). The top layer was made from the same piece of wood, but doesn’t contribute to the height of the sofa – the sofa leg just sits in the round depression so that it’s held securely. This is the rough version – if you’re going to be able to see the leg raisers, you could sand the outside and stain or paint for a nicer finish.

Construction

The trick to cutting out these perfectly circular disks of wood is to use a hole saw -  a circular blade that fits into a normal drill and cuts round holes.

For this project we need to cut two sizes of hole – a big one for the main layers, and a smaller one for the sofa/chair leg to fit into. Rather than buying two individual saws, it’s cheaper to buy a set that contains a range of sizes. This set will do the job perfectly and contains a range of sizes which will be useful for other projects. You’ll also need an electric drill and some smooth planed timber – try to get a plank that’s 3/4 inches thick and about 5 inches wide.

Now, on to the cutting. Disclaimer: power tools are dangerous – take care!

If you look at your hole saw, you’ll see that the central drill bit protrudes a bit beyond the cutting saw part. The trick to cutting nice neat holes is to drill through your wood until the central bit emerges on the other side, but before the saw part has cut all the way through. Then, turn the wood over and finish off the cut from the other side, using the central hole to make sure that you’re cutting in exactly the same place. If you just cut all the way through from one side, then you’ll get a load of splinters where the saw breaks through the wood. Most hole saws have a small hole in the back that you can use to poke out the circular disk if it is stuck – do this gently, as you don’t want to dent the wood.

While you’re cutting, watch out for any sign of overheating, like smoke. The friction between the saw and the wood can cause it to get very hot. Also, be careful not to touch the blade immediately after you’ve finished a cut as it will probably be hot. A hole saw generates a large amount of sawdust – much more than normal drilling – so make sure you do it somewhere that will be easy to clean up.

The easiest way to figure how how many layers you need is by trial and error. Cut out four disks using the largest hole saw in your set, and put them underneath the four legs of your sofa. If it’s still not high enough, cut another four and repeat. Be careful, because at this stage there is nothing holding the disks together, so they could easily slip.

Once you’ve got enough layers to raise your sofa to the right height, cut one more set of disks for the top layer that will hold the legs. Now comes the clever bit – we will use a hole saw to cut another disk from inside the first one, leaving us with a ring-shaped bit of wood that will hold the leg securely. The trick to this is to cut the inner hole just big enough to hold the existing sofa leg, so measure it and pick the hole saw from your set that is just big enough to fit. If your existing sofa leg is round, then just measure across it; if it is square then measure on the diagonal. If the size is in between two of your hole saws, then pick the smaller one and enlarge the inner hole after glueing. Use the drill bit hole in the centre of your wooden disk to make sure that you drill the inner hole in the exact middle. You’ll probably want to clamp the wooden disk when drilling it, as there might not be much clearance between the edges of the disk and the hole that you’re drilling.

When all the drilling is done, you’ll be left with a stack of wooden disks (3 in my case) and a wooden ring for each leg. Assemble each raiser by glueing the bottom of each disk to the top of the one below it, and glueing the bottom of the ring to the top of the uppermost disk (take a look back at the photo above to see what I mean).  Because you’ve made the disks from planed wood, the tops and bottoms should be perfectly flat and easy to glue. And because you’ve used a hole saw to make the disks they should all be exactly the same diameter, so it should be easy to get them to line up.

Once the glue has dried, it’s time to check that the sofa legs fit into the depressions on the top of each raiser. If you’ve cut the holes slightly too small, then the best way to enlarge them slightly is with a rotary tool like a Dremel with a drum sander.

You could also use a round file or a piece of sandpaper, but it will take quite a lot longer! If necessary, you can tap the bottom of the raisers with a mallet to get them seated securely on the sofa legs – the slight friction between the leg and the wood will help to hold them on securely.

Finally, finish the raisers however you like. I simply sanded the outside to a nice smooth finish, but if the raisers are going to be on display, then you could stain or paint them to match the rest of your furniture.

Historically, sound has always been a weak point for Linux, with many devices refusing to work due to a lack of drivers. The appearance of Ubuntu improved matters, but I have always found support for high-quality audio to be lacking. However, the development of USB sound cards has made a big difference and I have finally found a way to get high-quality audio on Ubuntu on a budget. The set up I’m about to describe will give you fantastic, detailed sound for music listening for around $200.  Briefly, the recipe is

1. use an external USB soundcard

2. get a line-out signal from the soundcard and

3. use active monitor speakers, NOT multimedia speakers

The sound card

There are two main reasons to use a USB sound card. Firstly it means that the digital-to-analog conversion is taking place outside the computer, where it can’t be affected by all the electrical noise inside. Secondly, the quality of the conversion (which will ultimately determine the quality of the sound) is far better than can be achieved by your computer’s built-in sound card.

The best low-cost USB audio device I have found is the FIIO E7, which you should be able to pick up for around $80.

It’s actually designed and marketed as a headphone amplifier, but it’s perfect for our purposes because it’s actually a high-quality USB soundcard as well. It is recognized by Ubuntu as a USB audio device so it doesn’t need any drivers and will work out of the box.

The line-out signal

Because the E7 is designed to drive headphones, you can’t take the output and use it to drive a pair of speakers. Instead you need to get a line-out signal which you can feed to an amplifier. There are two products that let you get a line out signal from the E7 – a rather cool looking separate headphone amp, and a line out dock.

The headphone amp looks extremely cool, but will set you back another hundred bucks and take up a chunk of space on your desk.  The line out kit (called the L7), on the other hand, costs ten bucks and does the job perfectly.

It clips to the bottom of the E7, then you plug a USB cable in one side, and get a line out signal from the other side. This will allow us to use the DAC part of the E7 while bypassing the amplifier part.

Active monitors

Now you have your line-out signal you need a amplifier and a pair of speakers. The best value solution is a pair of active speakers (also called powered speakers); these have an integrated amplifier so you can connect them directly to a line out source. Active speakers come in two main flavours. Multimedia speakers are designed for computer games and movies, so they tend to be loud and dynamic, but are lacking in detail for music. A much better choice is a set of monitor speakers; these are specifically designed to accurately reproduce music and are often used for recording and mixing.

M-audio make a few models of budget speakers that are ideal for our purposes. I am currently using a pair of AV40 speakers . They are nicely sized, comfortably loud enough to fill a large room and have wonderful sound reproduction.

If you need something smaller there’s a very similar model with slightly less power which will take up less room. Alternatively, if you want to go larger, the next step up would be the Bx5A, which has a slightly bigger speaker – handy if you listen to a lot of bass-heavy music – but comes at a hefty price.

Setting up

Hooking up a system like the one I’ve described above is very simple. The L7 plus into the bottom of the E7, then the USB cable runs from the L7 to your computer. The line out cable runs from the other side of the L7 to the active speakers. Be sure to arrange your speakers for best sound from your normal listening position – follow a guide like this one and you can’t go wrong.

A set up like this should keep you happy for a long time; the only thing I have found I needed to upgrade is the line out cable which goes between the L7 and the speakers. The supplied one is a little loose, but even a high-quality gold-plated, shielded cable is only about $10, will sound great, and will last practically forever.

• Recursive subroutines
• big-O notation
• passing functions around as variables
• building functions using higher-order programming

Anyway, I thought that the example used to illustrate higher-order programming was pretty cool, so I decided to see if I could implement it in Groovy. The example involves writing a function to calculate the square root of a number using the Babylonian method - start with a guess and repeatedly average the guess with the number divided by the guess, until the answer is close enough.

Here it is in Groovy:

def abs(x){
    if (x < 0)
        -x
    else
         x
} 

def sqrt2(guess){
    println "guess is $guess"
    def difference = abs((guess * guess) - 2)
    if (difference < 0.001){
        return guess
    }
    else{
        def new_guess = ((2 / guess) + guess) / 2
        return sqrt2(new_guess)
    }
}

sqrt2(1)

and the output:

guess is 1
guess is 1.5
guess is 1.41666666665
guess is 1.414215686275

I’ve defined an abs() closure because the built-in .abs() method complains about different types of numbers. The sqrt2 method itself is easy to read – given a guess, calculate how far off it is by squaring it, and either return the guess (it it’s close enough) or use the averaging procedure to make a new guess and call sqrt2() again. We could make it a bit more concise by leaving off the explicit return statements – a Groovy method returns the value of the last expression that was evaluated, so we don’t really need them (this is what I’ve done with my abs() method). Note that when we call the method in the last line, we have to supply it with an initial guess.

The first step in abstraction is pretty obvious – let’s do away with the hard-coded 2 and let the method take the number for which we want to take the square root as an argument.

def sqrt_iter(x, guess){
    println "guess is $guess"
    def difference = abs((guess * guess) - x)
    if (difference < 0.001){
         guess
    } else {
         def new_guess = ((x / guess) + guess) / 2
         sqrt_iter(x, new_guess)
    }
}

def sqrt = { x ->
    sqrt_iter(x, 1)
}
sqrt(5)

To make things a a little more convenient I’ve moved the iterative code to a closure called sqrt_iter; the job of sqrt now is just to supply the initial guess. Now we can ask for the square root of exotic numbers like five:

guess is 1
guess is 3
guess is 2.33333333335
guess is 2.238095238095
guess is 2.2360688956435

Up to this point there’s no higher-order programming going on. But now it starts to get interesting; we can extract the bits of code that are responsible for checking if the answer is good enough and for generating the next guess:

def improve(x, guess){
    ((x / guess) + guess) / 2
}

def goodEnough(x, guess){
    def difference = abs((guess * guess) - x)
    difference < 0.001
}

def sqrt_iter(x, guess){
    println "guess is $guess"
   if (goodEnough(x, guess)){
        guess
    }
    else{
        def new_guess = improve(x, guess)
        sqrt_iter(x, new_guess)
    }
}

def sqrt(x){
    sqrt_iter(x, 1)
}
sqrt(5)

Now, what we are left with in sqrt_iter is a generic procedure for solving a problem by generating successively better guesses until we get close enough. We can make this abstraction explicit by turning our improve / good enough methods into closures and having them as arguments to the main iteration method:

sqrt_improve = { x, guess ->
    ((x / guess) + guess) / 2
}

sqrt_goodEnough = { x, guess ->
    def difference = abs((guess * guess) - x)
    difference < 0.001
}

def generic_iter(goodEnough, improve, x, guess){
    println "guess is $guess"
    if (goodEnough(x, guess)){
        guess
    }
    else{
        def new_guess = improve(x, guess)
        generic_iter(goodEnough, improve, x, new_guess)
    }
}

def sqrt(x){
    generic_iter(sqrt_goodEnough, sqrt_improve, x, 1)
}
sqrt(5)

I’ve changed the names of the closures to make things clearer. sqrt_improve and sqrt_goodEnough are the particular type of improve and goodEnough routines that are for solving square roots. Our iteration routine is now a generic one that take four arguments – a closure that can tell if a guess is good enough; a closure that can improve an existing guess, a number for which we’re trying to find the answer, and a guess. Note that the generic_iter method now contains absolutely no logic to do with calculating square roots – it is completely generic. We can use it to solve any problem which we can express in terms of a way of checking if a guess is good enough, and a way of improving a guess.

Here’s a completely brain-dead example; using the generic_iter method to solve the problem of finding the smallest integer that is bigger than a given number:

biggerThan_improve = {x, guess ->
    guess + 1
}

biggerThan_goodEnough = {x, guess ->
    guess > x
}

def biggerThan(x){
    generic_iter(biggerThan_goodEnough, biggerThan_improve, x, 0)
}

biggerThan(5)

The improve closure just increments the guess by one; the good enough closure just checks whether the guess is bigger than the target number. The output is not particularly surprising:

guess is 0
guess is 1
guess is 2
guess is 3
guess is 4
guess is 5
guess is 6

One final point: because we can return closures as values from methods in Groovy, we can redefine generic_iter so that rather than executing the iteration procedure, it returns it. So we can assign the result to another variable and use it later on:

def generic_iter(goodEnough, improve){
    def returnClosure
    returnClosure =  { x, guess ->
        println "guess is $guess"
        if (goodEnough(x, guess)){
            guess
        }
        else{
            def new_guess = improve(x, guess)
            returnClosure(x, new_guess)
        }
    }
}

def sqrt = generic_iter(sqrt_goodEnough, sqrt_improve)

sqrt(5, 1)

Note that here we have to define returnClosure before we assign a value to it, because we want to refer to it inside the closure body. generic_iter now takes only two arguments – the two closures that will do the work – because its job is not to actually carry out the calculation, but to build the routine that will.

I moved a WordPress blog from one server to another which was running lighttpd with a blanket 301 redirect to from www to non-www URLs. When I fired up a browser to test it, I got the dreaded “this website is responding in a way that will never resolve” message. A quick look at the lighttpd logs confirmed that I was bouncing from www.example.com to example.com then back to www.example.com.

I expected the first redirect but not the second, and checking in my lighttpd conf showed no rule that could possibly be triggering it. Thinking maybe I had left a redirection plugin running, I logged on the blog (by temporarily disabling the redirect rules) and checked, but couldn’t find anything.

Turns out that WordPress itself is capable of generating 301 redirects according to the “Blog URL” field in the General settings page. If the URL is set to http://www.example.com and a request comes in for http://example.com/some/page, then WordPress will automatically respond with a 301 redirect to http://www.example.com/some/page (which in my case, would get caught by my lighttpd rule and bounced back to the original request URL, and so on).

Moral of the story: make sure that your WordPress URL settings and any manual redirection you are carrying out are in agreement as to what the ‘correct’ URL should be!

image credit: wikipedia

However, they can also be difficult to read and so a reader’s interpretation of them can be easily affected by the way in which they’re drawn. Take a look at this evolutionary tree, showing the evolutionary relationships between several different animals.

This is a pretty uncontroversial tree; you’d have difficulty finding any biologist who would disagree with it. On this tree, evolution moves from left to right and each horizontal branch defines a group of animals to the right of it. All the animals to the right of a given branch are more closely related to each other than they are to any of the other animals. For instance, the branch that I’ve marked with a red star defines a group that includes houseflies, horseflies and dung beetles. That branch tells us that these three animals are more closely related to each other than they are to any of the other animals in the tree.

Now if we wanted to tell a particular story with this tree, how could we change the presentation without changing what the tree actually says? One thing that we can do is remove animals from the tree. Doing this doesn’t change the relationships that are shown – it just means that some relationships are left out. Here’s the original tree with some of the animals in grey:

And here’s the tree we get when we leave those animals out. It’s completely in agreement with the first – but it tells a rather different story:

Look familiar? This is the “humans are the pinnacle of evolution” tree that’s often found in biology textbooks. Although all the relationships depicted in it are correct, by choosing to display only animals that are progressively more distant from humans we’ve set it up so that it looks like humans are the endpoint of evolution, and all other species are just steps along the way. If we want to make this point even stronger, we can redraw it using slanted lines:

So now we have a straight line from the origin of life to humans, with other species as mere offshoots. The ultimate misleading version of the tree has the species names arranged diagonally, so as to give the impression that other species are somehow “less evolved” than humans (by virtue of being not as far to the right).

Remember that this tree shows exactly the same relationships as the one we started with. To show how misleading it is, let’s go back to our original tree and pick a different set of species to show:

After removing the species in grey, we are left with this:

Which we can rearrange by moving the human down the list. This doesn’t alter the relationships, just the order in which we read the species names. The resulting tree, again, is in complete agreement with our original one, and shows a steady evolutionary progression towards houseflies!

Adding in our layout tricks completes the picture:

For comparison, here’s the human-centric tree, housefly-centric tree, and original tree side by side.

Remember, the trees to the left and right don’t include any relationships that are not also present in the one in the middle. The fact that they can tell such different stories about evolution is a reflection of the difficulties involved in interpreting evolutionary trees. They are to be viewed with caution.

Another trait that has evolved multiple times is powered flight. We know that there are four groups of organisms that can fly – birds, bats, insects, and (extinct) pterosaurs. And we know that each of these groups evolved flight independently because, in each case, the most closely-related group cannot fly. For example, bats are most closely related to carnivores like dogs and cats than they are to any other flying animal. (The situation with birds is slightly more complex because their closest relatives are all extinct, but the principal is the same). We can be pretty confident that powered flight evolved independently four times.

This seems on the low side; after all, many traits that sound just as complicated have evolved much more often than that – sophisticated eyes, complex social living arrangements (as seen in bees) and multicellularity have all been estimated to have arisen independently at least a dozen times. You might expect that something like flying, which offers such obvious benefits – escaping from predators; access to food; being able to migrate long distances – would have evolved many times as well. So why is it so uncommon? Perhaps it requires a degree of specialization that is rarely justified by the benefits it confers. Perhaps it requires a very unusual set of anatomical adaptations to happen simultaneously – this idea is given credence by the fact that gliding, as opposed to powered flight, has evolved independently many times. Maybe gliding offers enough of the benefits of flying, without the need for radical specialization, that it is more adaptive for the majority of animals.

Of course, perhaps it only seems rare to us because of our land-bound nature – flying seems like a big deal because we can’t do it. Let’s forget flying for a moment; how many times has walking evolved? I’m going to rule out animals like tardigrades, that live in tiny films of water – they don’t count. Neither do annelid worms; some of them have leg-like protuberances, but they still move by wiggling. By my count, walking has evolved independently just three times in the history of life – in arthropods (like insects and crustaceans), tetrapods (like humans and crocodiles) and velvet-worms (rather than try to describe them, here’s a wikipedia link). In fact, it seems likely that velvet-worms and arthropods form a closely-related group, which means that walking has evolved independently just twice. So as per the title of this post walking is, from an evolutionary point of view, twice as difficult as flying!

There is one biological law, however, that shares the elegance of these equations. It comes from the field of theoretical population genetics, and concerns a scenario where a species is split into two populations. Imagine a species of lizard that is found only on a single island. The island has a mountain range running from north to south down its centre. The mountains make it difficult for the lizards to cross from one side of the island to the other, effectively splitting them into two populations.

Our question involves the long-term fate of these two populations. We know that two isolated populations will tend to diverge from one another by a process known as genetic drift. This occurs because random variations in the frequencies of genes cause differences between the two populations to accumulate over time. But exactly what degree of isolation is necessary for this to happen?

One way to answer this question is to look at the frequency with which individuals move from one population to the other (from the east side of the island to the west, or vice versa). It’s obvious that if no individuals ever cross over, then the two populations are completely isolated and they will diverge. It’s equally obvious that if individuals can cross the mountain range easily, then there will be lots of migration between the two populations and they will not diverge. But what is the amount of migration at which the two populations switch from staying the same to diverging?

Intriguingly, the answer (given a large number of simplifying assumptions) turns out to be one individual per generation, in each direction. In other words, if fewer than one individual moves from each population to the other in every generation, the two populations will diverge due to genetic drift; if more than one individual moves, they won’t.

The reason why this answer of one-per-generation is surprising is that it doesn’t depend on the size of the populations. One migrant per generation is sufficient to stop the populations from drifting apart regardless of whether there are ten lizards or ten thousand. This seems counter-intuitive; we would expect a single individual to have a much greater impact on a small population than a large one. You would think that the genetic contribution of an individual would be swallowed up in a large population, swamped by the much larger number of genes that are already in it.

However, this effect is balanced out by another factor; genetic drift affects large populations much less than small ones. The explanation for this is beyond the scope of this article, but it stems from the fact that certain types of random events are more common in small populations. Genetic differences between populations are fixed by a process akin to flipping coins, so just as you have more chance of getting all heads when you flip five coins (1/32) than ten coins (1/1024), drift has a higher chance of occurring in a small population than a big one.

The reason why the one-per-generation rule holds, and the reason why it is so interesting, is that these two effects exactly cancel each other out. The simplified assumptions on which the rule depends are unlikely to be found in real-world populations, but nevertheless it’s an important and elegant contribution to the field of genetics.

The things we learn by studying Drosophila can hopefully be applied to animals that are of more practical importance, such as disease vectors, livestock, and, of course, humans. The last item on that list usually jumps out at us and makes us wonder: just how much we can learn about humans by studying flies? Surely humans and flies are completely different animals!

Well, as with many things in biology, it all depends on how closely you look. Let’s start with the obvious picture that springs to mind – human on the left, fly on the right.

At first glance, we’ll be hard pressed to pick out any similarity between the two. They’re both bilaterally symmetrical (i.e. the left and right sides are the same), and they both have a head at one end with eyes and a mouth, but that’s about as far as we can go. In this view, the differences are far more obvious – absence of wings in the human, and an abundance of legs in the fly, not to mention the vast difference in size – in real life, the fly is about a thousand times shorter than the human.

Let’s take a closer look. Here are pictures showing the internal organs in humans:

And flies:

The labels aren’t important here; what is important is that we can pick out a few more similarities. In particular, the number and placement of organs is quite similar – both have

• a brain at the front
• a mouth
• a gut running the length of the body
• a bundle of nervous tissue running the length of the body
• an ovary (in females) to produce eggs

There’s still a vast disparity in size however, and many of the organs, although they share the same name, look nothing alike. Let’s zoom in again, and look at the tissue that these organs are made of. Here’s a picture of nerve cells from a human:

image credit: wikipedia

and nerve cells from Drosophila:

image credit: Melissa Rolls Lab, Penn State University

Ignore the colours (they are not important) and take a look at the structure. The cells seem more densely packed in the upper picture, but the cells themselves are pretty similar. Additionally, the size difference has gone – the human cells and the Drosophila cells are about the same size.

As we look in more and more detail, the similarities between humans and flies become more and more apparent, especially when we start looking at genetic information. For example, here’s a comparison of the DNA sequences for a particular protein found in humans and Drosophila:

The exact nature of the protein is not important (it’s a thioredoxin, a type of protein that plays a role in redox reactions) and neither are the sequences themselves. What is important to notice is that the asterisks underneath the sequences show sections where the two sequences are identical – quite a large proportion. If we look at the protein sequence for the same molecule the similarity is even more striking:

There are fewer positions where the two sequences differ, and even these are filled with amino acids with similar properties (shown by the . and : symbols). Let’s look at the protein itself; here’s an image showing the three-dimensional structure of the human and Drosophila proteins superimposed:

image credit: wikipedia

As you can see, they line up pretty well in most places – you can see the divergence best in the spiral section on the right.

Finally, let’s look at a complete chemical pathway. Here’s a diagram showing the citric acid cycle (a set of chemical reactions that generates energy from food) in humans:

and in Drosophila:

As you can see, they’re exactly the same. In fact, just to show how similar living things are when you look in this level of detail, here’s the same image for rice:

Exactly the same again, despite the fact that rice has been evolving separately from humans and flies for about one and a half billion years!

So the answer to the question of whether or not humans and flies are similar depends on how you look at them. When you look in enough detail, all animals (and to a certain extent, all living things) are very similar – reassuring us that we can indeed apply knowledge about one animal to another.

This idea has had a controversial history when applied to humans, for a number of reasons. It’s been proposed to apply not only to easily measurable traits like height and weight, but also more nebulous ones like intelligence and criminal behaviour and has been used to justify some outrageously sexist viewpoints. Unfortunately, there has been much less debate about increased male variability in non-human animals. However, thinking about the possible mechanisms of variability reveals an interesting quirk of natural selection that suggests how it might come about.

Imagine the following thought experiment: every day I go to a casino and bet $1 on a single game of roulette. Now, the interesting thing about roulette is that there are a number of different types of bet I can make, with different probabilities of winning and different payouts. To keep things simple, lets assume that I can either make a red-or-black bet (where I try to guess the colour that the ball will land on), or a straight-up bet (where I try to guess the number). We’ll also ignore the ‘house edge’ and assume that for each bet, the payout is inversely proportional to the odds of winning. Lets look at what happens when we try each type of bet.

(Note: for clarity I am using the word “payout” here to refer to the total amount of money I get back after each bet; i.e. including the initial $1. I don’t think that’s how the word is normally used in casinos, but it makes the argument easier to follow.)

If I bet red-or-black, the chances of winning are 1/2 (for the purposes of this example, there are only two colours) and the payout is $2. Therefore, over a long period of time, I would expect to win every other day and leave the casino with an average of $1 per day. On the other hand, if I bet straight-up, the changes of winning are 1/36 and the payout is $36. So, compared to the red/black bet, I will win much less frequently (only once in every 36 days), but will take home much more money when I do. These two factors cancel each other out, so on average I will take home exactly the same amount – $1 per day.

The important point here is that my expected payout, over the long term, is  the same regardless of whether I always bet red/black, always bet straight-up, or play a mixture of different bets. The type of bets I choose don’t make any difference to my long-term success.

Now imagine that the casino suddenly introduces a new rule – all winnings will be paid in pennies, and you’re only allowed to carry out as many as you can hold in your hands. This new rule drastically changes the comparison between my two types of bet. If I bet red/black there is no problem – the record for holding pennies in one hand looks to be around 250, so it should be no problem for me to carry 200 pennies using both hands. However, if I bet straight-up then I am in trouble – there’s no way I can carry more than a fraction of my 3,600 pennies out of the casino door.

Under this new rule, therefore, it does matter which type of bet I choose – I should always make a red/black bet. If I make a straight-up bet then I can’t make enough money on the days when I win to balance out the losses on the days when I lose, because of the limited number of coins I can carry home.

The casino metaphor can help us to understand variation if we consider animal traits to be a type of bet. As an example, let’s imagine a population of birds that live in a jungle, eating nuts and fruit, and look at a single trait – beak length. Let’s say that short beaks are good for eating nuts but bad for eating fruit. Long beaks are the opposite – good for fruit but bad for nuts. And medium-sized beaks are in the middle – not particularly good for eating either fruit or nuts, but okay for eating either. We’ll also assume that the abundance of different foods varies from year to year.

Now we come to the interesting question: if you’re a male bird, is it better to have a short, medium, or long beak?  If you have a short beak, you will do extremely well during years when nuts are abundant. You’ll be able to eat loads of nuts, giving you loads of energy and allowing you to have loads of offspring. In years where there aren’t many nuts about, you won’t do so well – in fact you may not be able to have any offspring at all – but the good years will make up for it, and on average you will do okay.

If you have a long beak, of course, the opposite applies – lots of offspring in fruit-rich years, hardly any offspring in fruit-poor years. On average, you’ll do okay, same as if you had a short beak.

And if you have a medium beak, you’ll do okay every year – you’ll never have a really good year, because you can’t take advantage of bumper fruit or nut crops, but you’ll also never have a bad year, because you can eat whichever type of food is most plentiful.

So for a male bird in our imaginary population, it doesn’t matter what type of beak you have – they all do about equally well over the long term. Having a medium beak is the equivalent of making a red/black bet in the casino (frequent, small wins), and having a long or short beak is the equivalent of making a straight-up bet (infrequent, big wins). A single male can have offspring with many females during a breeding season, so a short- or long-beaked male can make up for bad years by fathering lots and lots of offspring during the good years.

Now let’s consider the same question for a female bird – short, long, or medium beak. If you have a short or long beak, you’ll have good and bad years, just like your male equivalent. But you won’t really be able to take advantage of the good years – you can only raise a single clutch of eggs during a breeding season, regardless of how well-nourished you are. So from a reproductive point of view, you will only have bad years and okay years. If you have a medium beak then you’re in a better position – just like a medium-beaked male, you do okay every year.

A female bird is like a gambler at the casino after the new rule has been introduced. She is limited by the number of chicks she can rear in a breeding season, just like the gambler is limited by the number of coins he can carry. Just as there’s no point in the gambler making a straight-up bet when he can’t take home his winnings, there’s no point in the female bird having a specialized beak when she can’t take full advantage of the abundant food. In contrast, a male bird is like a gambler at the casino before the new rule – he’s not limited in the number of offspring he can raise in a breeding season, so having a specialized beak can pay off just as well as having a all-purpose one.

So from an evolutionary point of view, we would expect to see extremes of beak length in female birds selected against, with the result that there will be fewer short- and long-beaked females relative to males. Similar arguments can be made for many other traits that affect reproductive success.

There are many nuances which complicate the argument in real life. We have been talking about males and females of the same species as if their genes evolve separately, which of course is not true – genes which contribute to beak length are likely to be shared between males and females. And of course, we are completely ignoring the role of environment in determining an animal’s traits. Nevertheless, the mechanism is an interesting one – hopefully future work will be able to test its validity further in non-human animals.