Ask HN: What was being a software developer like about 30 years ago?

I would like to know! I can go back 22 years. Then, jobs were more likely to be apps running on Windows. People yelling at screen because things aren’t rendering properly (render as in pixels, not virtual doms!). No unit tests. Sourcesafe (old buggy but simple to use VCS). You could exclusively lock a file to annoy other developers and stamp the importance of your work. No scrum and much less process. 9-5 ish and no time tracking. No OKR or KPI. Do everything with Microsoft tooling. No open source tooling. Someone’s job to build an installer and get it burned to a CD (the optical storage medium). There was some automated testing but no unit test or CI/CD. Not so many “perks” like swazzy office, toys, food supplies etc. If there was webdev it would be in ASP or ActiveX!

  The dominant position of Microsoft’s proprietary IIS in the Fortune 500 makes Windows NT a lock for the most used operating system undergirding the Web servers -- 43 percent. But the idea that Sun Microsystems Inc.’s Internet presence is weakening isn’t supported by the numbers. Sun’s Solaris holds a clear second place at 36 percent, with all other operating systems falling into the noise level. Linux showed up at only 10 companies.

You had to know things and keep them in your head, and have a pile of text books otherwise! Plus no normal app had access to gigabytes of storage, and indeed that was a vast amount for many years more[1]. Skills learnt then in terms of memory and CPU efficiency are still valuable now, though your typical smartphone is more powerful than the supercomputer replacements I used to look after for an oil company...

[1] https://www.amazon.co.uk/Managing-Gigabytes-Compressing-Inde... (1999)

You could have a highly proscriptive spec, or almost none. It depended what kind of s/w shop you worked in.

I interviewed candidates for a sw position who fronted with serious lisp experience on live deployment: traffic lights control systems. (We wanted C. But it stuck in the mind)

Compile-Edit cycles could leave you time for lunch.

SCCS was still in use, RCS was just better.

You had to understand byte/short/word/longword behaviours in your compiler. Unsigned was tricky sometimes.

FP error was common. Not all the bugs were ironed out of libraries (NAG aside. They were really reductionist)

Use of global variables was not yet entirely anathema

The CPP could run out of #defines still.

Pdp11 were getting more uncommon but not dead. VAX were common. Sun's were 68000 mostly.

There was a gulf between IBM and their seven dwarves and everyone else. UNIX was not quite ubiquitous off campus but becoming so.

I was doing Turbo Pascal, C and assembly back then. What I liked better, at least where I was and worked, what you had in your head was it. There were libraries, but, at least where I worked, not very many and it was tedious to get them, so you just rolled your own.

Focus was more (again, for me) on doing clever stuff vs, what I do today, integrating stuff and debugging stuff made by other people.

Compensation was lower than it is now (obviously?), but it was, similar to now, higher than most jobs. 30 years ago, unlike 40 years ago, you already could get jobs/work without a degree in software, so it was life changing for many, including me, as I was doing large projects before and in university which gave me stacks of cash while my classmates were serving drinks for minimum wage and tips.

I guess the end result these days is far more impressive in many ways for the time and effort spent, but the road to get there (stand ups, talks, agile, bad libraries/saas services, fast changing eco systems, devops) for me has mostly nothing to do with programming and so I don’t particularly enjoy it anymore. At least not that part.

Process reflected that; our team just got a stack of paper (brief) and that’s it; go away and implement. Then after a while, you brought a cd with the working and tested binary, went through some bug fixes and the next brief was provided.

One of the stark differences I found, at least in my country (NL), is that end 80s, beginning of the 90s, almost all people told me; you program for 5-8 years and then become a manager. Now, even the people who told me that at that time (some became, on eu scale, very prominent managers), tell me to not become a manager.

    Process reflected that; our team just got a stack of 
    paper (brief) and that’s it; go away and implement. 
    Then after a while, you brought a cd with the working 
    and tested binary, went through some bug fixes and 
    the next brief was provided.

I guess you had to learn things since there was no Google and Stack Overflow.

Let's see (wow, is it 30 years already?)

- I worked on C code, it was nicely logically divided into libraries and folders and you could build one folder at a time to save time.

- I was still young and not exposed to processes but there were signs (paper signs) in the corridors about RAD (Rapid application development) and QA was a separate department, only my manager talked to them.

- Compensation was rather good and very few years afterwards it become even better

- WLB was non existent, but again I was young and didn't care

Things were simpler, I knew the code down to which bits the CPU flipped, debuggers used primitive DOS GUIs and source control was something we considered starting using.

Fun!

Precarious. Very slow. Like a game of Jenga, things made you nervous. Waiting for tapes to rewind, or slowly feeding in a stack of floppies, knowing that one bad sector would ruin the whole enterprise. But that was also excitement. Running a C program that had taken all night to compile was a heart-in-your-mouth moment.

Hands on.

They say beware a computer scientist with a screwdriver. Yes, we had screwdrivers back then. Or rather, developing software also meant a lot of changing cables and moving heavy boxes.

Interpersonal.

Contrary to the stereotype of the "isolated geek" rampant at the time, developing software required extraordinary communication habits, seeking other experts, careful reading, formulating concise questions, and patiently awaiting mailing list replies.

Caring.

Maybe this is what I miss the most. 30 years ago we really, truly believed in what we were doing... making the world a better place.

I was working in Pascal, C and assembly about 30 years ago, mostly in DOS and Windows 3.

By 1995 I started dabbling with websites, and within a couple of years was working mostly with Perl CGI and some Java, on Windows and Linux/NetBSD.

Most of my work was on Windows, so that limited the available Perl libraries to what would run on ActiveState's Perl.

I gave up trying to do freelance because too many people didn't seem to understand the cost and work involved in writing software:

- One business owner wanted to pay be US $300 to fix some warehouse management software, but he'd up it to $500 if I finished it in one month.

- A guy wanted to turn his sports equipment shop into an e-commerce website, and was forward thinking... except that none of his stock of about 20,000 items was in a database and that he could "only afford to pay minimum wage".

I interviewed with some companies, but these people were clueless. It seems like a lot of people read "Teach yourself Perl in 7 days and make millions" books. The interview questions were basically "Can you program in OOP with Perl?".

I got a proper developer job on a team, eventually. They were basically happy that I could write a simple form that queried stuff from a database.

Some other people on my team used Visual Basic and VBScript but I avoided that like the plague. I recall we had some specialized devices that had their own embedded versions of BASIC that we had to use.

When Internet Explorer 4 came out that we started having problems making web sites that worked well on both.

Web frameworks didn't exist yet, JavaScript was primitive and not very useful. Python didn't seem to be a practical option at the time.

I was a programmer back in the MS-DOS and early Windows days. My language of choice was Turbo Pascal. Source control consisted of daily backups to ZIP files on floppy disks. The program I wrote talked to hand-held computers running a proprietary OS that I programmed in PL/N their in house variant. The communications ran through a weird custom card that talked SDLC (I think).

I was the whole tech staff, work-life balance was reasonable, as everything was done turning normal day-shift hours. There was quite a bit of driving, as ComEd's power plants are scattered across the Northern half of Illinois. I averaged 35,000 miles/year. It was one of the most rewarding times of my life, work wise.

The program was essentially a set of CRUD applications, and I wrote a set of libraries that made it easy to build editors, much in the manner of the then popular DBASE II pc database. Just call with X,Y,Data, and you had a field editor. I did various reports and for the most part it was pretty easy.

The only odd bit was that I needed to do multi-tasking and some text pipelining, so I wrote a cooperative multi-tasker for Turbo Pascal to enable that.

There weren't any grand design principles. I was taught a ton about User Friendliness by Russ Reynolds, the Operations Manager of Will County Generating Station. He'd bring in a person off the floor, explain that he understood this wasn't their job, and that any problems they had were my fault, and give them a set of things to do with the computer.

I quickly learned that you should always have ** PRESS F1 FOR HELP ** on the screen, for example. Russ taught me a ton about having empathy for the users that I carried throughout my career.

You would spend a lot of time and effort doing very simple things by today's standards. There was also a lot less information, especially if you didn't have an Internet connection.

But it was also fun and worth doing.

Personally I wasn't working yet, 30 years ago, so that was just my own side-projects when I had a chance.

Lots of books! We had the internet but it wasn't very useful for looking up information about programming. We had usenet but it would take a while to get an answer, and often the answer was RTFM.

But what we did have were O'Reilly books! You could tell how senior an engineer was by how many O'Reilly books were on their shelf (and every cubicle had a built in bookshelf to keep said books).

I remember once when our company fired one of the senior engineers. The books were the property of the company, so they were left behind. Us junior engineers descended on his cubicle like vultures, divvying up and trading the books to move to our own shelves.

I still have those books somewhere -- when I got laid off they let me keep them as severance!

In addition to what others have added: monthly magazines like Dr.Dobb's Journal, were eagerly anticipated, and this was _the_ way to keep my skills "modern". User Group meetings, and rare conferences which were vendor-driven, were others.

It was you and the black box. Manuals helped a bit. Books helped a bit. But largely it was you and the stupid box.

Well, suns and sgi’s. 3D graphics with OpenGL. Supercomputers yielding to mini-supers for a brief time before the hp pa-risc came and killed them all. Superscalar machines and programming - daxpy’s and vector masks. Lots of multiprocessor development. Still a lot of disk striping as both memory and disk space wasn’t “unlimited”. Rs6000’s pushing cad/cam onto workstations. Being able to do fluid dynamics calculations led to soap bar cars.

Lots of good Unix work came from that time which fell into place when Linux appeared. Things ported from there to Linux pretty painlessly which greatly reduced the cost of hardware. And that World Wide Web thingy that started to appear was pretty neat even at 19200.

A rite of passage, that current generation of Python programmers will not experience thanks to it's insanely better error handling, is the missing semicolon problem. Being a software developer 30 years ago included losing 4 hours of your life debugging a program, only to find it was because you missed a semicolon somewhere.

Slow network (1Mbps), slow computers (16MHz?), 1MB RAM, spinning disks, tiny screens. Only thing you might recognize from a developers desk back then was the keyboard. Even the mouse was mechanical and had a cord and wasn't USB.

Bad enough to make you want to quit.

People nowadays complain about algos and red-black tress but honestly, that was the easy bit. Wasn't much open source, so you had to build pretty much from scratch. Internet was young and empty, so big fat books were how you learned. No condensed version or easy trouble shooting. C and C++ were as dominant as Python is today, but nowhere near as fun. (https://xkcd.com/353/)

In short, the deal was to be a cog. If you were good as a small cog, you'd move up to be a bigger cog. Then you could manage a few cogs doing a tiny bit of a huge machine. The scrappiness of just throwing things together and getting something meaningful quick simply wasn't there.

I left, spent 15 years of my career doing decidedly different things, and when I came back I was overjoyed with how little code you actually needed now to get stuff done.

Good times. Most of us hadn't gotten "high on our own supply" yet, and the field was wide open.

You got the feeling of a thousand developers all running off in different directions, exploring the human and condition and all of the massively cool things this new hammer called "programming" can do.

Compare that to today. Anywhere you go in the industry, it seems like there's already a conference, a video series, consultants, a community, and so on. Many times there are multiple competing groups.

Intellectually, it's much like the difference folks experienced comparing going cross country by automobile in say, 1935 versus 2022. Back then there was a lot of variation and culture. There was also crappy roads and places you couldn't find help. Now it's all strip malls and box stores, with cell service everywhere. It's its own business world, much more than a brave new frontier. Paraphrasing Ralphie in "A Christmas Story", it's all just crummy marketing.

(Of course, the interesting items are those that don't map to my rough analogy. Things like AI, AR/VR, Big Data, and so on. These are usually extremely narrow and at the end of the day, just bit and pieces from the other areas stuck together)

I remember customers asking me if I could do X, figuring out that I could, and looking around and not finding it done anywhere else. I'm sure hundreds, maybe thousands of other devs had similar experiences.

Not so much now.

24(1998) years ago we paying $1000 per MB to access a computer network at 2400 baud for EDI (electronic document interchange) to Sterling Commerce for swapping files with vendors. This was pricing and tech from 1990. The modem cost $~800 as it was a different format somehow. I thought this was all insane having an personal 128K ISDN line at home and Netscape was a 16MB download. This would be $16,000 download, the price of a new car!

My mother used to be a developer, she worked with .NET mostly for a company called ITC Infotech about 20ish years ago. Anyway, I found a old paystub of hers which was for 20K many years ago while helping her sort out some financial stuff. Which was interesting cause that was what I got as an intern with zero work-ex about 18 years later. (Obviously 20K was a lot more then than it was now). Her work was definitely frustrating as she jumped jobs to a couple of companies, Satyam and then later,Dell before deciding to do an MBA sometime in the 2010s.

EDIT: The values are in INR.

I was seeing the question and started wondering how that time might have felt for those people… only to notice a few seconds later that I already did software development 30 years ago. Oops.

Started off writing a typesetting system in BCPL on a PDP-11 with our own custom hardware for display and our own protocol for sending information around with no internet to look things up and a fine of donuts for the team if you blew an overlay with too much code in it which caused hours of downtime. Then Sun workstations came out and we ported everything to C and productivity increased and WYSIWG became possible.

No concept of unit testing, integration testing or CI - customer support gave things a quick look over and the program got sent out so we always scheduled a 2 week Bug Blitz to deal with all the issues that the customers found.

Small company, salary was good, regular hours and a challenging environment with all the rapid tech changes

The thing I remember most about those days was how often I went to Barnes & Nobles. You simply couldn't find the information online at that point. I'd go and buy a coffee and sit with a stack of books on a given topic I needed to research; then after ~45 minutes I'd decide and buy one or two books, and head back to the office to get to work.

I built my first website in 1993, about a year before Netscape Navigator was released. There were no books, there was no javascript, no css. There was no PHP. It was just me, View Source and a netcom html hosting page.

When I went professional in 1998, the .com boom was underway. It was a wild time full of challenging work and exponential rewards. The hours were long, the pay was crap, and the value of programming wasn't fully acknowledged.

Compare that to today. I have banker hours. The pay is great. My job appreciates me. However, my coworkers are all 20 years younger than I am and make similar or more pay with half my experience. But, experience beyond 5 years in this industry doesn't matter because it's irrelevant. Only the mention of huge company's names in my resume are worth something beyond 5 years.