|However, I am curious just how valuable the code in a PIC could be.  After
|all, we are only talking about 1K of assembler, not something like windows
|95 or anything.  It seems like the real commercial advantage is product
|design and marketing, not in the particular code in a PIC.  After all, it
|seems like given an arbitrary product with a PIC in it, I could just write
|code to do whatever the PIC does, without having to resort to bypassing the
|code-protect bit.

In cases where the PIC's behavior is well-understood, re-engineering
a 1K program is normally not a huge job, comparatively speaking (on
about the same order as engineering the surrounding hardware, more or
less).  The cases where the PIC's contents are extremely valuable are
those where important details of its behavior are NOT understood by
outsiders, especially if it's important to keep things that way.  In
some cases those details of its behavior may be worth $Millions.

This, more than any technical reasons, is probably why the 16C84's
code protection was the most-publicizedly broken.  Not because it's
weaker than other chips', but because (through no fault of Microchip's)
the 16C84 ended up being used in an application worth $big bucks.

Essentially, what happened was this: someone a few years ago managed to
decipher the encryption used in the DSS smart cards.  The original cards
were based on a proprietary CPU, and I don't know whether the person who
cracked the system did anything to crack that CPU's innards.  In an eff-
ort to capitalize on his discovery, he decided to write a PIC program to
emulate the decryption algorithm and sell black-market decoders using it.

Suddenly, while most 16C84 programs would have a value to a hacker of at
most a few thousand dollars, there existed a particular 16C84 program that
would allow anyone who could copy it the ability to make black-market sat-
telite decoder cards (which could sell for many $hundreds each).  With all
the efforts of would-be sattelite pirates focused on it, it should be no
surprise that the 16C84's code protection was broken.

So while on the one hand, you're correct that there is limitted value in a
1Kx14 program, there are cases where such a program's worth far exceeds its
"intrinsic" value.