What Writing - And Selling - Software Was Like In The 80's

I started my career in 1981 working for 3 years at a defense contractor. By 1985 I started my first company to develop and then sell a spreadsheet like application for the Mac called Trapeze. It shipped in January 1987 but by the end of the year we sold it and then I started a new company to just develop for other people. We worked on the presentation app Persuasion (for the author) and then spent 6 years working on Deltagraph for its publisher.

So what was it like back then in the dark ages? Quite different than today in many ways; not so different in others. Warning, antique history!

I quit my job in late 1984 and then came up with the idea that became Trapeze. Like any young person with an idea I got people I knew excited and we got a group of investors together. As it is today there were people who liked to invest in new ideas but unlike today many of them had no idea what we were doing. The whole idea of software was unfamiliar to many. I remember talking with a banker who upon hearing we were going to work on software thought we were making lingerie!

There was little email (at my first job I had an email address outside of work but I only knew one person with one - my boss - and we sat next to each other at work) and of course no internet. Learning meant libraries, or magazines, or maybe a user group. If you wanted to know what a piece of software did you had to buy a copy. Just finding out what software existed meant reading ads or magazine reviews or a computer show.

We start development in late 1985. We had two 512K Macs and one Mac XL (a Lisa running MacOS) that had a small hard drive we all shared. I used the XL and the other two developers could access the hard drive over Appletalk. At first we used some C compiler who's name I don't remember, it was pretty slow. The linker spent most of its time drawing icons on the screen. At some point we started using Lightspeed-C (later named Think C) which helped a lot. We used C even though Apple had mostly Pascal interfaces because I thought C was the future.

Development was slow as we were basically inventing a new idea, working in a new language on a new platform, and on ridiculously slow machines (5 and 8 MHz) with tiny screens compared to today. In May of 1986 I went to the first Apple developer conference (not yet named WWDC) where basically the entire world of Mac developers showed up - we all fit in a single hotel ballroom! During the week Apple took us out on a boat in SF harbor for some fun, we all though it would be funny if we sank and the whole Mac industry vanished with us.

Today people think everyone did Waterfall in the "old days". We didn't even know that word and we never gave much thought to processes. We organized the app development into three pieces with a reasonable contract on an informal API. In fact it had to be informal as when we started C didn't even have prototypes - you had to manually make sure a function's parameter and calls matched! We also had no repository as there they weren't available on MacOS at the time, so we had to have a manual process to keep track of files. I did all the "official" builds.

In August we all went to Macworld Boston where we started doing press demos in a hotel room as well as wandering the floor looking at other people's apps. This was the first time I really saw what other people were doing (remember no websites, no free demos, spending money to even see an app) and was horrified by the interface I had designed. It reeked. Now that I could see other people's work it didn't measure up.

I would work 90 hour weeks for the next four months to completely rewrite the interface while supporting the old one so the other two could keep working. Of course while I was doing this I had to talk with the press, do demos, deal with investors, find suppliers, hire people, and all the usual business stuff. Unlike today you had to do everything yourself. Jolt Cola was my friend.

We finally shipped it at Macworld SF in January 1987.

Now what does that mean? Today shipping is nothing, push a few buttons and it's uploaded somewhere. In those days shipping meant floppy disk duplicators, printers for manuals, boxes, and actual shipping. Who did you ship to? Distributors and mail order houses. You rarely sold to end users. Distributors took cases of boxes, putting a short description into a paper catalog they gave to retailers. If they sold any they sent you a check 90-180 days later. Anything they didn't sell came back 6 months later. Mail order usually paid quicker. Distributors would pay you around 30% of the retail price; the mail order people were a little better. If you wanted a retailer to stock your app you were expected to advertise; no one did anything free for you other than put you in a catalog. This made making money a pain in the ass.

Of course potential customers had to figure out you existed, demand you from their retailer who hopefully ordered from the distributor. If they did buy a copy you only found out who they were if they filled out a registration card or called for support. When I think back at how crappy this all was I wonder why I ever got into it! Today it all sounds stupid.

We got a good review in Macworld, but the guy who wrote the MacUser review had a bad day and the review was horrible. Of course these were written in January and only came out 3 months later. The one bad review killed our sales. When the only source of information is reviews it only took one bad one. Being a small developer we couldn't fix it fast enough - it took months to make changes, ship it, and then wait for an updated review 4 months or so later in the magazine. A year later we met the author and he admitted he hadn't been fair and took his personal issues out on us. We sold Trapeze to a company in Boston which then split and formed Deltapoint in California. Eventually we would start Deltagraph for them.

Apple helped bring my second company together with the author of a drawing program who want to make a presentation program out of it. He had seen Cricket Presents in an early alpha and thought he had the right stuff to do one as well, but knew nothing of charts so that's where we came in. He and I sat in his condo in Brooklyn for 3 days and figured out what a presentation package should look like. He had briefly seen Presents and I knew nothing so we just made it up.

We worked in Texas and he was in New York, so since there was no email, we worked out a system by sending first floppies and later cartridge drives back and forth every other day, merging each side's changes by hand. Persuasion shipped in August, 1988. He had it published by Aldus. Eventually in the 90's it was owned by Adobe who killed it as Powerpoint become a virtual monopoly by being part of Office.

So in late 1988 Deltapoint and us decided to start building a charting and graphing program to challenge the market leader, Cricket Graph. Of course it was on Mac; Windows was not a viable platform until 3.1 in 1992. Everything appeared first on the Mac.

With Deltagraph we again wrote in C. We had 4 programmers including me, and one QA and the publisher had a product manager and another QA plus a lot of support people. They were in California and we were still in Texas and until 1990 we had no reliable email that could send binaries, so we still used Fedex. Until the last version we did in 1993 we were the only programmers. Each version would start with a page or two of ideas. We again broke the development into pieces with careful APIs. We still didn't have any repository software. Now that we had a real product manager we found it worked best to talk on the phone about a idea first; then often I would prototype it in Hypercard, Apple's nifty little app. Usually that resulted in speculative coding, we would write enough to build a version and send it via Fedex so that the product manager could see it. This would go back and forth until it was happy, or tabled. Note there was no advance planning; this was real lean type development long before agile existed as a thing. Everything in Deltagraph was built in parallel streams during the usual 6 to 8 month development cycle.

Now I had read at some point the famous Byte magazine Smalltalk issue and wanted to use OO programming in Deltagraph. Of course there was no language I could use yet so I rolled my own extensions to C, some incredibly lame ones involving switch statements. It made it easy to have a single output driver, and "subclasses" for each output type. This became Deltagraph's biggest feature; it produced Postscript and Adobe Illustrator native format files which meant you could build a complex chart in Deltagraph and then have your artist monkey with it in Illustrator. I reverse engineered their format. This format later become the basis of PDF.

We barely finished Deltagraph before the publisher ran out of money; we were actually owed $150,000 by the shipping date but it was a big hit and became a huge money maker for them. We worked on 5 major releases (the final one added programmers at the publisher).

Now in those days when you almost never sent out patch disks; generally you had to wait 6-8 months to ship a new version and you had to charge the customer for the update. Trapeze only needed one floppy but Deltagraph shipped on something like 10 disks. Paying for hundreds of thousands of disks is expensive; add to that printing of manual updates and boxes and shipping and you never did this casually. So the version we sent to the duplicators had to be perfect and live for months. I was always the final arbiter of what shipped. Thankfully we never had an issue with either 4 versions of Trapeze or the 5 of Deltagraph.

Of course we didn't write unit tests or anything like that; I never even heard the term until 10 years later. But we tested the builds continuously every day and kept careful record of anything that didn't work correctly. Having QA use the app all day every day from the start to the finish meant it was well tested by the ship date. It also helped in finding irritations in features or UI before the customers found it - use an app for months and everything bad is magnified! I still believe strongly that hard core continuous QA produces quality apps. I still try to get people to do this today and it gets the same results.

Deltapoint eventually sold Deltagraph in the mid-90's and it wandered around but is still available today; sadly still from the same codebase we started in 1988! It has to be seriously awful today, we wanted to rewrite it in C++ in 1993 but Deltapoint said no. Now twenty years and hundreds of engineers later it must be horrible. But for the longest time it was the standard for printed charts.

Hopefully you get a vague idea of what writing - and selling - software was like back then. Everything is so much easier today but users expect so much more, you need to ship continuously, feedback is instant but so is disgust and you have to know way more technologies to write anything. Back then all I needed was K&R C, Inside Macintosh and imagination.

The only thing I miss is the constant opportunity for invention: when you are doing something brand new and have nothing to help you it's all up to your imagination and creativity. There was no internet, no Google, no StackOverflow. It was just you and your friends and your brain.

Other than that I don't miss it at all but it was fun!

Edited since I got the Powerpoint dates wrong in the original.