Gravaton

Older versions of the Blackberry OS were pretty bad and clunky but they've improved the platform to the point where it's a very competent all-round device. I've used WinMo and Symbian, and like both of them, and I would say that the 4.6+ version of the BB OS is very much a live competitor. I haven't used the iPhone or Pre at all so I can't comment on them. However, what really keeps the BB from selling outside of the US is the fact that it's mostly US companies that have gone for BES which makes the phone something of a necessity for many businesspeople here. Unfortunately Nokia decided to stop providing BES support soon after releasing the E62, which is why I have a Bold and not an E72 right now :)

Oh god I screwed that previous comment up. Didn't realize < and > would get insta-killed. So I'll just redo this properly - is there a way to delete a prior comment?

I'll use C as an example of this, although I am not making any sort of claims as to the origin or history of "counting from zero" - just giving a practical example that gives some sense to the practice.

In C, an array is referenced as address[offset]. Arrays aren't too complicated, they're just contiguous blocks of memory that contain multiple values, all right next to each other. The "address" portion will always be the same for any specific array, and the memory location of element you're referencing is computed as:

address + ( offset * size_of_item )

Now the C compiler knows the type you've given the array, so it takes care of multiplying the by the size of one item. So, to make things simple, let's presume you have an array of 1 byte elements. The address points directly to the first element in the array. So if you want to retrieve that element, you want to retrieve the byte located at "address". As the equation above makes pretty clear, element number "1" is going to be [address + ( 1 * 1 ) ] == address + 1. Not what you're looking for! Element 0, however, fits the bill: [address + ( 0 * 1) ] == address.

So oftentimes in programming counting starts at 0, because 0 means "the thing at the reference" and 1 means "the thing 1 unit away from the reference".

I'll use C as an example of this, although I am not making any sort of claims as to the origin or history of "counting from zero" - just giving a practical example that gives some sense to the practice.

In C, an array is referenced as []. Arrays aren't too complicated, they're just contiguous blocks of memory that contain multiple values, all right next to each other. The "address" portion will always be the same for any specific array, and the memory location of element you're referencing is computed as:

+ ( * size_of_item )

Now the C compiler knows the type you've given the array, so it takes care of multiplying the by the size of one item. So, to make things simple, let's presume you have an array of 1 byte elements. The address points directly to the first element in the array. So if you want to retrieve that element, you want to retrieve the byte located at . As the equation above makes pretty clear, element number "1" is going to be [ + ( 1 * 1 ) ] == + 1. Not what you're looking for! Element 0, however, fits the bill: [ + ( 0 * 1) ] == .

So oftentimes in programming counting starts at 0, because 0 means "the thing at the reference" and 1 means "the thing 1 unit away from the reference".

Someone tried it once....

http://en.wikipedia.org/wiki/Voodoo_5_6000

Oh god I know! Maybe if they'd given it a more generic name I could forgive them for it, but with a name like "Sins of a Solar Empire" it's just begging to have a plot. What are the sins???