/Ask HN: Old guys, what do you miss about development in the 70s, 80s, 90s, 00s?

Ask HN: Old guys, what do you miss about development in the 70s, 80s, 90s, 00s?

Developers being far less critical of other developers.

We were much more positive in the olden days. Back in the 90s you could post an idea in a developer-oriented usenet group or discussion forum and get pretty decent feedback. If you do that today there’s good chance you’re going to either get nothing back or you’re going to be flamed for using an “anti-pattern”. People are far too quick to dismiss things now.

It’s probably a function of how everything gets marked with a score now and every post is social proof, but it’s quite annoying regardless.

On reflection, the thing I miss about web dev in the ’90s is the low user expectations.

Because I was going to say I missed the simplicity of it all — your front end was just HTML, no CSS (which didn’t exist yet) and only sometimes a smidgen of Javascript for like light form validation; your back end was just a Perl script with CGI.pm running behind Apache that rendered that HTML.

No React, no flexbox, no REST API, no microservices, no Docker, no Kubernetes… but the reason it didn’t need any of those things is because it had a terrible UI, didn’t do all that much, and only needed to support trivial numbers of users whose modems were probably the main bottleneck anyway.

Trying to make modern users happy with ’90s era tech would be impossible and deeply painful.

But it was nice, just for a while, to have a world where people were thrilled that even a super-basic web application was a thing that existed.

I still make websites this way because no-one told me to stop. They can be made responsive to things like smartphone browsers which incredibly minimal changes. No complaints so far.

Worked in SW since early 90s. Back then you didn’t have to think much about security and you could push things to the limit.

Also things were not as “professional”. When I started out my boss told me to figure something out and I would report back weeks or months later. I had the time to make mistake and learn from them. Today the young devs are often very micromanaged and have no freedom.

On the other hand we can do a lot of cool stuff today and it’s amazing how much info is out there. But I think the 90s were more creative. Stuff like StackOverflow is great. Documentation was MUCH better in the 90s.

That you could buy a book, read it, and then know literally everything about a particular system. And often that book came with the system.

So much this. It ties in with my other comment, to some degree.

Someone here mentioned StackOverflow, but really, a handful of manuals, maybe a good book or two, and some persistence, /usually/ gave you all you needed to figure out a problem, and do something magical.

Now, those resources (if they’re available) will likely only help you understand a very small subsystem.

I appreciated that the behavior of that system was fixed for a certain period of time. That word processor would work the same for all eternity (warts and all) if you didn’t intentionally get a version upgrade.

Elegant, tight, and efficient code mattered back in the days when a machine with a 20 MHz processor and 8 MB of RAM was considered a high-end workstation. You really had to understand what your hardware, your OS, and your compiler was doing in order to produce decent software.

Nowadays, such esoterica is relegated to the tiny niches of systems and embedded development.

There were very few ready-made frameworks and libraries to get things done, so it was fun writing those meta libraries that runs your business. Of course, purely from a business point of view, this is not ideal and is extremely wasteful. At the same time, it really helped me understand the systems that we use. Maybe that’s why people survived without Stackoverflow 🙂

In comparison, modern software development is almost all about composing or stitching together a bunch of different services. There are other complexities around orchestration and breadth of the systems involved, but very rarely one goes deep into a particular technical problem.

After a really long time, I’m getting a kick out of working on a highly technical problem: an open source search engine from scratch (https://github.com/typesense/typesense). It has been deeply rewarding and definitely something that’s missing in a typical web oriented software development career today.

There was a lot less stuff, in general. Now you have libraries, protocols, umpteen different languages, paradigms, design patterns, IDEs, runtimes, platform after platform, etc.

I remember all I used to need was a C compiler and a task and basically alone I would be able to complete it with the standard stuff that came with the compiler.

I was tempted to write “computers were so slow and lacking in resources that you were forced to write efficient code”. Because efficient code is good, right?

But I lived through that era and being forced to write efficient code is a god-damn nightmare. There were so many ideas flying around that you simply couldn’t do because the computing power just didn’t exist.

Today people revere things like “vi” but when you were forced to use such basic utilities because your human/machine interface was a 300 baud modem, or even a paper teletype, life wasn’t so good.

Nostalgia isn’t what it used to be.

Main thing I miss is the lesser degree of abstraction in doing anything. If you wanted to build a simple app which just took one input and did a calculation and returned a result, there were multiple languages, but you didn’t need a huge number of libraries, infrastructure, etc. to deploy it — you just built the code, compiled it, and distributed a binary (and source, with a makefile). There was complexity crossplatform (even across unixes), but there was a period of time in the mid-90s/early 00s where “some form of linux or a BSD” was all I had to care about, and it was pretty easy.

Also, being able to trivially modify almost anything I used (because it was largely open source, and simple).

Lots of things were worse, but less abstraction was pretty nice.

No DRM. No walled gardens. You could write code on your own computer without needing Apple’s permission to code sign it.

Agree. I’m around students often. The way they treat me is pretty alienating. I liked the Sir Davos quote from GoT “the young treat us old people with respect because we’re an uncomfortable reminder of the inevitable.”

Speaking as someone who cut my teeth in the 80s and early 90s: I miss the elitism and exclusivity of it. Nowadays the internet has made it so any question can be answered within seconds, but back then you had to scrupulously acquire your information from magazines, Usenet discussions, and just plain experimenting with the code. As things currently stand, programming has become a commodity skill that anyone with a room temperature IQ can learn within a reasonably small time frame. Then, you get on StackExchange and start cobbling together your app from copypasta provided by other programmers.

Things have been dumbed down considerably.

Among other things, yes.

For example: On an IBM PC, running DOS. You could know all there was to know about the BIOS, hardware ISRs, DOS ISRs, DMA, how a file system works, and maybe a bit about the graphics system, and you could make the machine do anything you wanted.

Today, if my kid wanted to learn all those things, I wouldn’t even know where to tell him to start. You simply can’t get that low (easily) anymore, or know that much about numerous subsystems. And the higher level stuff, like you say, is buried in layers of abstraction.

Of course, now we have an unprecedented access to cheap, powerful microcontrollers and SBCs, which make up for it to some degree – but it’s still harder to translate that knowledge into something of perceived usefulness on a ‘proper’ computer.

Late 90’s here.
There are two things I miss:
1. Going to the book store and looking through the (mostly) O’Reilly books to see what there is to learn or what new technologies are coming out.
2. Having a huge pile of 3.5″ floppies (or even CDs) you are using to load the latest version of Visual studio or whatever and just imagining how much knowledge is contained in those. I think my copy of VC++ was something like 21 floppies.

I miss building everything from scratch, in assembly, because I could do it better than the libraries that shipped with the system.

I can still do it better today, but the stack is so deep now, I just don’t have the time.

Would I go back if I could? Nah.

Hacking is a blast, but never forget it is to achieve a greater purpose. A greater purpose for our software’s users, for ourselves, and for for our subroutines.

Old hackers never die— we merely gosub without return.

Not having so many plug-n-play abstractions that you’re so strongly encouraged to use to “not re-invent the wheel”. The problem in my mind is that the abstractions leak all over the place, but we stop caring.

Pushing off compute to the browser because it’s cheaper, nevermind the cost to non-powerhouse phones.

Avoid putting any thought into optimization because compute and memory is cheap. Nevermind that you’ll have to do a complete re-write when a few dozen 600+ ms microservice responses results in 20 second page loads.

Store all the things! You might need them someday, after all. GDPR what?

I work with developers who think that DB migrations are “of the devil”. As a result, they have pivoted to use the RDBMS as a rudimentary k/v store and create the relational data structures in memory. All they need to do is pull a few dozen GB of rows from the DB with every container restart.

So, yeah. I miss having fewer abstractions; having more constraints. The software seems somehow nicer through the CRT-colored lenses.

I miss dump reading on reams of green-bar paper.

The dump reading was done with a cardboard pamphlet that listed the machine instructions, arguments, address offsets.

You’d find the hex abend on the greenbar, mark it up with a pencil, and use the machine instructions to figure out what went wrong (and the record that caused it).

In my business (banking) this was done sometime around 2 a.m. after you got called back to work by the night operators.

Ah, the good old days.

Just the sense that we were on the cusp of some magical, new, civilization changing thing.

I don’t get the same sense that stringing lines of code together can change the world, largely because, where it could, it mostly already has (I am not a believer in the latest wave of AI hype).

What we did used to be magic and was met with gasps and now, it’s mostly just expected and complained about if it breaks :/

Original Source