Software may be getting worse, but it used to be horrible

I worked in early AAA in the late 90s, and it's true that games were often quite rough around the edges. But they were also often biting off WAY more than they could chew, inventing genres and innovating like crazy, often in messy ways that didn't always work. But that meant players were often also routinely and genuinely surprised by the experiences they encountered in even big budget games.

He lists a bunch of quality of life and balance issues that were fixed in Diablo 3 compared to Diablo 2... but, well, Diablo 2 was obviously _important_ in ways that Diablo 3 wasn't. It's a much greater game.

And lurking in the background is the hard fact that often the progress with software (certainly game software) entailed turning to much better software engineering standards, using much better external libraries or game engines with much larger teams, and relying on much more process to capture and filter all those rough edges... and along the way, you've built a much, much larger team with a much larger burn rate, and so all those experiments and innovations become much more dangerous and need to be corralled and controlled and mostly stifled, and as the cost of all this to build skyrockets your entire game design _has_ to focus on your business model and your microtransaction story and your live services first and foremost, because you've boxed yourself into a corner where that cash flow issue is the central fact of your game / software design.

(I experienced this evolution first hand in the FPS space)

All of which is to say, I think there are multiple different axes at play here for evaluation, and it's probably fair to say that software _undefinably_ was much worse in the past along some of them... but not all of them. And there are probably deep tensions and tradeoffs between some of those axes.

I think this entirely discussion really is muddied, though, too, by the fact that hardware got radically better over this entire arc as well, and so many programming techniques in the past that made software more brittle or crash prone hinged on memory and computation optimizations techniques that really had nothing to do with the software culture of then or now. It was just a response to the realities of the hardware.

Latency is one metric by which computing has gotten noticeably worse over the years.

Daily, I encounter multiple situations in which I take some action (click a button, type text in a text field, etc.) and the response is visibly delayed - from several hundred to several thousand milliseconds.

This used to happen only on websites, but lately is also happening on apps installed on my computer. The cause? My theory is that everything is now some sort of monstrosity of React or similar web app, running inside a browser process, and possibly even that local apps are sending data round-trip up to the mothership for tracking, surveillance, synchronization, etc.

And the UX is terrible - often while this is happening, stale data is showing, or there is no visual indication a process is underway.

If the complaint is vibe coding makes bad software, I largely believe it, but I absolutely believe that vibe arguing makes tissue paper arguments. “Everyone knows” and “it’s obvious” are flimsy things to rest arguments on.

I’m writing dramatically better software for all the reasons this post says obviously make worse software.

Testing has gotten much easier, and bug fixing has gotten much easier. I looked at a pre-AI project I did a couple of years ago: test to code LOC was 0.15:1. The projects I work on now are around 1.3:1. The old project had no accessibility considered at all, the new ones are nicely done aria and beyond. Old project is stuck on old libraries because upgrading is a major pain. New projects take new libraries (after cooldown) no matter the effort.

So I’m left thinking that perhaps some people, too lazy to use the new powers of new tools, churn out the same or worse quality code/essays.

But I am seeing a lot of very high quality software that simply wouldn’t have been possible before, and I believe the same could be done with essays by leveraging these tools to research and find real data beyond “it’s obvious”. But that does take a lot more work.

Since it was much harder to make stuff, you really had to architect it well or otherwise it would simply fall apart. For example in assembler you need discipline in your calling conventions, layout and so on, otherwise it just corrupted, you needed to follow sensible naming conventions otherwise it degenerated into unreadable label spaghetti and so on.

Nowadays it's the other way around, the micro level is so much better due to libraries, code reuse, LLMs and better languages/tools, you can use highly sophisticated data structures and functions at your fingertips. In exchange, you can afford to skimp on architecture because computers are fast anyway, and the programming languages don't let you make a huge mess. (Most don't have unstructured goto/jumps, can't corrupt memory accidentally, etc.)

However, this has the cost of making larger programs a nightmare to maintain and systems suffering from a "death of thousand cuts" i.e. on the micro level all is well but when you look at the entire system it's a sprawling unreliable mess. This is where rewrites often happen ;)

What popular consumer software today matches the incredible extensibility of Winamp?

Who is developing fun tools like Coverflow, which was popular enough that Apple incorporated it into iTunes.

You actually do see some of this today but it’s almost entirely limited to software tools, because software devs are willing to spend a little more effort on the tools they use because they know their users can just develop an alternative otherwise.

AI might change this, but well crafted software was genuinely disappearing for the past decade and a half.

That said, as a counter-point, there were also applications such as WriteNow which was ~100,000 lines of hand-coded assembly, which was quick and performant even on an 8MHz 68000 Mac Plus --- it flew on a 25MHz NeXT Cube (it was originally developed as a possible advanced MacWrite/replacement for it if it didn't ship, then was contracted by NeXT to make a bundled word-processor)

https://www.folklore.org/The_Grand_Unified_Model_The_Finder....

While I believe that the decline of the west started with the Reagan Revolution, that decline didn't show up in our consumer technology until about 2010. The best car motors, and the best version of Windows (Windows XP) were released in the mid-aughts.

- Purchased or downloaded a software package.

- Installed it onto your local machine.

After that you were free to do what you liked with the software.

Now software generally:

- Runs on someone else's computer, or is at least locked behind a login.

- Is served to you through a web browser.

- May be revoked or changed without notice at any time.

For this reason, regardless of reliability or capability, software was generally better in the past.

Software is bad when it's buggy, slow, bloated, annoying, distracting, anti-user, anti-consumer, anti-ownership, and rent-seeking. I pine for the days where something as simple as "wtf can't it autosave" be a reason to call software horrible.

For instance: an AI-assisted developer can probably make a pretty decent basic text editor, but let's say they need to make an entirely new type of app, then I think the new app will lack polish or finesse because no one has made that before. Or AI can help find bugs in mature, well-written code but what if someone needs to write a new kind of app? Then there's a lack of polish again...

- I've never heard or experienced NES cartridges rusting -- but I've had to blow on them, and I've had plenty of CDs scratched (typically when storing them without a case).

- Yes, Windows had significantly more blue screens; however, the cause of lost work was always failure to Ctrl+S (not a blue screen).

- Memory was certainly limited (and in DOS there mostly was no multi-tasking), but only fanatical players would run into the issue described. And you were aware that many games required a memory extender.

- Even now, games are massively hacked e.g. GTA V Online.

- My original PC had a TURBO button, but I never had to use it.

Snow Leopard on the macOS side of things, Windows 7 on the other, both offering marked improvements in stability and sandboxing over their predecessors. Shareware is booming, the first App Stores have only just launched, Facebook is still that place you share exam notes with your college classmates.

I remember these! I could not figure out why it never seemed to make the computer faster and actually made it slower. TURBO was even written in italics to imply speed.

I suppose for some short time it may have actually overclocked the CPU, until the default clock speed caught up. After that, the turbo button was a lie.

Edit: Maybe I have it backwards, it sounds like on some machines it might have been in the underclocked condition when it was off. I just remember disappointing results with the machine that I used.

Mandatory EULA must be banned. Any device must be usable and provide all features advertised without accepting an EULA.

The vast majority of software (past or present) is not distributed and therefore difficult to access. So I find when people talk about “software” in this context they often mean commercial “boxed product” software or software that otherwise has an end-user that is the general public rather than “all software”. That is simply the only neighbourhood of the software universe that most people are familiar with. Yet even if we were to restrict ourselves to that category of software there is a complete lack of convincing comprehensive comparisons. And even if there were it might only be an indication of a trend confined to that category of software.

Most commentators suggest the trend concerning software quality continues and may even accelerate in the future. So instead of trying to compare the present with an inaccessible past, why not compare the present with an eventual future? Design objective metrics and/or recruit esteemed judges for subjective assessments, then assess today's software and repeat this assessment a number of years later and compare the metrics.

I, for my part, as much as I dig a little 70s and 80s retro stuff, would never ever want to go back.

>Blue Screen of Death >Windows had extreme stability issues for most of my childhood.

I was a Windows system administrator from 1997 through 2013. In the beginning, we had issues with the blue screen of death in Office Professional and Windows 98. It turned out that when HP wrote their printer drivers for the LaserJet 4000 printers, they used an optimizing compiler, and it dynamically loaded floating point emulation.... and let it get unloaded, thus when you needed to compute page layout to print.... blue screen of death.

Once I solved that, we never had problems again, for over a decade!

Once we got to Office 2000 Professional, we stopped upgrading, and enjoyed 12 years of stability.

The only real problems were with the gigabytes of email people kept around, most of it in their "Deleted Items" folder, used as a filing cabinet, and the Exchange server that was full. They wouldn't let me buy a spare machine for to test out the email server backups, which naturally turned out to be a prayer in the end. 8(

----

>Nothing was secure Nothing has changed, it's still not secure, no matter your choice of OS. We're not running HURD or Genode on everything, or even Qubes. It's ambient authority everywhere, which is nuts in an era of persistent megabit internet.

----

>Software came on unreliable physical media That's what backups are for. I had a folder of all my CDs, that was included in my system backups. So, I could restore the domain server, restore the backup filesystems, then reinstall everything, without using any media other than the Windows Server CD (actually, a copy of it, with the serial number written on it)

That Office 2000 install should still work today, without buying it again. It's unlikely to get memory holed.

----

>Give me higher-level programming languages that abstract common pitfalls from C and C++.

Yep... Turbo Pascal, then Delphi, and now Lazarus/Free Pascal have done that since the beginning.

I don't think I've had to do that in 15-20 years or so. At some point, shit just started working. Simple as. DLL hell is a thing of the past.

Maybe choice might come back when some talented kindergartener or junior high schooler who doesn’t know any better comes along and kickstarts the process all over again?

A user of alternative systems from the 1980s, early 90s…

90s software ran mostly offline. It was simpler and more deterministic. I think that's why it felt more reliable. Your UI couldn't depend on laggy server round-trips. Things either worked or they didn't.

Oh gosh, and how could I forget the software crisis [2], a term coined in 1968, naming a problem identified long before.

Bad software is not a new thing.

[1]: https://www.stilldrinking.org/programming-sucks

[2]: https://en.wikipedia.org/wiki/Software_crisis

I think that software (and hardware) should be made in a better way which combines what should be good from new and old things, instead of necessarily avoiding what they were in the past due to thinking that the newer ones are somehow inherently better even though it is not that simple.

I will note that like any large enough company, it also employs a lot of cool people doing great work, and don't see this as a contradiction in any way

[0] https://en.wikipedia.org/wiki/Wirth%27s_law

The code I wrote was ugly yes, but vscode back when I wrote it was nowhere near that miserable.

The other day google docs started freezing, It got stuck on the creating sheet state.

Youtube is making my fans spin recently just because I am hovering over the play button.

God forbid you use a lesser known SaaS tool. I started a trial on a platform and it kept asking me to start trails because I suppose the modal system was just trash.

The list is endless.

Things just don't work as intended and I know hn gets very offended when you're critical of AI but I couldn't care less honestly because I have my own data. Vibe code slop is slop no matter how good you are with your "orchestration". Oversight is a side effect of vibes and no ambition.

I don't think the author understands what 'worse' means

If anything, software 'may' be getting worse due to non-programmers (vibe coders) releasing things they have no business making in the first place.

Today's software isn't even software. It's just a bunch of poorly made extraction machines backed by utter delusion that "it works" when a lot of it most certainly doesn't (or if it does, at best, it works as an efficient extraction machine and torture device with no real utility).

It seriously feels like we've been huffing gas for the last 15 years.

There were games released in a pre-alpha state (Big Rigs: Over the Road Racing), games that were basically released in a normal alpha state (Superman 64, Action52, etc) and there were games which literally didn't work because of major programming issues (SQIJ! had a player character which couldn't move due to the game only looking for lower case inputs while leaving the caps lock on).

And that's only the most extreme examples. Plenty of games had broken features and mechanics, or were outright impossible to complete due to poor level design and a lack of proper testing. Fan games, mods, ROM hacks and indie game scenes from the earlier days were just as notorious for works that were barely functional.

Generally games are at least now functional nowadays, with even the worst tending not to outright crash to a black screen or leave you with a player character that's completely unable to move. In many ways, the baseline level of competence arguably seems to be getting higher, with the march of AI meaning the worst is probably better than it might have been previously been.

Outside of games, it's worth noting how deeply insecure and flawed many older websites and programs were. There was a time where storing passwords in plain text was more of a norm, where input validation and sanitisation was often forgotten about, and where sites getting hacked was just as common an occurrence as today. Many Perl devs probably recoil in horror after hearing the term "Matt's Script Archive".

Are some things worse? Sure, performance seems to have become increasingly ignored in recent years, with web page sizes getting incredibly bloated and latency going through the roof. In some places there's more bad software overall, since the ability to vibe code it means non-programmers are building software more than ever. And some big companies that used to be respectable have let standards slip a lot (see Epic Games, Microsoft, etc).

Sturgeon's Law/Revelation held back then, and still holds today: 90% of everything is crap.

So now, it is worse than horrible.

Every time I open my phone, Google has a new "busy/loading" icon. Why?!

I'm truly horrified all that data is online somewhere synced from external sources in 1 dump.

On the end he said to me: you don't seem impressed...

He didn't knew a thing he was talking about technically. Barely even the db used ( postgres).

He mentioned sha256 for passwords, but doesn't know rainbow tables exist. If I would mention it to him to use a salt, he would probably break every login.

He has no dev and no test environment. Doesn't know about pr's, but he was proud he says he uses git and he "made" it.

It's under "NDA" and his step brother is checking it. Lol

The author then kids in [0] that the most popular software in Debian was editors to edit X86Config but...

I fully agree that Windows was an horrible crashing piece of crap back then. Linux was a godsend to me (installed it in the early Slackware days).

Armed with Emacs and LaTeX, on Debian 1.1 then 1.2, I wrote a 440 pages book (published by an editor).

Linux was already rock stable solid, while Windows was a crashing PoS.

Linux was so solid that I'd also run it on my laptop (and back then all laptops were crappy). When I was late I'd let LaTeX convert the files to .dvi (IIRC) and the PostScript while driving to my editor. We'd then the PostScript file to the printer at my editor.

It was something else then Windows.

As for Windows, yes, I was using it too.

And the absolute best software I ever got back then was Ghost, way before Norton bought them (it then became Norton Ghost). That allowed me to take a full dump of the Windows partition and then restore it at will from that partition, when Windows would invariably become unusable.

When I discovered Linux, suddenly I had a stable system that didn't need to be re-installed every other day. There's a reason the world is powered by Linux and companies like Google weren't built on Windows.

And I also had a small consulting gig (for little SMEs) where I basically had a business installing brand new Windows systems for the clients and all their stuff (like Outlook) and then immediately imaging the entire disk.

Because the only guarantee was that Windows would be borken rather sooner than later.

TFA is right and Microsoft has always produce mediocre shit.

It's hard to say if the BSOD'ing Windows of yore was even shittier than the ad-infested, surveillance, behemoth Windows of today. Both are equally bad IMO.

Because the day Microsoft shall product a product that doesn't suck is the day they'll start producing vacuum cleaners.

I have no problems with AI-written code and I've been a working programmer since the 90s. I don't even code review it as a matter of principle. I firmly believe that code itself has quickly reached an asymptomic value of $0, and if there are any bugs then just ask the AI to fix it.

He says that he learned to read around 1990, and just about remembers navigating computers in the mid-1990s and using them in the early noughties -- the 2000s.

So, earliest OS Win95, learning to use them WinXP.

That is the beginning of enshittification. Windows 3 is when the GUI came to the PC, but it's also the beginning of the era of PCs crashing all the time. It's also the beginning of the era of dial-up internet, meaning patches from online, meaning it was OK to ship bugs.

The previous generation of PC software was the height of the DOS era. Lightning-fast apps like WordPerfect, sold on their speed and their device support. If a printer could put marks on paper, WordPerfect would drive it, and drive it as well as it could be driven. Hacks like overprinting twice for bold, backspacing the print head and typing underscores for underlining.

People navigated documents by just pressing the cursor-up or cursor-down key and waiting: the text blurred into a flickering wall of grey as the text scrolled much too fast to read, but with skill and practice, you spotted the shape of the paragraph edges to spot where you where and let go, and it was tuned to stop instantly.

Computers were shipped with 1 app and used in that single app for years, sometimes for decades. Walls of floppy disk cases, thousands of media, hand indexed.

Speadsheets tuned to be no bigger than fit in RAM, and used daily for years on end, upgraded only for faster recalcs.

Home computers with libraries of tens of thousands of games, and not a single byte of update or bugfix in playable lifetimes of years, because there was no way to distribute updates, so you made sure it worked as shipped. Tiny playable imperfections became cheat modes.

In offices, multiuser boxes running OSes like Concurrent CP/M or, if you were richer, SCO Xenix, or for big corporations, OpenVMS, with uptimes in years. Operators who used apps 7-8 hours a day for a decade and who could navigate with keystrokes so fast that a CRT couldn't update quick enough to show the UI in time for their controls... and developers knew this and detected the keystrokes first and acted on them, and updated the display later when there was time.

Giant mainframes running hundreds of thousands of lines of code in 1960s languages, arcane and hard to modify, so they are still there 50 or 60 years later, buried under layers of terminal emulation and screen-scraping so now they look pretty. Still running natively on modern gigahertz-class bespoke CPUs today and every time you use a credit card or book an airline flight, it goes through that half-century old code.

Those enterprise minicomputers had clustering Linux will only ever dream of, with individual running processes able to migrated seamlessly from node to node across different CPU architectures, while in use. Cluster uptimes in decades. Still running today. OpenVMS is still being maintained, still running. So are all those IBM mainframe OSes.

Ever seen Tron? The big baddy is MCP, the Master Control Program. That was a real OS, an old fashioned one in 1982 when Tron was made.

It is still maintained. You can still buy it.

https://www.unisys.com/product-info-sheet/ecs/clearpath-mast...

It was released 65 years ago and there is a current version on sale. It was in production 8 years before Ritchie and Thompson typed the first line of UNIX into a terminal on their PDP-7.

Sure, it looks like it has got better, but only if you entered this world right at its lowest point. Before that lowpoint, before Microsoft subsumed the world in a second-rate copy of the best of the 1980s, SOFTWARE WAS BETTER.

Everything used to be horrible.

There were a few gems of good UI and functionality but they were rare and either got snuffed out by bigger companies like Microsoft or bought out and then forgotten.

Now, everything is more horrible than it should be.

It's like airplanes: Just barely 100 years ago, nobody could even dream that a common person could fly across the world to anywhere within hours.

Now we have planes and spaceships but they cram you in like cattle to squeeze into tiny inhumane chairs for hours..

The biggest companies in the world with hundreds of employees and billions of dollars still can't fix their software.

Google is still anal about dark mode if you're not signed in. Some other major apps don't even have dark mode even though it's been almost a decade since major operating systems supported it.

YouTube still hinders iOS's picture-in-picture feature.

Facebook still doesn't have iPad-native versions of their apps.

There's so much shit in apps with millions of users that hasn't been fixed for years.

And goobers act as if AI could possibly make it worse.

If it's getting worse, one can logically deduce that it used to be better

If it used to be better, why are you saying it used to be much worse? You cannot have it both ways unless AI already fried your brain.

...and if we are actually heading the wrong direction, why does it matter that we haven't regressed fully quite yet. AI is pushing us towards regressing fully. It's only a few miserable humans ranting about wanting a future filled with hope