Jun 17

Light is electromagnetic radiation. In particular it’s that part of the electromagnetic spectrum that our eyes are sensitive to: it ranges in wavelength from about 400nm (violet) to 700nm (red). Beyond red light we come to infrared (IR). Like ordinary light, infrared (or specifically near infrared) can be focussed by glass lenses and recorded by the CCD in a digital camera.

Ghostly colours -- if your camera is compatible

Infrared photography can be used to produce interesting ghostly effects, but all cameras are different so test yours before buying any pricey gear. (Click the photo for a high resolution version.)

By excluding all visible light from the camera while allowing infrared to pass, it’s possible to take photographs using infrared alone. White clouds can appear against an almost black sky and green vegetation comes out so white that it almost glows. The end result has been variously described as otherworldly, ethereal and ghostly.

If you don’t want to fake the effect (see ‘Fake Infrared Ektachrome’ later in the article), you’ll need to collect together a little bit of kit to do this right. First, infrared photographs usually require a long exposure so you’ll need a tripod. However, if you don’t already have one, hold off on buying one until you’ve tried a test infrared photograph. If you just happen to have a camera that’s unusually sensitive to infrared you might get away with using it handheld, but it’s unlikely. Small tripods start at about £10.

Choosing a filter

The next consideration is an infrared filter. For your first attempts at infrared photography we suggested that you use the Hoya R72 filter. Its cut-off point is only just into the infrared spectrum, which means it actually lets a small amount of visible red light through too. If you’re pleased with your initial foray into infrared photograph and want to go one stage further, you could try other infrared filters that have cut-off points further into the infrared spectrum. The infrared effect will be even more pronounced and dramatic, but exposure times will be increased.

The Hoya R72 has a 50 per cent cut-off point of 720nm. The Kodak Wratten #87 has a corresponding figure of 795nm and excludes all visible light. The Wratten #87C has an 850nm 50 per cent cut-off and this is probably as far as you’d want to go. Although Wratten filters are supplied as 75mm square gelatine sheets that aren’t easy to attach to your lens, manufacturers of screw-in filters often refer to an equivalent Wratten number.

But before you buy, make sure it’s actually going to work with your camera…

Preparatory work

Although CCDs are extremely sensitive to infrared, many digital cameras aren’t. This is because manufacturers usually put a filter in the camera to block infrared, as it would otherwise upset the colour balance. These filters aren’t 100 per cent effective so some infrared still reaches the CCD, but exactly how sensitive a camera is to infrared varies greatly. Your first job is to check that your camera is sensitive enough to be usable.

The unusually high reflectivity of grass and foliage is responsible for the unreal look of infrared photographs. (Click the photo for a high resolution version.)

The easiest way to do this is to ask a local photographic shop if you can try an infrared filter before you buy. Here we’re talking about a filter that allows infrared to pass through while blocking visible light. Remember that the light meter might be wildly inaccurate under these conditions, so if you don’t get an image on your first attempt, try over-exposing by several stops if necessary. Another option is to use a TV or DVD remote control unit, since all such devices emit infrared light. If your camera allows the LCD panel to be used as a viewfinder, view the infrared emitter at the front end of the remote on the LCD panel and press one of the remote’s buttons in a dark room. A bright dot indicates that the camera has reasonable infrared sensitivity. If you have a digital SLR that can’t use its LCD panel as a viewfinder you’ll have to try a test photograph, again bearing in mind that you might have to over-expose.

Once you’ve discovered that your camera can be used for infrared photography and bought an infrared filter, you can start to get a better feel for what sort of exposure you’ll need under various conditions. Screw the filter onto your lens and try some test shots. The exposure will be much longer than normal and could be several seconds, even on a bright day. On the basis of these trials you can decide whether there’s any chance of shooting handheld or if you’ll need to use a tripod. The other piece of information you’ll glean from this test is whether the camera’s light meter is accurate in infrared and, if not, by how much you’ll need to over-expose.

Capturing the invisible

If you’ve got this far we’ll assume that you have an adequately sensitive camera, have bought an infrared filter and have decided whether you need to use a tripod. Now you’re ready to pack your gear up and try your hand at some infrared photography. First, though, a word on your choice of a subject.

We don’t want to be too prescriptive because this can stifle creativity, but perhaps we can offer a few suggestions to get you started. Remember the unique characteristics of infrared photographs – the blackening of blue skies and ghostly white rendering of grass and tree leaves – and pick your scene accordingly. Trees in the summer against a blue sky might look quite dramatic whereas an overcast scene of a bracken-covered moor almost certainly won’t. Try looking at the work of others for inspiration – you’ll find no shortage of infrared photo galleries on the web. You’ll soon see that some subjects seem to work whereas other just don’t, and you’ll also discover that some scenes are almost compulsory for infrared photographers. Perhaps the all-time favourite cliché is the graveyard, which seems to be perfectly suited to the ghostly look of infrared.

A graveyard -- the ultimate infrared cliche

This might be a cliché, but every infrared photographer has to shoot a graveyard sooner or later. (Click the photo for a high resolution version.)

Taking a shot should now be plain sailing but there’s one possible snag – you might not be able to see anything in the viewfinder with the infrared filter attached. If you have an independent optical viewfinder you’ll be OK, but you may or may not be able to see the scene in an LCD viewfinder, depending on the camera. With a conventional DSLR the viewfinder will almost certainly be blank. If you aren’t able to see through the viewfinder, you’ll have to frame the shot before fixing the filter –so you’ll have to use a tripod.

Infrared photographs will rarely be up to scratch straight out of the camera, so image processing will almost always be necessary. First, although infrared photograph is a form of black-and-white photography, your photograph probably has some colour cast. Often the raw photograph will be in shades or red, so your first job is to convert it to greyscale. Even if the result does appear to be black and white, you should still to convert it to greyscale to ensure accurate blacks and whites. Then, because high contrast is often important in infrared photography, you might decide to exaggerate it by artificially increasing the contrast. Ensure you only ever edit a copy – leave the original intact so that you can try something different later if you want.

Infrared colour photography

Infrared is normally considered a form of black-and-white photography, so infrared colour photography sounds like a contradiction in terms. However, it’s possible to create a photograph that contains some colour information yet has the tonal quality of an infrared photograph.

First, take a pair of photographs of the scene, one in infrared and the other normally in visible light. This means that the camera must be mounted on a tripod and that nothing in shot is moving. It’s also important to use the same aperture for the two shots so that the depth of field is the same. Try to work as quickly as possible so that the lighting or slow-moving clouds don’t change much between the shots. You need to add or remove a filter between shots and probably alter the exposure, which could be tricky. It’s a good idea to give this process a bit of thought before trying it out for real.

Process the infrared photograph as already described for ordinary infrared photography. Now, using your photo-editing software, split the ordinary photograph into either the HLS (Hue, Lightness, Saturation) or HSB (Hue, Saturation, Brightness) channels – the two are slightly different so try experimenting with both. Splitting channels is a feature of most fully featured photo editing packages, although it might be absent on entry-level products. Each channel appears as a greyscale image, of which one – lightness or brightness – defines the lightness. Since we want to impart the tonal qualities of an infrared image, discard the brightness or lightness channel and put the infrared image in its place before recombining the channels. The result should be quite an eye-opener.

A colour shot combined with an infrared one gives a striking effect

Combining an ordinary photograph with an infrared shot can create dramatic colour effects. (Click the photo for a high resolution version.)

This is just one way of creating a colour infrared image and the possibilities are limited only by your imagination. Here’s another method that has been widely used, but be aware that the exact result will differ from one camera to another – so you might end up with a different effect entirely. And if the infrared image as it comes out of your camera appears black and white this method won’t work at all. Take an infrared photograph but, instead of converting it to a greyscale image, use your photo manipulation package to correct the white balance. Although the colours won’t be correct it will result in some parts of the photograph coming out almost white instead of shades of pink. The sky will appear red or brown, which looks most odd. To correct this you need to use the channel splitting and recombining trick. But instead of splitting to HLS or HSB, split the photograph to RGB (Red, Green, Blue) and then recombine with the Red and Blue channels swapped. With a bit of luck you’ll end up with a blue sky, while any foliage will have a slight sepia hue to its ghostly appearance.

Fake an infrared photograph

For many, the appeal of infrared photography is that it’s a natural phenomenon that can’t be recreated by digital wizardry. However, if you don’t want to shell out on an infrared filter you can get a similar (albeit less dramatic) effect using image-processing software.

Take an ordinary colour photograph and make sure it’s one with a really dark blue sky and light, well-lit foliage. Using your photo-editing software, split the channels to RGB and then discard the blue channel, recombine the remaining two channels and convert to greyscale. This will have the same effect as putting a red filter on the camera – it darkens the sky but not as dramatically as happens with an infrared filter. The glowing white appearance of the foliage will be absent, though, so let’s try something different. Again split the colour photograph to RGB and discard the blue channel. Before recombining, though, try increasing the brightness of the green channel. Now when you recombine you’ll find that the foliage has become lighter but, because all but the darkest azure blue skies contain some green content, the sky won’t be as dark. A degree of trial and error is required to find a compromise that comes close to the genuine infrared effect.

Simulate infrared ektachrome

For many years Kodak produced a film called Infrared Ektachrome, which produced a colour infrared image. That image was very different from the colour images we’ve discussed in the main part of this article because the film was intended for scientific rather than artistic purposes. Nevertheless, some mainstream photographers did experiment with it for its novelty value, and it’s quite possible to emulate it digitally.

An ordinary colour photograph is made up of images in the three primary colours – red, green and blue. Infrared can be though of as another colour so Infrared Ektachrome recorded an image in three alternative primary colours – infrared, red and green. Because our eyes can’t see the infrared, each primary colour was translated so that infrared appeared as red, red as green and green as blue. Because our eyes can only handle three primary colours, blue was discarded by putting a yellow filter over the lens. This combination of infrared and colour was used in aerial photography because it showed up features than couldn’t be seen in visible light alone. Normal crops, for example, appeared red because they’re highly reflective of infrared whereas diseased crops looked blue because they only reflected green light.

Faking Ektachroms is relatively simple if you split the right channels

A different way of combining a visible and an infrared shot gives results reminiscent of Infrared Ektachrome film. (Click the photo for a high resolution version.)

To create this effect you need to take a pair of photographs, one in visible light and one in the infrared and combine them in a photo manipulation package. This time, however, split the visible image to RGB, discard the blue channel and recombine with the infrared image in place or the red channel, the red in place of the green, and the green in place of the blue.

Near and far

Infrared photography is often thought as a means of seeing in the dark. But the far infrared radiation (or heat) emitted by living creatures, is recorded. It’s also possible to use near infrared to photograph in the dark, but because most objects don’t emit near infrared you need a source of infrared illumination. A flashgun with an infrared filter over it will do nicely.

Although many insects can see ultraviolet, few creatures have vision that extends into the infrared. Research has suggested that birds of prey can see longer wavelengths than humans, but they probably don’t perceive this near infrared as an extra colour – so you have the potential to capture scenes that no living creature has ever seen.

Tags: camera, device, information, lighting, photographs, Research, rms, sla, Software, web, XP
Jun 15

Although languages like APL, Prolog and COBOL might seem unusual to many of today’s programmers, they are serious languages developed to address a specific requirement or a particular model of programming. We’re looking here at those languages that have been designed, first and foremost, to be odd. Referred to as esoteric programming languages, some are intended as jokes, some as parodies of other languages, whereas others were designed to be downright strange.

Esoteric programming languages: is there room in your brain for these nutty devices?

Bizarre or not, though, all of them truly are programming languages in the sense that they really can be used to provide instructions to your PC. Our intention here isn’t to show you a lot about any one language – after all, you’re not exactly going to be using them for genuine programming projects – but to look at three of then, fairly briefly, to give you a feel for the variety of esoteric languages.

INTERCAL

The names of programming languages are often acronyms that give some clue as to their purpose. So BASIC is Beginners All-purpose Symbolic Instruction Code, COBOL is COmmon Business Oriented Language and FORTRAN is FORmula TRANslation. So you start to get a feel for INTERCAL when you read in the manual (which you can find at www.muppetlabs.com/~breadbox/intercal/intercal.txt) that its full name is “Compiler Language With No Pronounceable Acronym, which is, for obvious reasons, abbreviated INTERCAL”. It was designed with the aim of being as obtuse as humanly possible, mainly so you that you can amaze your fellow programmers by your ability to do something useful in this bizarrely complicated language which was designed specifically to have nothing at all in common with any other major language.

Ironically, since our stated aim is to show you how to program in esoteric languages, we’ve not even going to try with INTERCAL. Instead we’ll show you how to use the INTERCAL-J compiler using a sample program provided and then we’ll leave you to peruse the manual. We suggest you do this in a darkened room and clear a week or two from your diary before you start. If you consider this a dereliction of our duties, take a look at the INTERCAL program below, which has been provided to illustrate how fiendishly involved even a simple program can be. Its purpose is to read in 32-bit unsigned integers, treat them as signed, 2s-complement numbers, and print out their absolute values, terminating if the absolute value is zero. A comparable APL program runs to 16 characters.

DO (5) NEXT
(5) DO FORGET #1
PLEASE WRITE IN :1
DO .1 <- 'V":1~'#32768$#0'"$#1'~#3
DO (1) NEXT
DO :1 <- "'V":1~'#65535$#0'"$#65535'
~'#0$#65535'"$"'V":1~'#0$#65535'"
$#65535'~'#0$#65535'"
DO :2 <- #1
PLEASE DO (4) NEXT
(4) DO FORGET #1
DO .1 <- "'V":1~'#65535$#0'"$":2~'#65535
$#0'"'~'#0$#65535'"$"'V":1~'#0
$#65535'"$":2~'#65535$#0'"'~'#0$#65535'"
DO (1) NEXT
DO :2 <- ":2~'#0$#65535'"
$"'":2~'#65535$#0'"$#0'~'#32767$#1'"
DO (4) NEXT
(2) DO RESUME .1
(1) PLEASE DO (2) NEXT
PLEASE FORGET #1
DO READ OUT :1
PLEASE DO .1 <- 'V"':1~:1'~#1"$#1'~#3
DO (3) NEXT
PLEASE DO (5) NEXT
(3) DO (2) NEXT
PLEASE GIVE UP

So to business and in particular we’re going to compile and run a program that prints out prime numbers. J-INTERCAL runs from the command prompt so Select Run… from the Windows Start menu, enter ‘cmd’ into the Open box in the Run window before clicking on OK. Then, at the prompt in the command line window, type ‘cd c:\jintercal-0.12\samples\’ and you’ll notice that the prompt will change to reflect the new default directory which is, in fact, the one where you’ll find an INTERCAL source file called primes.i. To compile it, type ‘Java intercal.Compile primes.i’, noting the capital C in ‘Compile’. All being well it will create the Java class file primes.class that you’ll be able to see if you type ‘dir’ at the prompt to list all the files in the folder. Now to run it, type ‘Java primes’ and you’ll see prime numbers flash down the screen expressed as Roman numerals which is INTERCAL’s standard form of output.

Brainfuck

INTERCAL programs are long and convoluted, aided and abetted, to no small degree, by the requirement to write polite programs with sufficient PLEASE statements included. Not so with the inappropriately sweary Brainfuck. Its programs couldn’t be more different. The aim was to implement a language with the smallest possible compiler – the compiler we’re using is just over 2Kbytes in length (yes, Kbytes, not Mbytes) and the record is somewhat less than 200 bytes. This required simplicity and despite the fact BF is Turning complete, meaning that it can perform any computation that “serious” languages can perform, it has just eight instructions, each of which is represented by a single character. That doesn’t make for the most readable program – so again you’ll reach guru status if you can master it – but it does mean that we can teach you the language in its entirety.

There is no concept of named variables, as there is in most languages. Instead BF has a string of 8-bit memory locations and a pointer that records which of those locations the current instruction will operate on. Initially all the locations contain zero and the pointer is initialized to the left-most location. With that bit of background we can now introduce the eight instructions, which are:

+    Increment the value at the pointer
-    Decrement the value at the pointer
>    Move the pointer to the right
<    Move the pointer to the left
[    Start of loop
]    End of loop (exit if value at pointer is zero)
,    Input an ASCII character and store it at the pointer
.    Print the ASCII character at the pointer

Of course a simple instruction set invariably means a complicated program so the simplest of operations, that might be achievable in a single instruction of a conventional language, can take dozens of instructions in BF. As an example we’re going to create a program that accepts two single digit numbers as its input and outputs their sum. The program to do this is as follows and, despite the fact it has 30 instructions, it still only works correctly if the answer is represented by a single decimal digit:

, > + + + + + + [ < - - - > - ] , [ < + > - ] < .

Your first job is to create a file containing the code showed above using Notepad. Since the space character isn’t a valid instruction it’s ignored and although we put a space between each character to make the code easier to read, you can leave them out. Note also that the full-stop at the end is part of the program. Call the file add.b and place it in the c:\bfd100 folder. Actually Notepad will try to give the file the name “add.b.txt” so you’ll have to rename it in Windows Explorer.

Now start up the command line window and change the directory to c:\bfd100\ – if you’re not familiar with command line prompts we did something very similar when we started to use INTERCAL. At the prompt type ‘bfd add.b’. BF will respond with the message ‘File assembled’, and if you do a directory listing you’ll see that the file add.com has indeed been created. This is a DOS executable file so all you have to do to execute it is to type ‘add’ at the prompt. Now type in your two one-figure numbers (with no space or punctuation between them) and the program will display their sum, immediately after the input, again without a separating space.

Now a slight aside. To be quite honest, of the three languages here, BF is the only one that you might want to delve into. After all, it’s quite an interesting language in its own way, in contrast to the others which are, quite frankly, plain dumb, and that’s being charitable. So to start you on your voyage of discovery, let’s see how the simple program above manages to add together two numbers.

The comma reads the first of the two figures and places it where the pointer is positioned which is, initially, in the left most memory location. However, the value read is an ASCII character which, for the figures 0 to 9, are the codes 48 to 57 so, to yield the actual number represented, we need to subtract 48. That’s achieved with the rest of the code up to but not including the second comma. It does that by moving the pointer to the right and incrementing that memory location six times so that it contains the value 6 which will then be used as a loop counter. Next it enters a loop that decrements the ASCII code eight times and the loop counter once. Since this loop will execute eight times, and each time it will subtract six from the ASCII code, when it does exit 48 will have been subtracted from the value input. The second comma inputs a second ASCII code which, because of the position of the pointer, will be stored one location to the right of the first value and again this will be used as a loop counter. The second loop causes the first value to be input (now decremented by 48) to be incremented as many times as the value of the second ASCII code input. When the loop exits, the value in the left-hand memory location (which is a valid ASCII value for a digit since we only subtracted 48 from one of the input values) is printed out.

BF commands might be terse but that doesn’t mean that programs can’t be made readable. Since all but the eight characters representing instructions are ignored, comments can be placed anywhere, as the following program shows.

===INPUT NUMBER===
+      cont=1
[
-      cont=0
>,
======SUB10======
----------

[      not 10
<+>     cont=1
=====SUB38======
----------
----------
----------
--------

>
=====MUL10======
[>+>+<<-]>>[<<+>>-]< dup

>>>+++++++++
[
<<<
[>+>+<<-]>>[<<+>>-]< dup
[<<+>>-]
>>-
]
<<<[-]<
======RMOVE1====
<
[>+<-]
]
<
]

Java2K

Unlike our previous two languages which were supported by compilers, Java2K is implemented as an Integrated Development Environment (so it’s a bit of a mystery why it’s referred to as DIE for Win32 instead of IDE). But before you get too excited, this doesn’t mean a fancy integrated editor and all the works, it just means that immediately after compiling the code it runs it. To start it just double click on the Java2K.exe icon in the c:\java2k\ folder it’ll open in a command line window and announce its presence with the rather puzzling statement “ELVIS HAS LEFT THE BUILDING AT 0.0.1900 <chair>:”. To see it in action just type the name of one of the sample Java2K programs supplied, say “26”, and you’ll see the output which, in this case, is the letter “F”. Having seen something of the astonishing power of this remarkable language you’ll be eager, no doubt, to try out more of the sample programs. However if, for the moment, you can get over your understandable excitement, we’ll first take a look at Java2K behind the scenes.

Like INTERCAL and most other languages, but unlike BF, Java2K has operators that work on variables. Like BF, Java2K is obscure in the extreme but whereas in the case of BF that was by necessity (i.e. to achieve the goal of producing a tiny compiler), in the case of Java2K it’s by design. First of all, where most languages use decimal numbers, perhaps with the option of binary, octal or hexadecimal, Java2K uses numbers to the base 11 which, as the manual points out, is close enough to decimal. Because base 11 numbers require an additional digit to the usual 0-9, Java2K uses 0-9 plus space. The upshot of this is that since a space will be interpreted as the number ten, spaces can’t be used just to make programs more readable. Second, function names are numbers rather than words, and so too are the names of variables. So you can forget, for example, of using meaningful variable names such as “Total” or sensible instruction names such as “Print”. In the case of this latter instruction Java2K uses the instruction “1 1 “ (note the two spaces, after all this is a base 11 number) instead. And finally, on the subject of obscuration, because numbers are interpreted as functions or variables, you can’t use them as numerical constants. Instead, if you want to refer to the number one, you have to use some function that will produce 1 as its output. The classic way of doing this is to use the code “11 6/*/_\”. If we point out that “11 6” is the divide function, “*” returns a random number, “_” repeats the previous argument, “/” is a separator and “\” is an end-of-instruction marker, it should be clear that this will produce a 1. Surprisingly, then, this statement isn’t quite correct as we’re about to see.

1 1 /125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2
/*/_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/
_\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\
\\\\\\\/*\1 1 /125 /119 /11 6/*/_\/13 2/*/_\\/
125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_\
/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\\
/125 /131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_
\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_
\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_
\/_\\/131 /119 /125 /11 6/*/_\/_\/125 /13 2/*/_
\/_\\/119 /125 /11 6/*/_\/_\/125 /13 2/*/_\/_\\

Using the Java2K IDE (sorry, DIE) run the program 13 which is supposed to display “Hello, World”. We’ve included a small chunk of it above. Run it a few times and you’ll probably notice something odd – it doesn’t always get it right. The reason for this is that unlike virtually any other language, Java2K is a probabilistic language rather than a deterministic one so all its functions generate the “correct” answer only 90% of the time; for the remaining 10% it will give a random result. So the method of generating a one that we saw above only has a 90% chance of success. And that’s just for generating a one. The obvious way of generating a two is to add two ones together using the code “125 /11 6/*/_\/_\” but we’re now introducing another instruction that also has a 90% chance of success so the combined likelihood of getting the expected result drops to 81%. In this light of this you might find it surprising that the program 13 manages to produce “Hello, world” as often as it does.

The fact is that there are clever tricks that Java2K programmers can use to improve a program’s success rate but the result is that even the simplest of programs can be extremely long, not to mention virtually incomprehendable. As proof of this why don’t you take a look at program 13 using Notepad. Having done so we suggest that you use the experience to convince yourself that there are better ways of spending your time than attempting to learn Java2K. If you choose to ignore this advice you’ll find the programming manual, in all it succinct glory, at www.p-nand-q.com/humor/programming_languages/java2k/manual.html but we won’t be responsible for the consequences.

Tags: acronym, API, business, Development, device, directory, Discovery, Environment, memory, requirement, sla, space, type, Windows, XP
Jun 14

Linux doesn’t have a CEO. Consequently, there’s no annual keynote hosted by a charismatic alpha male. But if it did, and if there were a conference covering the first half of this year, the first speech would start with three words: ‘Linux is winning’.

Firstly, a market research firm in the US called The NPD Group revealed that sales of Google’s Android platform overtook those of Apple’s iPhone in the first quarter of 2010, propelling itself into second place behind the waning RIM. Android is becoming increasingly competitive, spanning both the smartphone and the emerging tablet markets, with devices from Dell and HP on the near horizon. This might be why Apple has started a patent infringement lawsuit against HTC, using many of its Android-based phones as physical exhibits in its litigation.

Secondly, Google announced its intention to open source the VP8 video codec. This was acquired when it bought On2 earlier in the year and it will be used alongside Vorbis and the MKV container to create Google’s WebM video format. This is vitally important for Linux. The nascent H.264 format, as used by Apple and many HTML5 video streams, is encumbered by patents, and current open-source implementations live under the shadow of legislation. VP8 and WebM have the potential to match it for quality, and while WebM will undoubtedly attract similar litigious trouble, having an umbrella the size of Google should satisfy many Linux distributions, especially when Mozilla, Opera and Adobe have already pledged their support.

Finally, the UK’s new coalition government has published its Programme for Government. There are two points in the section on Transparency that are great news for free software. One states, “We will create a level playing field for open-source software,” while the other adds, “We will ensure that all data published by public bodies is published in an open and standardised format, so that it can be used easily and with minimal cost by third parties.” If these promises come true, it will transform attitudes to open-source software and Linux, and hopefully open the door for its use within government and schools, two areas where it’s ideal.

Many of us used to think that for Linux to be judged a success, it had to be installed and running on more desktop computers than Microsoft Windows. And there are great swathes of Linux users who still feel the same way. But the world of computing has changed. There’s more than one way of judging the success of something that started as just a good idea.

Windows, Linux and OS X are survivors. They’ve lasted this long because they exist within their own ecosystems. Linux, for example, is fed by a curious mixture of enterprise investment, embedded hardware vendors and a community brimming full of zealous commitment. There’s a low-cost threshold to entry and a subsystem that maintains itself with very little investment. It’s these factors that have shaped how it looks, how it feels and how it’s operated.

The ecosystems inhabited by both Microsoft and Apple are equally well-adapted to their environments. The former is the domain of the utilitarians, offering straight functionality for an up-front price. The latter is an increasingly important fusion of fashion and function. But things have changed. The borders between the ecosystems have become indistinct. Apple has surpassed Microsoft in market value, winning thousands of new fans through it’s no-fuss interfaces and lower prices. There’s a shift in the balance of power.

And thanks to Google, Linux is becoming less free and less open, proving that in the new markets where it’s having the most commercial success, it’s becoming more like Apple. ROMs are encrypted and need to be rooted for user-hacking, third-party applications have to be sold through a single vendor and personal information is held in the cloud by a sole provider. If Linux wants a taste of similar success, it might find it if it makes similar concessions to a user’s freedom.

But then we’d have failed. The Linux ecosystem would have become too polluted, bogged down by sponsored kernel additions, paid-for support and short life cycles. It may be a commercial success, but no longer an active one. Our hypothetical CEO might make further compromises, and make judgements against the interest of Linux users. Which is exactly why we don’t have a CEO, and exactly why the success of open-source software is so difficult to judge using the same language as its competitors.

Tags: Apple, application, ceo, Computer, computers, Computing, desktop, device, embedded, Environment, functionality, google, Hardware, implementation, implementations, information, interface, iphone, linux, microsoft, Microsoft Windows, patent, Patents, Personal, Research, sla, Software, system, third parties, web, Windows