On the other hand, the reality experienced by software companies is that adding features is profitable. Joel Spolsky talks about this in one of his old blog posts[1]: "I can tell you that nothing we have ever done at Fog Creek has increased our revenue more than releasing a new version with more features."

It makes sense though, if software companies could make just as much money doing less work, they certainly would.

[1] https://www.joelonsoftware.com/2006/12/09/simplicity/

There's really nothing wrong with new features as long as you understand that there's a certain subset of users who don't want things to change. Maybe it's because people are already trained on the current version, or they don't want to have to upgrade machines just to run the new feature set, or any of a thousand reasons you may not have thought of.

And then there are the "upgrades" that try to force you to pay more.

There was a dev tool that I purchased a couple years ago. Don't remember the name. It was reasonably priced and came with 1 year of support. A bit over a year later I got a notification that they had put out an update, so I downloaded it to take a look, only to find out that it had deleted the version I had bought and my license wouldn't transfer over. If I didn't now buy this new version, not only could I not use it past the trial period, but I'd lost the version I had before.

Yeah, I was pissed. And the company really had trouble understanding why I was so pissed off by this behavior. I did finally find out where I could download the version I had before, but there went my entire workday. And the product that previously I would recommend became something I cautioned people to avoid!

The subset of people who don't want things to change are running which OS exactly? User interface is just like any other artistic field: it has fashion trends. Look at something that's been around forever and is still developed: BBEdit. Yeah sure the app has not changed a *ton*, but its changed more than you think. Many fads in OS X design (like drawers) had to be implemented and later removed.

Any successful piece of software cannot realistically just stay still. It has to keep evolving with the trends of user interface. The difficult part is doing it well. BBEdit has managed it.

>The subset of people who don't want things to change are running which OS exactly?

All of them? Hell I hate it when things change in a way that forces me to give them attention now rather than when I have time. Nothing worse than doing an update and having to rework my flow, scripts, and code just to be productive again. Let me choose when I update my tools, don't force it on me just because your UI team found an even more complicated and torturous way to make simple things ugly and hard - I have my own work to do.

The problem is that you generally can't support yourself by just selling to existing customers; you need to keep selling to new customers.

And the market keeps evolving, so you need to evolve with the market if you want to continue selling.

If you do it slowly enough, and cautiously, then existing customers can adapt.

But if you stop updating your app, it's eventually going to lose its appeal and will be forgotten.

I think this is kind of disproven by a feature that was added to Microsoft Word in the 1990s (I don't think it is still around, although I may be mistaken). It was called "WordArt" and let the user do things like write the word "shark" with the letters deformed so it looked like a picture of a shark. Why would you want to do this? I have no idea. It's just obvious that the people working on Microsoft Word needed to add something and just bug fixes weren't enough, I guess (although they still don't have a reference management system which is why things like EndNote still exist)

I wonder if you are trolling or being serieus, because me and literally everyone i know would use this feature extensively. For powerpoints, school presentations, birthday cards. 50% of the time I fired up Word, it would be for that feature.

I seriously have never seen this used ever. But it sounds like you are talking about children using it, which I hadn't considered (I was already an adult in the 1990s).

Are you kidding? That would actually make presentations fun again.

Time moves on. In the 80's, 90's and 00's entire genres and niches were explored and defined. Much of the software I use matured around the time that article was written, and the "new features" in a lot of software are so niche, that they are big enough draws to buy new software versions. Hence the move to subscription for everything. Microsoft office is a generic example. The company I work for has all versions from 2007 through current in use. There are no features in the newer versions that change how we work.

Many people I know in my industry have been looking to dump the service contracts for CAD software for 10+ years. No useful added features, no improvements in stability, and no service to speak of through the VARs. What is the point of paying?

So, this is true:

> Too much software changes just to change.

But it doesn't imply this:

> I'd say at the very most it needs security updates.

What the parent said about "security updates at the very least" is correct, and sometimes that happens to also be the very most updates that should be made. And sometimes it's that but a little bit more. And sometimes it's that and a lot more.

The hard part is figuring out the right balance. And then, figuring out how to staff in order to achieve that balance.

The "only security updates" approach turns out to be among the hardest to figure out how to staff for. Because the idea is that this software is essentially complete upon release, so the natural business model is to sell it that way, for a one-time fixed price. And then with that revenue structure, the natural cost structure is to move all the staffing to a new project (or to build these kinds of products with project-based contracts to begin with).

But once you've accepted that you should at least be doing updates for security (and I think this is correct in almost all cases), well, now who is going to do those? You have a recurring cost with a non-recurring revenue stream. You can push down the recurring costs as far as possible, but eventually this model just struggles to pencil out. At that point, you'll probably decide to just stop all updates, including security patches.

This phenomenon is why most people making software seek a business model with a recurring revenue stream. It's not an accident that the days of boxed software were also the days of rampant insecurity.

But, you're totally right that the next step in this is often, "well if we have to have ongoing staffing and recurring revenue, we need something for them to do besides maintenance, so let's do UI refreshes and metrics and stuff I guess". It's a test of leadership, to avoid that temptation. Better products have better leadership that is making better decisions about when it makes sense to do more on a product and when it makes sense to mostly leave it be.

> "security updates at the very least" is correct, and sometimes that happens to also be the very most updates that should be made.

And a lot of those updates wouldn't be necessary of software and tools wouldn't offer so much attack surfaces, that they wouldn't need if they cared less about those things as necessary features...

Man I dunno. This sounds right and all, but after years of seeing security issues that don't seem to have anything to do with unnecessary attack surface, I have to say that this just seems unrealistic to me. The problem is that no software runs on a machine without an internet connection, and you can't control the attack surface of other software on the machine.

Why would I pay my developers to do bug fixes if you've only paid me once? Bug fixes are the user's problem, so why should I have to pay for it?

Companies can bake the cost of one or two maintenance releases and maybe one or two years of security releases into the purchase price. I agree it's not reasonable to expect lifetime updates from a one-time purchase. As long as you're not doing heavy development on these maintenance releases, the company's cost should be very small.

As a user-developer, I'd also be happy with being provided the source (or un-linked object files, or the equivalent for whatever language being used) after the maintenance period was over, so I could continue applying dependency security patches myself.

Because you sold a defective product

Depends on whether the bugs are because of preexisting flaws or because the underlying platform has shifted. No one can predict the future, and even OS vendors who once took backward compatibility seriously may not in the future.

The design of MOST non-trivial products is refined over time with no expectation that older versions will be upgraded to the latest and greatest. Yes, material esp. safety defects can lead to recalls but this is relatively rare in the physical world.

Even the security updates are often dubious. Software that could be entirely local (with a system provided filesystem backup/sync for data) adds "cloud" functionality so that it can lock you into the SaaS subscription model, and now it's got the network as an attack surface. Even there though, it generally just talks to the vendor's servers, and if you control the vendor's servers, you probably have more direct attack routes than some http client bug.

"Security" patches are something only checklist-driven corporate IT (i.e. people who can't consider use-case) ought to care about. For individuals, they're mostly a cudgel to justify abusive practices and should be ignored.

The reason that desktop world existed is because computing was very localized.

Now people use it in very interconnected ways.

> Another benefit of software that doesn't change every week is you can charge one time for it rather than these awful subscription pricing that most software are switching to.

How do you pay developers to continuously fix bugs, provide security updates and update their software when the underlying hardware and operating system changes?

> How do you pay developers to continuously fix bugs, provide security updates and update their software when the underlying hardware and operating system changes?

Have we really strayed so far that everyone's forgotten how this is done? Security fixes and serious bug fixes should always be free (At least going back N-1. You price that work into the sale price to begin with), and you get ongoing revenue by selling new versions.

And if the person is happy with the current version “n” that they were using, kept the same operating system while you released n+1 and n+2 to stay compatible with new operating systems then they decided to upgrade their hardware and find out that their old software doesn’t work?

They will still need to buy a new version or should that be free?

If the author of BBEdit never added a feature since 1991. You would have still had to pay for new versions to run on your PPC/Classic MacOS, OS X PPC, x86 Mac and now your ARM Mac.

Back in the “good old days” MS Office cost $595 for ea h version if you had a Mac and Windows PC.

Now it’s $99/year for five users and you can run on your Mac, Windows, iPad, iPhone, web, or Android device.

The same for Photoshop.

And you get continuous features added as the platform vendor and software vendor add more capabilities.

> and you get ongoing revenue by selling new versions

This works exactly up until the moment that your software is good enough that most of your userbase stops paying to upgrade. Then you are dead in the water, and the software becomes abandonned by design.

Obviously that's bad for businesses - but it's great for consumers! I think the question that's being asked is if there's some business model out there that delivers what customers want (the ability to just buy a finished product once and have it work decades down the line, like "pass it down to your kids" long) while also delivering profits to shareholders.

There's a reason farmers want the ability to repair their own tractors without having to give John Deere an extra cut, you know.

How is it good for consumers to have abandoned software that is not compatible and never will be compatible with newer operating systems?

Two decades ago, for instance Apple was still selling PPC based Macs.

You emulate the abandonware, old OS and all. She kicked the habit recently, but my sister preferred Word 5.1 for Mac for a long time. That was a 68k program, which she dutifully used _on a PC_ while Apple was busy shipping iOS on ARM and Mac OS on x86. The Centris 610 is very tired, but the software still works. (Well, not the original copy. Those install floppies are very dead.) Software can be uniquely persistent, in a way physical artifacts can't, so why are we so insistent on keeping everyone on the upgrade treadmill?

George R.R. Martin pretty famously uses WordStar on DOS. I can't imagine it'd be some win for consumers (either Martin personally, or downstream enjoyers of his books) if he had to be on the latest internet-connected, ad-infested, notification-riddled copy of Windows just so that his OS and Office Suite could repeatedly check to make sure he still has an active subscription and a valid "digital entitlement."

I still use Office 2010. (Though it gets increasingly difficult to activate it, and it last received security updates in 2020.) In 2010 I was using x86_64 (an Athlon 64 X2), and today I'm using x86_64. Why should I upgrade? It happens to still run on Windows 11, but I'd gladly stuff it in a VM to continue using it. (I do use Office <current 365 build> for work, so I can pretty confidently say there is nothing worth paying for in there. The only feature even remotely interesting is PowerQuery for Excel, which is available as an add-in for Office 2010.)

Well, my wife uses one my 5 user Office 365 subscription licenses on her Mac. I use it on my iPad and phone. My mom uses it on her Windows laptop and her iPad.

We each get 1TB of online storage.

Compare that to the $599 that Office for Mac use to cost and that you could only use on one computer.

> if there's some business model out there that delivers what customers want ... while also delivering profits to shareholders.

Of course there is, but that's why software in a box cost hundreds or thousands of dollars per version, with minimal bug or security updates thereafter. The grass is always greener, yeah it's a pain in the ass having a ton of $10/mo subscriptions. But I'd much rather have that - as both a consumer and a developer - than have $800 single-sale purchases.

> Old, unchanged software is not obsolete. It's mature. Bugfixes only, please.

This assumes a waterfall approach to development which implies multiple 6 month to year long development cycles.

In reality, a mature stable project can receive monthly updates, and an immature half-working project can be in maintenance mode. Furthermore this may work for software that should be seen and not heard doing its job in the background without much user interaction, but for software that users interact with regularly, the design needs to be periodically refreshed to match current trends or users will leave for the newer sexier product with fewer features. We've seen this time and again. I have absolutely experienced a mature product that was "finished" (abandoned) like 4 OS version ago that just doesn't run/work on the current OS version because the platform has added new security controls, APIs, and/or UX expectations, etc. No amount of security updates would fix that.

So while I understand where you're coming from opining for a world where we ship mature software and security updates only, I don't think it's remotely realistic given the way humans operate.

> In reality, a mature stable project can receive monthly updates

Software that gets frequent updates isn't "mature and stable" by definition. It's constantly changing.

> Software that gets frequent updates isn't "mature and stable" by definition. It's constantly changing.

That's simply not universally true and it's incredibly naïve to try and assert that it is. Obviously there are examples of immature unstable software that receives monthly updates, but it's not a tautology that monthly updates imply immaturity. You either don't work in software or haven't really thought this through.

Stable means the software run reliably without major issues and mature means it is a solution well adapted to the problem domain and solves a problem with grace, tried and true. Monthly updates might be "integrate support for new technology/service (that didn't exist 6 months ago)" or "support latest changes in macOS 14" or even "fix issue that happens 0.01% of the time". Other software changes and you have to adapt, and no software ships bug free. Being mature and stable means you have the time to work on things that aren't existential for your product/business, like adding convenient support for some sexy new service as a nice value bump or making sure those 0.01% of your users aren't occasionally encountering an annoying or frustrating issue.

In this context, stable means that it should not break, not that it will not be updated anymore. The term for what you are referring to is end-of-life.

Software "maintenance" is kind of a self-fulfilling prophecy. It's not required to break the old in order to make something new, but unchecked scope creep results in what used to work not working anymore, and thus the artificial need for maintenance.

But interface updates do meaningfully help many people.

Most people in engineering roles think the job is done when the engineering is done, and the maintenance is unnecessary unless it's necessary for stability or security. That's not limited to software, either. The fact is, to the vast majority of non-developer software users, an improved workflow, more intuitive, or yes, even more attractive interface makes more of a difference than moderate performance upgrades or minor stability improvements.

To a developer, interfaces are a way to interact with with software, like an API for humans. To everyone else, the interface is the software. Old interfaces are as or more usable to you because you have a sophisticated mental model of software and a high tolerance for logical complexity. These dreaded designers' profession is figuring out how people who don't have those things can most easily solve their problem with the tool you built.

Car controls would look a lot different if the engineers maintained control over the available controls without designer input. They might intuitively understand that the array of controls that change fuel injection parameters should only be used in certain instances, but they liked having them right there just in case. When told that they'd just confuse average drivers and should probably be hidden, they might argue, "I explained to my 6 year old nephew how more or less air can affect engine preformance." Multiply that by the dozen internal systems they want to control or get real time data from. A designer world recognize that this would confuse most drivers for little benefit and hide everything but the things most drivers need to find and parse instantly... And they would be met with the same heavy sighs and eyerolls that software designers regularly get from developers.

Designers are in the organization because they can do things that developers can't. They make developers work vastly more useful to the world because the way someone solves their problem is as or more important than it being optimally solved using the smallest amount of available resources with 5 9s of reliability instead of 3.

And that's why, in the overwhelming majority of cases, end-user-facing commercial software with professionally designed UIs and someone looking at UX on a whole will dominate FOSS alternatives while tools targeted at developers and other technical people do as well or better, and the commercial equivalents.

Without solid designers most software would be completely unusable to the majority of people.

It is really easy to get caught in the trap that YOU are the end-user, but a couple user interviews will quickly shatter that reality.

The OS under your software is not static. MacOS programs from 10 years ago rarely execute successfully. Windows programs from 20 years ago might. Linux programs from 5 years ago mostly don't unless you have access to source code (and a certain willingness to patch it yourself).

> because developers gotta develop.

You're touching on the real problem, here. Software isn't broken, it's just that the inherent issues in capital are starting to become painfully clear in this context.

I've been trying to find a term for "behavior focused on maintaining your job when the need wouldn't exist without such behavior". It's kinda tangential to artificial scarcity but broader in scope, and if we don't have a term for it, we need one badly. So much of our society's resources are committed to solving problems that don't exist, because the actual problem is "you need money to live and for whatever reason the thing you do in the place and time you are isn't necessary or desired".

> I've been trying to find a term for "behavior focused on maintaining your job when the need wouldn't exist without such behavior"

The concept of self-preservation or calling it superfluous self-preservation probably works here. But perhaps saying auto-preservation conveys better the sometimes lack of conscious intention that goes on in these situations.

> I'd say at the very most it needs security updates.

and then you move the bar a little (although I agree):

> Bugfixes only, please.

I would also add updating to work with the current OS / hardware. (I have unusable games that are a recompile away from being usable.)

But I agree with the rest of your points. Especially when, in addition to asking you to fund new features, the new features make the app worse for your use cases.

However I don't know if the root cause is more accurately described as "developers gotta develop" or "product managers gotta produce".

Yea, I don't mean to target individual software developers here. "Developers gotta develop" is commentary on the entire industry, and all the contributors, including developers, UI designers, product owners, QA, executive sponsors. I remember hearing the saying "Programmers are like beavers. Leave a beaver alone to decide what to do and they'll just keep building dams, regardless of the fact that their home is done." I don't know if that's really true about beavers, but it's true about software organizations. The whole software development team will just continue working on the software even long past the point where they're done.

Software compatibility with current modern platforms is a feature, and an owner of software isn't entitled to forward compatibility any more than an owner of a car is entitled to new parts as the old ones degrade.

Software degradation is much like hardware degradation: it happens with time as underlying platforms change.