Graphics on the Web 1 - Binary Number System Primer

Have you ever wondered where those strange computer numbers come from: numbers like 8, 16, 256, 1024? Have you ever wondered why these same numbers keep coming up over and over again? Well, the answer is really quite simple.

Computers are binary machines. This means that, unlike humans, they work in a “base-2” number system. Humans generally do math in base-10, or decimal. Decimal means that each digit can represent 1 of 10 possible values: 0-9. Note that there is no number ten, while there are 10 possible combinations; the possible value ranges from 0 up to 9. If we want to represent the value “ten” in decimal, we have to use two digits in sequence: 10, or a one and a zero. Computers work the same way except they only have 2 possible values: 0-1. Just like decimal, with two possible values, because zero counts, the biggest number we can represent with one digit is “one.” If we want to represent the value “two” then we have to use two digits in sequence: 10, or a one and a zero. Binary seems strange to humans only because we’re used to decimal. The two systems work exactly the same, except that one has two possibilities, and the other ten.

A “bit” is a binary digit. Just like decimal, where a two digit number can represent 00-99 for 100 possible combinations, or three digit numbers can be 000-999 for 1000 combinations, bits can be strung together to form larger numbers. The following table outlines what strings of bits are capable of:

Number of Bits	Number of Possibilities	Largest Number
1	2	1
2	4	3
3	8	7
4	16	15
5	32	31
6	64	63
7	128	127
8	256	255
9	512	511
10	1024	1023

Note that 4, 8, and 10 bit combinations are the most common. The first thing you will notice is that, if you have done anything with computers, the numbers above will seem very familiar. The number 256, while it seems arbitrary in decimal, is simply the maximum number of combinations that 8 bits can be, and 255 is the largest number you can get with 8 bits. The arbitrariness of 256, 512, or 1024 is only an artifact of converting binary numbers to decimal number. Rest assured, converting decimal 100, 1000, or 10000 to binary would also produce seemingly arbitrary binary numbers.

In fact, binary does not convert well to decimal; we always wind up with these arbitrary numbers that are not intuitively obvious. When working with computer hardware or machine-level programming, this becomes such a problem that people dispense with decimal altogether and work in something called “hex.” Hex, or hexadecimal, is base-16 and follows the same rules as binary or decimal. One hex digit can represent 16 possible combinations: 0-F. People sometimes stumble over the ‘F’ part but it’s actually quite simple; it comes from exactly the same place ‘7’ comes from: somebody just said so, it’s an arbitrary choice. Hex requires 16 symbols to represent its possible combinations. Way back when, someone said “let’s use the decimal digits 0-9 and then add the letters A,B,C,D,E, and F to make up the extra 6 possibilities.

To see how this works, another table is in order.
Four bits of binary can be strung together like this:

Binary	Hex	Decimal
0000	0	0
0001	1	1
0010	2	2
0011	3	3
0100	4	4
0101	5	5
0110	6	6
0111	7	7
1000	8	8
1001	9	9
1010	A	10
1011	B	11
1100	C	12
1101	D	13
1110	E	14
1111	F	15

So, now we have binary, decimal, and hexadecimal. To understand why programmers bother with hex, let’s look at some more binary numbers.

Binary	Hex	Decimal
0011	3	3
0011 0011	33	51
1111 1111	FF	255
1111 0000 1111 0000	F0F0	61680

Now, things start to clear up. Writing out longs strings of binary ones and zeros can get tedious but converting to decimal is not intuitive so we use hex. Converting between hex and binary is quick and easy as it only involves remembering those 16 combinations in the table above. This is why programmers use hex and this is why, when your computer bombs, you see crash-dump screens full of hexadecimal numbers that seem like gibberish. It’s not gibberish, it’s just programmer-speak for “here’s what went wrong.”

There are other times you will see hex numbers as well, and when you do it’s because the programmer didn't bother converting, or chose not to convert, the numbers before displaying them. Many high-end graphics programs will display colour values in hex for this reason. So, when you see letters in the middle of numbers, you’re probably looking at hex.

One other thing to note: when you see a number like 10, you automatically think “ten” but this could also be binary “two” or hex “sixteen” depending on the context. Because of this, programmers will often follow binary numbers with “b” and hex numbers with “h” to avoid confusion. Then there’s “o” for octal but you don’t need to know about that.

Another place these numbers come up is with kilobytes, megabytes, and gigabytes. First off, a byte is 8 bits, and that’s just because somebody said so. Just like the reasoning behind hex, memory and hard drives are organised in bytes rather than bits out of convenience for system engineers. Now, in the metric system kilo is a prefix for 1000, a kilometre is 1000 metres, and mega is a prefix for 1,000,000, as in megawatts or 1 million watts. In computing, because engineers are a strange bunch, the metric system is perverted to deal with those arbitrary decimal conversions of binary numbers. Kilo is short for 1024, the decimal conversion of 10 bits. Similarly, mega is 1024*1024,giga is 1024*1024*1024, and on it goes.

Why, because it’s easier to say 128Mbytes than it is to say 134,217,728 bytes. Remember, it’s a binary system and it doesn't convert well to decimal. However, by using 1024 as the multiplier, a “half-conversion” can happen that sort of makes sense to regular humans. 128MBytes makes more sense that 8000000h to the average person. For the most part, the system makes for good shorthand as the extra 24’s don’t make too much difference. However, some manufacturers will cheat by saying their hard drive is 40Gbytes, which is true as it is over 40,000,000,000 bytes, but when it shows up on your system as only 37Gbytes you know one persons “giga” is different than the others. One is a 1000*1000*1000 in true metric fashion, the other is 1024*1024*1024 in the computer confabulated system.

As you can see, the computer numbers 4, 8, 16, 32, 64, 128, 256, 512, and 1024 are around for a reason; they are just decimal conversions of binary numbers. There really is nothing mysterious about them, they are just values that come up when you double two, and then double it again, and double it again… It’s the same reason we get 10, 100, 1000, 10000 etc. in decimal. One’s base-2 so we double it, the other is base-10 so we multiply by 10 each time. If you don’t like the arbitrariness or these numbers, you could work entirely in hex and computers would make perfect sense. No one else will understand you, but computers will make sense.

Part 2 - Colour Systems

Part 3 - File Types

Graphics on the Web 2 - Colour System Primer

Now that you have a basis for understanding where these strange computer numbers come from, we can apply that knowledge to colour systems.

Back in the old days, monitors were black and white only. Okay, they were black and green, or maybe amber, white didn't come along for a while. But hey, if you want to get picky, the really old systems were lines of blue text on white paper. But, in any event, the systems were “monochrome” or one colour. Monochrome can either be on or off, white or black; it’s a binary system that has only two possible states. This means that it takes 1 bit of storage for each dot on the screen. A screen dot is called a “pixel”

It looks something like this: (note, for printing clarity, I've made on = shaded)

The Screen					The Data
					0	1	1	0
					1	0	0	1
					1	0	0	1
					0	1	1	0
					0	1	1	0

In words, for a screen that was 4 pixels across and 5 pixels down, it would take 20 bits of data to store the image.

Now, This is pretty boring so someone came up with the idea of having variable intensity levels for each pixel. Each dot on the screen could be black (off), dim (33% on), medium (66% on), or white (full on). In other words, each pixel had 4 possible states and this requires 2 bits per pixel to store. For the same number of pixels, our bit count now stands at 40. It looks like this:

The Screen					The Data
					00	11	11	00
					10	00	00	10
					01	00	00	01
					00	11	11	00
					00	11	11	00

Then someone thought, wouldn't colour be nice, and 16 colour mode was born. In 16 colour mode, each pixel can be, you guessed it, one of 16 possible colours. Of course, 16 possibilities require 4 bits per pixel to store. It looks like this: (note that the colours won’t print on a black and white printer, they may appear as shades of grey. Also, I've randomly picked values for each colour.) Note that our bit count is now running at 80.

The Screen					The Data
					0000	1010	1010	0000
					1001	0000	0000	1011
					0101	0000	0000	0111
					0000	1100	1100	0000
					0000	1111	1111	0000

But still, 16 measly colours does not a perfect world paint. How many colours do you thing you would need to create realistic scenes? Well, getting realistic colours requires a lot more: millions more. Thus, 24 bit colour was born. This colour system uses 8 bits for each of the 3 primary colours (red, green, and blue). Remember that 8 bits gives you 256 possible combinations, and that’s 256 possible shades of red, 256 possible shades of green, and 256 possible shades of blue. By mixing each of the primary colour together, we get 256 * 256 * 256, or 16777216 possibilities. Now, for realistic colour, our bit count, for the same 20 pixel display, now runs at 480. 24 times more information than 16 colour mode. It looks like this:

The Screen					The Data
					R=00000000 G=00000000 B=00000000	R=00000000 G=00000000 B=11111111	R=00000000 G=00000000 B=11111111	R=00000000 G=00000000 B=00000000
					R=00000000 G=11111111 B=00000000	R=00000000 G=00000000 B=00000000	R=00000000 G=00000000 B=00000000	R=11111111 G=00000000 B=00000000
					R=11111001 G=00111011 B=11100110	R=00000000 G=00000000 B=00000000	R=00000000 G=00000000 B=00000000	R=10001101 G=00000110 B=00111110
					R=00000000 G=00000000 B=00000000	R=00000000 G=11000110 B=11011100	R=00000000 G=11000110 B=11011100	R=00000000 G=00000000 B=00000000
					R=00000000 G=00000000 B=00000000	R=11111111 G=11111111 B=11111111	R=11111111 G=11111111 B=11111111	R=00000000 G=00000000 B=00000000

Now, 480 bits is still pretty insignificant but you have to realise we’re talking about a 4x5 pixel array. Nowadays, most people run their monitors at 800 x 600 pixels. A full 24 bit colour image on this display requires 800*600*24, or 11520000 bits. That’s 11 million bits of information. Now, recall that computing people use bytes instead of bits when talking about storage space, so 11520000 / 8 = 1440000 bytes (or 1440000 / 1024 /1024 = 1.37Mbytes in computerised metric.) One screen image takes nearly 1 and a half million bytes of storage space.

Back when storage space, in hard drives and RAM, was very expensive, someone came up with a way of compressing this information down. The idea was that, while 16 colours is very limiting, most of the time you don’t really need 16 million colours. Why not have something in between? Thus, 256 colour mode was created. 256 colour mode is actually still 24 bit colour but limits the possible range of colours to 256 by using what’s called a “pallet.” At the beginning of the file for each image, or within a video card, there is an area called the pallet. It is a list of 256 possible colours and their corresponding 24 bit red/green/blue (RGB) values. A pallet looks something like this:

Pallet Entry	Colour	RGB Values
0		R=11111001 G=00111011 B=11100110
1		R=10001101 G=00000110 B=00111110
2		R=00000000 G=00000000 B=11111111
3		R=00000000 G=11111111 B=00000000
4		R=11111111 G=00000000 B=00000000
5		R=11111111 G=11111111 B=11111111
6		R=00000000 G=00000000 B=00000000
…
255		R=00000000 G=11000110 B=11011100

Then, the actual pixel info just references the pallet rather than storing the full 24 bits for each colour. It looks like this:

The Screen					The Data
					00000110 (6)	00000010 (2)	00000010 (2)	00000110 (6)
					00000011 (3)	00000110 (6)	00000110 (6)	00000100 (4)
					00000000 (0)	00000110 (6)	00000110 (6)	00000001 (1)
					00000110 (6)	11111111 (255)	11111111 (255)	00000110 (6)
					00000110 (6)	00000101 (5)	00000101 (5)	00000110 (6)

So, we have a bit count of 160, not including the overhead for the pallet, or roughly one third the size of the same pixel area in 24 bit colour. In general 256 colour mode works very well for graphic images but, even with 256 possible colours, does not work well for photo-realistic content.

The very same system is also used for a newer form of 16 colour mode. In this system, rather than using the stock 16 colours, a pallet containing 16 possible 24 bit colour values is used. It provides a little more flexibility than the old 16 colour system, with very little extra bits. When using this system, the original 16 colours are sometimes referred to as “Windows colours.”

There is one more system worth mentioning: it’s “greyscale.” Greyscale is kind of like the old 2 bit variable intensity black and white, but with 8 bits per pixel. Thus, each pixel can be one of 256 possible shades of grey. I won’t bother with the table as it’s pretty similar to the ones already shown.

Now, with storage space still at a premium, engineers figured out other ways to compress the pixel information down. Thus, we will get into file types.

Part 1 - Binary Numbers

Part 3 - File Types

Graphics on the Web 3 - Graphic File Type Primer

First off, file types, in the Microsoft world, are the three letter designations that go after the period on file names. Examples are filename.gif, filename.jpg, or filename.txt. The computer uses those designations to figure out what program created the file. Thus, when you double-click on a .txt file, notepad (a text editor) opens up the file. If you click on a .jpg file, then a graphics program, or whatever program is “registered” to open .jpg files will open the file for you.

There are many, many different file types for graphics programs but some of the more common ones are BMP, GIF, JPG, TIF, and WMF. These five, at least, provide good examples for the next discussion.

BMP files are “Windows Bitmap Files.” These files are the native Windows format for graphic files. They can be in any of the colour systems mentioned before. There is nothing overly special about them.

GIF files are “Graphics Interchange Format” files. When people first started working with pictures, the file sizes were too large. Someone figured out a way to compress an image by recording repeated colours as counts rather than over and over. For example, if you had a line of pixels that was black, blue, blue, blue, blue, blue, blue, blue, blue, blue, red. Then you could store it that way, as BMP files do, or you could say black, blue (x9), red. This is a simplified example of how GIF files compress file sizes. Depending on how simple the image is (if there are a lot of repeated colours) a GIF file can be significantly smaller than a BMP file, often less than one half the size, with no loss of information. This last part is important: GIF compression is “lossless” in that no information is thrown away, you always get out what you put in, it just takes less room to store. GIF files are usually in 16 or 256 colour mode. Note that there is also a system called “animated GIF. This system is just a series of images, stored in a single GIF file, that play in an animated sequence and is used extensively on the web.

JPG file are “Joint Photographic Experts Group” files, also know as jpeg. JPG, like its cousins in video (MPG) or audio (MP3), is a “lossy” compression system. In other words, information is lost when an image is compressed to this standard. The amount of information lost depends on what the image is of (widely varying images don’t compress well) and how “aggressive” you choose the compression to be. Typically, JPG compressed files will be one twentieth the size of the same image in BMP , a significant savings in file size. To casual observation, the resulting compressed image will not look any different from the original; it takes a trained eye to spot “compression artifacts” from lost information so the file savings are usually worth the lost information. However, JPG images are almost always 24 bit colour (there is a greyscale JPG standard but many applications don’t support it). That means, if you compress a 256 colour (8 bit) image with JPG , it has to convert to 24 bit when you open it up again. In the end, the size can actually grow to three times what it was originally! You need to use JPG compression with caution and full knowledge of what’s going on to get the most from it.

TIF files are “Tagged Image Format” files. This is a file standard that isn't really standard. Most programs support the TIF format but they usually do in their own special way. For example, some mapping files in TIF format include “georeferencing” tags to tell the opening program exactly where the map file is suppose to represent. In other words, the image is “tagged” with special information. Different applications may tag the image in different ways. One unique feature of TIF files is that they can be “paged” from a disk if they are very large. Because of this, it is possible to work on TIF files that are much larger than in the other formats. There is a compressed version of TIF files, actually several version, but not all programs support them.

WMF files are “Windows Meta Files.” I’m ending with this type because it’s weird. Before you can understand what’s going on with these files, you have to know the difference between raster and vector graphics. Raster graphics is what I've been describing all along. The pixels across and down the screen form a raster. Lines and other shapes are made by turning pixels on or off to create the image desired. All but the most specialised monitors and printers are raster devices. In other words, no matter what you start with, the displayed image is raster. A raster graphics file is simply a pixel by pixel recording of the image. Vector, on the other had, is a completely different ball game. In a vector graphics file, rather than storing information for each pixel, information is stored for each line or shape displayed. Thus, a line would be stored as “Line, starting at coordinates 27, 67, ending at coordinates 234, 553, thickness of 3, colour green. Each line or shape of the entire image is stored in this fashion. Most computer-aided design (drafting) or mapping programs are vector based.

Windows Meta Files are vector graphic files. In other words, these files are collections of shapes rather than arrays of pixels. So, why do they bother with this filetype? Well, try enlarging a raster graphics file and you’ll find out why. If you shrink a raster file, say by cutting it in half (from 800 x 600 to 400 x 300) all the program has to do is throw away 3 out of ever 4 pixels (if you half the width and height, you get 1/4 of the picture size), it’s very simple. But, if you took that same file and doubled it’s size, both horizontally and vertically (from 800 x 600 to 1600 x 1200), then the graphics program has to quadruple every pixel into chunky squares. When you do this, smooth lines become jagged staircases. For this reason, raster images are said to be "not scalable." You can’t just keep zooming in without the image turning into large chunky blobs. However, vector files are infinitely scalable. If you zoom in on a vector file, it just changes the co-ordinates of the start and stop points, and maybe changes the line thickness. Smooth lines are still smooth. You could zoom in 500x on an image and the lines will still be smooth.

If vector graphics files are so scalable, many people wonder why we don’t use them for all graphics and just do away with raster entirely. Well, the problem is that photographic images just don’t reduce down to lines and shapes. When there is just too much variation, vector graphic systems can’t hold the image, they just don’t work. Where they do work particularly well is in simple graphic images, and that is exactly where they are used in Windows. Most Windows clipart images are stored in WMF format. Not only are the file sizes small, they are scalable to whatever size you require within the program you are using them in.

What about the WEB:

Well, hard drives and memory may have become cheap in the last while but there is now a new reason to keep file sizes small. The larger the file size, the longer it takes to transfer from a web server to a web browser, especially on a slow link. This is a powerful incentive for web-designers to shrink their images down to the smallest possible size. To do this, they use GIF and JPG files. For simple graphics, reduced to 256 or 16 colour mode, GIF files are the best choice for the reason previously mentioned. For everything in 24 bit colour, JPG is the way to go.

Part 1 - Binary Numbers

Part 2 - Colour Systems

MS-Earth

Is Microsoft the evil corporate empire that so many people profess it is? Well, I'm a tech, I help people use computers running that OS those people seem to hate so much. Windows sucks, it crashes, it confuses, it contains countless examples of frilly yet useless features, and this is a good thing. I owe my job to Microsoft. I don’t work for them but I am one individual in an army of techs that support Mr. Bill’s products. Without Bill, I would be an a truck driver or even (shudder) and accountant.

Think about it; how many people would be employed in the computer support industry if, say, Apple produced the standard desktop? How many authors would be producing “How to understand this stupid product” books? How many “iMac for dummies” books have you seen? Microsoft and Mr. Bill have created more jobs in the last 20 years than any other entity. This IS the master plan.

Look at any company that has bought into the MS world. They’re always looking for more support people. This usually happens after they've bought some fancy MS product that automates some corporate function; like, they get an accounting package that lets the “manager” do the payroll so they can fire a bunch of accountants. Of course, right after that, they have to hire a bunch of support staff to help the manager deal with the buggy software. This is the key: Automate the tasks, fire the useless people, and hire more techs. Eventually, there will only be “managers” and “techs.”

Another part of Mr. Bills master plan is hidden in the “techie” language. Ever wonder why computer jargon is so full of normal words, like “boot” with special meanings? This is so, when there are only a few managers and lots and lots of techs, Mr. Bill can start using words like “overthrow,” or “insurrection” and the mangers will think it’s just another technical term like “socket.” Then Mr. Bill’s army of techs will rise up to dispose of the manager types. It will be a world of techs: MS-Earth.

I eagerly await that day. The day when my benefactor, my hero, and my personal God – Mr. Bill – will command his armies into action. After all, when you're the richest man on earth, the only thing left is power.

Similar Articles

Perl Code Examples - Date and Time Functions

I've put another page of example code on the linked website. This one covers basic date and time functions including epoch seconds, converting to normal dates, converting back, and how to get a date in a useful log format (yyyy-mm-dd) .

The standard DISCLAIMER applies. You can see the code HERE.

Similar Articles

Perl Code Examples - General Stuff

When learning a programming language, I often create little example files to demonstrate different ways I've learned to do things. I am in the process of putting them up on the website that's attached to this blog (via the Navigator panel).

The first example is in Perl and describes general things like printing, variables, comments, basic string handling, if/then/else constructs, loops, and basic Perl hashes.

You can view it HERE

Be sure to read the DISCLAIMER too.

I have a bunch more I'll be posting over the next while.

Similar Articles

Dirt Biking and Moore's Law:

Being a dirt bike rider, of some skill, I've chuckled while watching video clips of the DARPA Grand Challenge participants bouncing around, especially the bike and quad. While it amazes me that they can get a computer to "ride" a motorcycle, the results really are pathetic from a riding point of view. There is no finesse, no anticipation, and only rudimentary control. Very beginner stuff. But, I'm sure that will change soon.

Moore's Law states that transistors on chips double in density every 18 months. Most people shortcut to assuming computer processing power doubles in that time. I've been thinking about that a lot lately. Extrapolating this backwards, in the 50 odd years that computers have been around, Moore's Law says they've gotten roughly 4 billion times more powerful. It kind of makes sense, going from hertz to gigahertz and with substantially wider buses and the like. But, if we extrapolate forward, then 50 years from now - in 2056, computers will be 4 billion times more powerful than they are now. People keep saying we're going to miss a beat in Moore's Law, it's not a real law after all. But, so far we've kept it up and there's enough research in the pipe to keep it going for a while.

So, assuming, as some people have, that our minds are 100 times more powerful than a decent computer, that gives us about, say, 13 years head start. Maybe the assumption is wrong and we're 200 times smarter... so we fall behind computers in 14.5 years. Maybe we're 1,000 times smarter: 17 years. A million times smarter: 29 years. The basic issue is that we, being biological, are not subject to a Moore's Law exponential curve. At best, assuming intelligence evolved, and that we are still evolving, and that this evolution is towards increased intelligence - all debatable assumptions - then our processing power increase is pretty linear, punctuated equilibrium aside. Computer processing power, and thus intelligence, is increasing exponentially. Sooner or later, computers will be smarter than we are. Being exponential, later isn't very much later. 100 years from now, computers might be 30 million trillion ( 30,000,000,000,000,000,000) times more powerful: we won't.

Chess players have had to suffer the indignity of being beaten by a computer. How long before I have to admit that a computer can out-ride me in the desert? The age of riders, drivers, and pilots is rapidly coming to a close. The best will be bested and the rest of us will just be along for the ride. My father saw the obsolescence of the steam locomotive and the space shuttle; he might even be around for the first space elevators. I'll probably live to see the human race fall to the number 2 slot on the intelligence scale. 18 months later, we'll only be half as intelligent, and so on. Are humans 30 million trillion times smarter than an ant?

Are we stupid enough to make computers smarter than we are? Maybe the Luddite's got it right.

Similar Articles

If Computer Companies Made Cars:

If computer companies made cars, the Mac car would be clean and stylish with classic lines. The Windows car would seat 7, be all-wheel drive with variable-height suspension, have vintage '50s Cadillac fins and pneumatic gull-wing doors. The Linux car would be anything you wanted, there are a lot of models to choose from. If you weren't happy with the available Linux models, you could take the parts and make your own, for free.

The dashboard on the Windows car would look something like a jet fighter; not a modern fly-by-wire fighter but one of the old ones with masses of gages, lamps, and rows of switches. You could also browse the Windows download site and, after proving that you own a legal Windows car, download a free pair of MS-dice to hang from your mirror. The Mac dash would have a speedometer, a "service engine light" and a start button. Its mirror would be specifically designed to eliminate the possibility of hanging dice, air fresheners, or other tacky things from it. The Linux car would have any number of dashboards to choose from or, for that hardcore look, you could choose to have no dashboard at all. Linux car owners could browse fuzzydice.org and download as many dice as they want, being open-source, they're free. Despite Steve's good taste, fuzzydice.org will have free Mac car compatible dice as well.

To start the Windows car, you would either have to push the heater, clutch, and AM radio buttons simultaneously and then choose Start from the dialog box, or you could go Start - Control Panel - Engine, enable the Run check-box, and then go to the Status tab and hit the Start button, or you could open a command box and type in "Engine /Start" (you could also do that by clicking Start - Run and then typing "Engine /Start"), or you could edit the registry by browsing to HKCurrentCar-Microsoft-Car-Windows-Controls-Start and add the Dword value "IsRunning" and set it to "1". Be sure to back up the registry before doing this. To start the Mac car, you would click on the Start button. With the Linux car, after you've downloaded the components, made, and bolted on the starter, you just hot-wire the ignition.

Later, to turn the Linux engine off, you type in "qx-t0." The same thing can be accomplished in the Windows car by going Start - Engine - Turn Off and answering Yes to "Are you sure." You could also leave the Windows car running as it will stop all by itself fairly soon. With the Mac car, you merely drag the engine to the Trash, of course.

Every car has problems and computer cars would be no exception. Trouble is indicated on the Windows car when the MIL (Malfunction Indicator Lamp) turns on. On the Mac, it's the "service engine light." Linux car owners could make and install MIL functionality if they choose but most will forgo the luxury and instead prefer to browse the logs periodically.

When trouble happens, Windows car owners can browse the online help, knowledge base, and technical articles for information like: MIL status operation, changing the MIL bulb, tire rotation - MIL spec, setting MIL function codes in VB, and, maybe, if they persist, they will find a knowledge base article that says: Symptoms - the MIL indicates a fault, the fuel gage is over half-full, and the vacuum indicator is off. Cause: this is a know Windows car problem for which there is no current solution. Workaround: Open the global group policy entry: Hardware - Windows - Current - Engine Management - Windows - Specifications - Engine, and set the entry "Disable MIL Blanking" to False. Linux car owners can view the Man pages for relevant information. However, after they have paged through all the irrelevant POSIX stuff they will come to realize that only UberGeeks can understand Man page documentation. Non-UberGeeks can ask one of the many Linux forums for help but the following guidelines should be adhered to at all times: First, all requests for help must start with the refrain "Linux is Great, Linux is the one true OS, All Hail Linux." Second, never, ever, complain that only UberGeeks can understand Man pages. In fact, it would be much better to copy a random section out of a Man page (any one will do) and paste this into your plea for help as an indication that, yes, you did indeed RTFM. Third, never plead complete newbie ignorance. It is far better to say that you think you know what you're doing, and did RTFM, but there must be something wrong with your config file that you just can't see, probably because you've been up for 37 hours straight trying to get Linux running on your walkman. For Mac car owners, a trip to the owner's manual will state "The service engine light indicates that the engine should be serviced. Please have the car serviced by qualified service personnel" or some other completely useless collection of obvious yet meaningless words.

There is another operating system worth comparing, even if it is obsolete. A car made by VMS would look like a delivery van, have a dashboard that looks like the dashboards everyone is already used to, be started with an industry-standard ignition switch, turn off by turning off the ignition switch, and come preconfigured with a MIL. When this MIL turns on, a trip to the VMS car hierarchical help system would show: MIL - indicates that the engine requires service, MIL service - service is indicated through trouble codes, MIL service trouble code - Service personnel can get a list of current trouble codes by ..., MIL service trouble code listing - the following trouble codes can be indicated..., and so on. Also, a VMS car would be virtualized and 200 people could drive it at the same time, going different places, without being aware of each other. Despite this, a VMS car would never crash, ever.

Given the above analogy, why doesn't everyone use VMS? The answer is that an operating system, like a car, is built for a purpose. A car's purpose is to carry people from one place to another while an operating system's purpose is to let the user start applications. Taking the analogy further, a VMS car could only drive from the factory to the on-site accounting office, nowhere else. Mac cars would only be allowed to drive on specially-constructed iRoads; iRoads would only go places Steve Jobs thought was cool. Most Linux cars, or rather trucks, would be relegated to designated truck lanes or industrial complexes. Other Linux cars would be more like Land Rovers, capable of going just about anywhere, places other cars just can't go, all be it with some effort and discomfort on the operator's part. The Windows car would be for everyone else, everyone else adding up to 80% of the people that use cars.

Similar Articles