1 {scene: The pirate ship Allosaurus, at sea.}
1 Long Tom: Arrr, it be good to be havin' the wind at our backs again!
2 Parrot: Awwwrk! Pieces of eight! Pieces of eight! Pieces of nine! Pieces of eight!
3 Long Tom: What be the problem with that scurvy creature?!
4 Wendy: A parroty error, cap'n.

Pieces of eight refers to the silver coins known as Spanish dollars that circulated
from the 16th to 19th centuries, and traditionally formed large parts of pirate treasure. This dollar was subdivided into eight reales,
which were often physically realised by cutting a silver coin into eight more or less equal pieces. Thus "pieces of eight".

Computer programmers will need no further explanation.

For the rest of us: Parity basically means equality. In mathematical usage, it refers
to the concept of things being divisible into two classes, most usually referring to the classification of whole numbers as either odd or even.

Computer science has taken this meaning and extended it to refer to the "oddness" or "evenness" of a piece of binary computer data. Binary
information is stored as a sequence of individual pieces (called bits, short for "binary digits"),
which come in one of two different possible values, conventionally represented by the digits 0 and 1.

For example, a piece of binary data might look like 1101000, which might represent, say, the letter h. Now looking at this sequence merely
as a number, you would call it "even", since it ends in a zero. A more useful definition of parity for computing turns out to be what you get if
you add together the individual bits of the data. In this case, there are three 1s, an odd number, making the parity of this bit sequence odd.

In some cases, when binary information is transmitted from computer to computer, or within a single computer (say from
hard drive to processor), a bit can accidentally get "flipped", or changed from one value to the other. This is bad, because the sequence
1101010 - just one bit different to our h - might represent the completely different letter j.

Notice that flipping a bit has changed the parity of our h from odd (three 1s) to even (four 1s). If it had been
changing a 1 to a 0, the result would also be even (two 1s). Here's the clever part. What if we add an extra bit to the start of our piece of data,
where the value of the extra bit is determined to make the overall parity of our data even?

In that case, our h would be represented by 1101000, with an extra 1 stuck on the front: 11101000. The parity is now even. How does this help?

Well, the letter j would be represented by 1101010, with an extra 0 stuck on the front, because its parity is already even: 01101010. This leaves
the parity even.

Now what happens if we have the same transmission error that causes the same bit on our h to flip? We end up with 11101010. Notice two things:
This is not the same as our new representation for the letter j, and, more importantly, the parity is now odd. This tells us two things:
that the data we have received is definitely not a letter j, so we don't make the same mistake as before, but also, because the parity is odd
and we know that the parity of all our data should be even, that an error has occurred.

Before, without the parity bit, if an error occurred, we would misinterpret our data and carry on blithely unaware. With the parity bit, we know
that an error has occurred, and can do things to fix it, like send a request back to the original source of the data and ask for it to be sent again.

Clever, huh?

Some of you may be wondering: What if two bits accidentally flip? Well, in that case, our simple one-bit parity check would fail. But the chances of
getting a two-bit error are much less than a one-bit error, and that may be an acceptable level of risk. If not, then there are more complex schemes that
involve adding additional parity bits according to more complex mathematical rules, which can solve that problem. But that's about all you really
want to know about that. The basic principle is the same.

So a parity error is what you get when you were expecting all of your data to be even, and suddenly you get one that is unexpectedly odd.

Oddly enough, the cut up sub-coins of a Spanish dollar, of value one real each, were known as bits.

2016-10-08 Rerun commentary: I'm sure there's another pun somewhere in the fact that the eight pieces made by cutting up a Spanish dollar are called bits. If I'd known that bit of information[1] before writing the comic, I might have done something with it. But I only discovered it while researching pieces of eight to write the annotation, after the comic was done.

I should have given this parrot more lines and made it a recurring character. Hmmmm.