On 10/3/2015 10:39 PM, Robert Green wrote:

As someone said in a movie once, "A man's got to know his limitations."
Would I try to run a leading edge graphics program on a clone? Probably
not, but I also saw plenty of people with legit IBM's and MACs go through
some serious tsuris trying to get things to work. The SW of that period had
extensive "complexity" issues exacerbated by a rapidly evolving HW base.

The bigger problem was the fact that the OS didn't isolate the
applications from the hardware. So, you had the CP/M mentality bleeding into
the PC world -- developers thinking they could freely play with aspects
of the underlying hardware "at will". Until those aspects didn't exist
in some variant of the machine they *expected* to encounter.

I had more problems with programs that used copy protection (like Lotus)
that required key disks or that secret sectors be written to the hard disk.
those programs invariably caused serious backup problems.

I believe that CopyLok or some such nonsense actually caused several of the
software companies that used that or similar technologies to go under.
People learned what happened to Copy-locked programs after the first system
restore and shopped elsewhere. I believe Borland began eating Lotus' lunch
over the copy-protection issue. There's poetic justice in a convoluted
scheme to protect against software copying that ignored real-world
consequences to users bringing a whole software company to its knees.

FutureNet/Data I/O had probably the nicest schematic entry (capture)
system at the time (DASH/STRIDES). They had a whole suite of related
EDA tools -- logic synthesis, device programming, etc.

But, were super paranoid about copy protecting EVERYTHING they
sold! And, tried a bunch of different *hardware* approaches to
the problem (even adding "protection" to a many thousand dollar add-in
"coprocessor" card that was required for some of their tools! WTF?
I have to buy this expensive board *and* another board in case I happened
to acquire the expensive board "for free"???)

One scheme used small registered PAL's (programmable logic devices...
precursors to FPGA's) as "keys". The thinking was that they could
implement a finite state machine (FSM) *in* the PAL using the PAL's
internal register to store the "current state". Then, supply new
"inputs" to the PAL from software running in the application and,
KNOWING how the FSM was designed, they could PREDICT the new state
that the FSM would enter given its "current state" and the supplied
inputs.

If you didn't know the logic governing the FSM's operation, you
wouldn't be able to predict the next state for all possible
input conditions (and for all possible "current states"!).

I wrote a tiny little program (two pages?) that would walk the
FSM through every possible set of states, applying every possible
set of inputs to each -- and recording the "next state" that the
FSM progressed into for each of these cases.

[This is actually tricky because you don't know where you will end up
at any given time -- yet, have to ensure you travel down every possible
path. Sort of like being deposited in a city and tasked with
making a map of all the roads -- without being able to *see* down any
of them! "I wonder where *this* will take me?" Obviously, you don't want
to keep taking the same path over and over again. Yet, need a means
of "discovering" every path that you aren't even aware of, currently!]

Armed with this "map", I then used the logic synthesis tool from that
same paranoid vendor to convert the verbose map into a concise set
of equations. The same set of equations that yet another of their
tools would then *burn* into a virgin PAL device -- giving me a
duplicate, counterfeit copy of the genuine "key"... all using THEIR
tools to do so!

Ooops!

[Of course, I had to own a legitimate key to begin with. All I've
done is come up with a way of creating a backup copy of that key!]