Jul 16, 2018
One of the first products I created as a software developer was a touch-typing program called Typing Instructor .
This was back in 1985, and at that time there was no such thing as a standard PC.
Instead you owned a specific brand and had access to the programs that had been written specifically for that make, whether IBM, Wang, or DEC.
Each of these companies was attempting to create lock-in for their third-party software developers.
If a user wanted a specific application, they needed to own the computer for which it was written.
Now, was this a good thing or a bad thing?
All of these brands approached the problem in unique ways.
Compaq, a dinky start-up in the 1980s, had the most expansive philosophy about building their business.
The team at Compaq realized that to win against the industry strategy of creating unique, proprietary PCs, they must push for PC uniformity.
They decided to make their products compatible with IBM.
Similarly, IBM licensed MS-DOS, a Microsoft operating system designed specifically for their PCs, a decision that subsequently made a fortune for Bill Gates.
On the other hand, companies like DEC and Wang thought they could create some unique differentiators that would make the software developers come to their platforms first.
Wang was especially notorious for wanting to keep their programs proprietary.
Because the PC manufacturers were in a fight to dominate the market and win over the largest market share as quickly as possible, locking a customer into using their brand and making it as hard as possible for the customer to switch in the future seemed like a good idea.
One of my first jobs in computer engineering was with a company called Individual Software.
I was twenty-four at the time and married with a kid when Individual called me.
I knew these guys, and I had faith that they were going to do interesting work, and that it would be a good place to get in on the ground floor of a booming industry.
I talked to my wife and we packed up our lives and drove west to Silicon Valley.
Individual had some ideas for programs, and one of the first that seemed to have real potential was a simple program to teach touch-typing.
Think about it—home PC use was exploding.
Even if a user didn’t need touch-typing at work, they were soon going to start wanting it at home.
My colleagues at Individual and I got together and started throwing ideas around.
Once we’d decided what kind of program we wanted to write, the second question was What PC are we going to write it for?
This was in the early days of Silicon Valley.
Individual was at the crucial phase of a young, start-up company.
We had the resources to make one or two moves, and if these moves didn’t work, we were going to be out of cash and out of luck.
One of the biggest stumbling blocks was the fact that in the mid-’80s there were easily a dozen different major PC manufacturers in widespread use.
While each of these companies used the same OS, they all tweaked it by adding custom code to MS-DOS to make it work with their hardware.
Clearly some of these PC companies were going to fail, but there was no guarantee about which company was going to win.
Since each of these PCs required its own version of your program, how could you decide which one to write for?
Individual needed to get products out to as many users as possible to survive, but any choice we made was automatically going to eliminate the majority of our potential customers.
Writing an individual program for each operating system was not financially possible.
We had limited research and development (R&D) dollars to spend, and the future of our company was riding on making the best choice.
So what do you do?
Traditionally a company like ours would write a program, and then spend a lot of R&D dollars on porting it to as many operating systems as possible.
However this wasn’t going to work for us.
We couldn’t afford to do it.
We had the budget to write the program once, but if we only wrote it once we weren’t going to be able to sell enough copies to ever make a profit.
How could we take those R&D dollars and put them into an approach that would allow us to create a standard product once rather than multiple custom versions?
We turned this question over and over in our heads.
Finally, we did what innovators throughout history have done in this kind of situation.
We said, “Forget the obvious solution,” and we decided to take a crazy gamble.
Instead of writing a program specifically for an IBM or a Wang, we took the same amount of money and created a software engine that essentially worked as a universal translator, and allowed the same program to run on any of the existing PCs.
While the industry, thankfully, has moved away from proprietary PC platforms, developing the translation engine rather than worrying about the program was a 180-degree turn from what was the norm at the time.
It could have killed our company and left us all out on the street, yet it paid off.
If you go into a big-box computer store today you can still buy a copy of Typing Instructor more than twenty-five years after it was first written.
It’s not hip, it’s not glamorous, but it worked—really well. And that’s what counts.