If you freeze your features you will soon arrive at a point where everybody who wanted your software bought it and then the revenue stops.
That's... how it should work. You don't get to hook into their wallets for time and all eternity.
everybody who wanted your <shovel> bought it and then the revenue stops.
everybody who wanted your <light bulb> bought it and then the revenue stops.
everybody who wanted your <real estate> bought it and then the revenue stops.
... and then you go do something else!
That is the precise mechanism that drives the economy forward.
Shovels break, light bulbs burn out. Then you go buy another one, and there's a good chance it's better than the earlier one. The manufacturer keeps working to improve the quality, and people keep paying them for this. "Buy a software license once for all time" is not analogous to this.
Not in my experience. Almost always the new ones are improved only in one respect: profitability. Generally this means they have used cheaper components, lowered the cost a bit, and made an inferior product. Ok. End of tangent.
Call me cynical, but I think it's naive to make this claim.
Manufacturers don't optimize quality, they optimize profits. Even if there's sufficient competition, manufacturers don't race upwards to improve quality, they race downwards to reduce the cost and undercut the competition.
You can see this in kitchen appliances. People complain about how they don't last as long as they used to and are harder to repair. That's because when a customer sees a $30 blender and a $50 blender on the shelf, they will nearly always pick the $30 blender, even if the $50 blender is a higher quality. There was a race to the bottom on pricing, and corners had to be cut.
What you really want to read is reviews from 3 years in the future but you can’t. So you buy the $30 blender because it’s too hard to assess whether the $50 one is worth it.
I really liked the hn article the other day on assessing garment quality. The first step in stemming the tide of garbage is being informed.
In the software world SaaS tends to optimise for growth and customer retention, which is probably better aligned to meet people’s needs than optimising for first sale.
I didn’t see this at the time; if you remember the title or still have the link could you please post it?
So you are right in the short term, but consumers learn. This will bite cheaper brands in the long term.
Problem being, <shovel> makers are now prohibiting you from owning your <shovel>. From fixing your <shovel>. From changing your <shovel> so you don't need to buy <super shovel>. Now with forced updates, you're now literally prohibited from keeping the shovel you have and like!
I agree, why I feel ye olde numbered software releases worked fine. I even think subscription based software is fine if the yearly subscription price is at or below what the old numbered version costs.
What happens these days is software converts to a subscription model and the developer decides to jack up the yearly subscription price to 2-3x the old yearly price.
New Mac OS version? Users want <software> to support it. Found a bug in a library <software> uses? Users expect to get a fixed version etc.
And while as a software user/buyer myself I like the idea of paying once and be done with it I kinda understand why people need recurring income if they keep on working on a piece of software even if it's just "minor" things.
No, they expect to have the opportunity to upgrade to newer versions which may be different if they want those differences. They don't expect the one they bought, learned to use, and have grown proficient with to suddenly be completely different one day for no good reason.
Consider buying a truck because you haul stuff around a lot. You don't expect to just come out to your driveway one morning and find a fuel-efficient minicar there instead because someone at the car company decided that people like fuel-efficient vehicles, so they would steal back all the trucks they made and replace them. However, maybe you used to haul a lot of cargo but you don't anymore so you've been thinking of replacing the truck and a fuel-efficient car would interest you, but you want that to be your choice.
I can guarantee you that inboxes of all iOS developers who have not implemented dark mode will fill up the first day iOS 13 is released to public.
Heck, people expect your app to work on the first beta and will complain if it does not.
Its this weird delicate balance of improving the UI but not changing it too much. I tell people all the time UI is the hardest job in the world, an entire team of PhD's cannot get it right most of the time. Its simple an impossible task to consider the 'work flow' of every user- it is just beyond the scope of human intelligence I think.
All you can do is create a good UI that works for a majority of people, and try to manage it from there.
A delightful assertion that is the precise opposite of TFA's entire point.
I have been avoiding the available OS update for my Macbook Air because I've heard it kills performance, reduces battery life, may not run one of my favorite applications, and AFAIK brings nothing that I actually want.
You might not want security updates, but you probably need them, and probably should have them.
Example: A customer bought your app on iOS 9. It worked perfectly fine. You wrote it once, because you couldn’t expect more revenue from existing customers. It stopped working on iOS 11, because 32-bit support was ended on Apple’s side.
Of course, it’s not Apple who gets the blame, it’s you, because your app doesn’t work anymore. But it is supposed to work, because your customer paid good money for it ($4.99).
Back in the day, sure, if you bought a software that worked on MS-DOS only, it’s your fault when you got Windows and it didn’t run your software. No expectations, no hard feelings. But iOS is iOS. It’s the thing running average Joe’s smartphones. Software bought for iOS should work on iOS. Forever.
Your examples all describe products with an expected expiration date. Software used to have expiration dates. But not anymore. The expectation changed.
What you're glossing over here is that for literally decades, that was a pretty good baseline assumption, because we actually valued backward compatibility. The lengths that Microsoft went to in order to maintain that compatibility in the first several major releases of Windows are legendary. The lengths that Linux developers still go to are also remarkable.
It's only in the crazy new world of X-as-a-service and not even controlling the OS on your own devices that anyone thinks deliberately breaking stuff every few years to force the upgrade treadmill is a good thing. And the people who think that are largely the ones who also see you as nothing but a data point in a revenue maximisation model, not the actual users.
Ask yourself this: Have you ever met anyone who isn't a software developer who told you joyously about how much they appreciate the endless stream of updates that everything they buy now gets? I haven't. But I have lost track of how many friends and family have bemoaned things being changed that they didn't want, older devices that seemed to be working perfectly well but then got broken by some software update, some service they depend on being broken or switched off, some content on a service they pay for being removed or blocked unless they pay more, etc.
This is not progress. This is a failure of regulation, the triumph of capitalist free markets in consolidating so much power in so few places that competition is no longer an effective protector of the customer's best interests.
But: How useful is your copy of Windows 98 these days? Can you collaborate with others with your copy of Photoshop 5.0 or Office 2003? Can you easily install Quake I on a modern machine without hassle?
> Ask yourself this...
It depends. I see your point and you are right to a certain extend. But then I see lots of people asking for new features or are glad about new capabilities the app now offers. I’d say it depends a lot on the type of software.
> competition is no longer an effective protector of the customer's best interests.
Why? You still get to buy some software or use your iPhone 3GS. It’s just a security thing. Or did you expect free updates to your OS?
The buy-once-use-forever software doesn’t really work, because software is rarely isolated like some Linux CLI tools from the 80s. You need to have security updates or collaborate with people by sharing files. Someone wantsnew features and change, others don’t. At least under the new model, you get to use software for a low price if you don’t use it that much (Adobe cloud is what, 10 bucks a month compares to 600 upfront?).
It's that they replaced the old toolbar with the awful ribbon interface, instantly breaking years if user familiarity.
I suppose that depends on what you're trying to do. I can still run those programs, and I can still access my data created in those programs. Obviously they don't support some features and formats that were added in later versions, but forward compatibility is a different issue. My point here isn't about new things being given to you free by magic, it's just about not losing things you already had.
But then I see lots of people asking for new features or are glad about new capabilities the app now offers. I’d say it depends a lot on the type of software.
Again, just to be clear, I'm not objecting to change in general. Of course in some cases we hope that our software will add useful new features or fix bugs or improve an interface.
What I'm objecting to is software that forces updates on users whether they want them or not, which Apple for example has a history of doing with iOS devices through a variety of mechanisms.
It has total control of the only major source of software on its platform, and it seems to have no problem with mandating that any software supplied through that store complies with its latest guidelines. As a developer, that might mean issuing a new version of an otherwise working app for essentially cosmetic reasons. Don't comply, lose your whole market.
Crucially, Apple also pushes new versions of its OS that bundle essential security updates with functional and cosmetic changes. You can't keep an Apple device secure without accepting everything else as well, even if the everything else makes your experience worse than when you chose to buy the device. This, to me, is the really nasty shift in recent times, and it's one that Microsoft is guilty of as well now.
You still get to buy some software or use your iPhone 3GS. It’s just a security thing. Or did you expect free updates to your OS?
Yes, if my product does not work as it should because of a defect, it is reasonable to expect that the supplier of that product should remedy the defect, or otherwise compensate me in some reasonable way for the loss caused by its failure. This is how consumer sales normally work, and indeed the principles are enshrined in law in many countries.
Software companies have had a very easy time on this score, despite the large number of bugs in what they ship, and I think that is in large part because of the informal arrangement that essential bug fixes and security updates would be issued free of charge for a reasonable period after someone made a purchase.
If software companies no longer want to uphold their side of that unspoken bargain, then I don't see why we shouldn't get stricter with them about consumer protection and their liability for failures. Obviously we don't know how to write perfect software and it's unrealistic to expect a developer to ship a flawless product, but let's not kid ourselves that huge numbers of corners aren't being cut in order to push things out the door more quickly, nor that those compromises don't sometimes have damaging results that were entirely avoidable.
On Linux retrocompatibility is handled at the source code level. So stuff will work as long as you are ready to compile your own old versions of all libs in a chroot somewhere. Trying to run even a few months old binary will often fail.
Mac is similar to Linux but the burden of recompiling is on the developers. Many applications ship an old version that you can run on some Eldritch version of macos.
If you introduce a cloud component everything breaks unless you are ready to support multiple versions of your DB.
No wonder so many entreprise devs fled to evergreen web apps.
Retrocompatibility was a given because it was relatively easy.
I hear the big downside is that you have to offer enough improvement over the previous version for your customer to be willing to pay for them. That's just crazy talk!
I think the absence of this theory in reality is proof that it is not a successful business practice for software development. If you believe that this model accurately translates to software then I challenge you to start your own software shop.
Then you have to secure a new vendor when it eventually breaks completely which is basically the same as buying yearly versions. Or you pay a subscription/maintenance contract so that the software keeps being maintained.
The problem with software maintenance is that it isn't a 'full company' job so you have devs sitting around who might as well add features for large clients since it makes them happy and you keep getting that sweet ARR.
If you buy an annual subscription, you are paying for 12 months up front, so you immediately get a fallback license for the version that is available at the time you start or renew the subscription.
If you buy a monthly subscription, then after you've paid for 12 months you get a fallback license for the version that was available at the beginning of your subscription. If you then keep your subscription active and later cancel, you get a fallback license for the version that was available 12 months before you canceled.
https://sales.jetbrains.com/hc/en-gb/articles/207240845-What...
Jetbrains has a price in mind for what they want to sell their software for, $X. You can buy it whenever you want for $X. To demonstrate that you may want to buy the next version of their software, they'll let you use the most recent version of their software for 12 months after your purchase, at which point they will stop and you will have to use the version you purchased.
Alternatively, as a different service, you can subscribe to the most up-to-date version of their software for a monthly fee. In an example of great customer service, Jetbrains will treat you at the end of each rolling 12 month period of subscription as though you had bought their product 12 months ago, and they will give you a free copy of that product!
If you're bothered that you can't subscribe to their latest-version service and then end your subscription and keep using the product, that's just silly. The price of the product is not $X/12, it's $X, and if you want it you can freely pay $X for it.
But if you don't feel that a subscription to a service adds value, please don't buy it and voice your concern to the developers. Especially if they're a small shop.
That said, subscriptions can be canceled. For example I needed Adobe Photoshop and Illustrator this month. Got to use those for a fraction of the cost I would have paid five years ago for each program and been stuck with a license. It's more flexible that way. But I understand it doesn't reflect every use case.
And can subscriptions be canceled in practice? If you cancel your Photoshop subscription, your documents suddenly become unopenable. In this way, software subscriptions—at least for software you create with—are like protection money: "Nice documents there. It'd be a shame it anything were to happen to them."
And no software vendor would like to categorize bugs as security related or not, or maintain and test all combinations of old releases plus security patches applied. The easiest is if all customers stay on top of tree.
When you put it like that SaaS doesn't sound all that different from ransomware.
Software is crystallized behavior, which rots when not in symbiosis with a developer.
Software developer holds the software ecosystem hostage, trying to extract the maximum amount of value.
Office 365 is a support nightmare but it does have security patches.
[0] https://products.office.com/en-us/office-2007-end-of-support
Ideally. Assuming you haven't bought into a contract, and assuming the company... you know... stops charging you once you stop using their product and "cancel" using the mechanism they provide. That second problem can be mitigated with single-use credit cards, like what privacy.com offers, but if that gets to be too common, I can imagine companies requiring you not use those as a condition of service.
This is what disputing charges is for. Once you have told them, even once, that you are canceling your subscription, any further charges are fraud and you should respond accordingly.
A random email from an unverified address to the first point of contact you can find with Google is not a reasonable way, for the purposes of this discussion. Nor is a casual ambiguous statement during a long phone call whose meaning clearly wasn't understood, if you don't clarify it at the time but then quote it out of context later.
Personally, I like the rule of thumb that it should be no harder to cancel a subscription than to take one out and you should be able to give that notice via the same channel(s) you could use to sign up in the first place, but no-one on either side is required to go any further than that. It keeps everyone honest, but it's also obviously reasonable and proportionate.
Ultimately, though, they're periodically asking you for money; if you decide to stop giving them money, then things need to work out such they don't get any more of your money.
Agreed, that is the important thing (though it implicitly assumes that you don't have some contractual obligation to continue making payments for whatever reason).
I'm not in any way advocating making legitimate cancellation artificially difficult here. I dislike shady businesses that do that as much as anyone else. I'm just also seeing it from the other side, as someone who has run subscription-based services, because sometimes customers will give ambiguous or conflicting signals and then assume you magically know how to interpret them correctly.
A particularly common one in my experience is a subscriber sending an email to ask how to cancel, receiving a prompt reply from you answering their question, but then not actually doing it. Contractually speaking, there seems to be no doubt at that point that their subscription continues and further charges are legitimate. However, if they just forgot to act on the response, and then they come back six months later claiming that they're still being charged after "they asked to cancel", that's always an awkward situation. It gets more awkward if they really haven't been using your product/service since that time, or if they haven't actively been using it but they do have some sort of data stored in it that would be deleted if their subscription ended. It can get much more awkward if they really did literally ask to cancel, but in an insecure/unverifiable way such as an ad-hoc email, and if you did reply advising them of that and explaining the correct procedure, which they didn't then follow.
Within reason, we tend to refund as a good will gesture in this sort of situation as long as we believe it was an honest mistake by a customer, but I don't think either the law or whatever payment service was used should be imposing any sort of obligation in that case. Insisting on a clearly defined cancellation process does have the advantage of being unambiguous and therefore reducing the risk of that sort of confusion.
Especially considering that so many people get extremely high quality software for free (open source, free software, apple style "comes with hardware purchase", etc) these days.
Oh come on. Companies have been in business selling stuff for the longest time. It wasn't exactly wrecking capitalism before subscriptions became the normality in the last decade.
1 - Users have been trained by Apple and Google to expect endless upgrades for $2. When I grew up, Eudora, an email client, retailed for $100-ish, with an incremental $50 for ugprades every couple years. You can make a living on the latter pricing, but require hugely popular software for the former.
1a - as software has moved to mobile devices and web, the OS updates more often. ios does annual releases, android does the same, and chrome has a 6-week-ish update cycle. There's simply more thrashing, and it's no longer good enough to ship to a copy of Windows that updates every 4 years.
2 - There is a lot less end-user only software that just runs on a users device. It's far more common for software to require running servers to provide part of the service, and/or to code against apis that regularly change and require ongoing updates.
I'm aware no eng is owed a living, but if they can't make a living, the software becomes unavailable: either not written or not maintained.
see eg Sketch's rationale for not building an ipad app. https://www.designernews.co/comments/173706 quoted in case the link disappears:
> We don't have plans for an iPad pro version at the moment. Yes, it has a beautiful screen, but there's more to consider, such as how to adapt the UI for touch without compromising the experience.
>But the biggest problem is the platform. Apps on iOS sell for unsustainably low prices due to the lack of trials. We cannot port Sketch to the iPad if we have no reasonable expectation of earning back on our investment. Maintaining an application on two different platforms and provide one of them for a 10th of it's value won't work, and iPad volumes are low enough to disqualify the "make it up in volume" argument.
> the effect of a steady revenue stream on any business cannot be dismissed
Really? The effect of a steady revenue stream on any consumers can't be dismissed either, so how about we have those businesses pay us first? Then we can pay them back for their software. Is this how logic works? An effect can't be dismissed, therefore everyone else must dance to produce that effect?
So the logic behind "this model is objectively bad and means life or death for a company" was "well, it's a free country, so if you don't like it, go somewhere else"?
Specifically, I did not say that the subscription model is the only way to make money or stay in business. You're needlessly polarizing the issue and at this point, I'm gonna have to set the troll flag on you, and this conversation has stopped being productive. Bye.
In contrast, I can easily name dozens of companies in other fields that have been around for 50 years or more, including some small ones that have stayed small yet successful.
Adobe (1982), Intuit (1983), Electronic Arts (1982), Activision (1979), Symantec (1982), McAfee (1987)
Nintendo should probably be on that list with EA & Activision as well. The only reason they still exist is due to their consumer software business. They've shipped an enormous amount of consumer software.
Microsoft hasn't been a pure-play software company in a very long time. So I would also include Apple and IBM on that list, as both have shipped huge volumes of consumer software at various points (Apple is both still alive and still ships consumer software; IBM still exists, but no longer ships consumer software).
Just down the road from me is Frontier, which was founded by David Braben. He was working on the original Elite back in the early 80s, and although Frontier didn't come along until a decade or so later and doesn't strictly meet your condition, I'd argue that it's a good example of a successful consumer software business and has got there by producing a sustained track record of successful products. A few years ago it was listed on the stock market, but by then it had already managed almost two decades as an independent and grown to hundreds of people.
Others have, but Microsoft always been primarily B2B/Enterprise, not primarily consumer.
For that kind of company from the 1980s or earlier, MicroFocus.
> In contrast, I can easily name dozens of companies in other fields that have been around for 50 years or more
In any one field, though? And one as young as software?
Lugaru Software [1] (Epsilon Editor) has been around since 1984
There are more but...
That was the old business model. It worked well for a while. Then most small software companies that sold general purpose software went out of business doing just that. And with App Stores basically stealing 30% of all your sales, its become even more harder to do that. A lot of major software companies have since moved to the subscription model and have seen a bump in revenue and profit. For me, its not a bad value proposition for things like Office or Photoshop where I appreciate the updates.
>I don’t want to pay your software team over and over so they can keep changing it on me over and over. Just make it once, sell it, then go make something else!
Interestingly, after Photoshop moved to the subscription model, Serif released their Affinity Photo software that was a one-time-payment-no-subscription software to compete with Photoshop and to cash in on the discontent. I bought it to support their efforts, but I kept using Photoshop because its just a better software and I'm more familiar with it. It will be interesting to see if Serif is still around in 5-10 years..
I’ve never understood that argument. Physical media production, packaging and shelf space was way more expensive than 30%. Not trying to justify the Apple’s Premium here, just pointing out that it’s a lot cheaper than physical retail used to be.
> I kept using Photoshop because its just a better software...
In some ways it is, in others it is not.
And of course you only get 100% if you have zero fraud, zero hassles, no fees, no awkward cases.
I think its just the same bullshit as Walmart and Target selling toxic toys and then shifting blame onto the original supplier. Not sure what happened to the lawsuit though..
Agree to your second point on fraud/hassles,etc...
The primary reason subscription model makes sense, and why many software shops are switching to it, is because you never want to find yourself in a situation where you have to generate new sales to afford supporting the existing customer-base.
A decent middle ground is permanent fallback versions. But then you still have the issues with feature creep.
If need one of a hundred niche features, it's great to have software that has it, and it's also really great to have softare that doesn't have the other 99 features; it's better from usability perspective if they don't get automatically added for me.
Files closed with the application no longer reopen, UI elements are gone, and, worse yet, you can't completely customize all of the possible keyboard shortcuts any more, you can't even find access to them.
To my understanding, this was for 2 reasons (excuses):
1. Some OS changes Apple made*
2. To push people to subscribe to office 365 and "gain" that functionality
* I paid full price for both 2011 and 2016 (and the corresponding windows office copies). 2011 still works on the most recent macOS with all of the functionality. So, claiming that Apple did something to make the feature of automatically reopening the documents you had open when you quit broken is bull. Their old version still does that on the new OS just fine (despite that little pop up claiming the software is incompatible...it still works, why not use it?)
After buying MS Office with removed functionality, I will sadly not be buying office again. Nor will I be subscribing to office 365, nor will I be supporting it in any corporate ecosystem. The files from the old versions are perfectly fine and when they no longer are, Libre office and (almost embarrassingly) Google docs will have to do.
I'm definitely not the only one bailing. My father has been off for many years and, as a principal engineer at a Silicon Valley medical device company he helps others see that we don't need to let Microsoft maintain a stranglehold on us.
But, I was happy buying the new versions of office year after year until these most recent changes. Excel 2005 was one of their best versions. That was my subscription model: I pay full price every couple years you put out a new version and, in return, you give me a good, solid product that built off the prior one (or at least stayed damn near as useful) while providing support to that product through updates and bug fixes.
Subscription services are already gaining groans from people and we don't need another subscription in our lives.
But, to wrap up, back to the point: even though excel (and the other MS Office software) were incredibly versatile already, you still had the option to install the Analysis ToolPak if you needed to work with complex statistics or engineering analysis or even write your own plugins or macros for it, instead of those features overburdening the software and overwhelming the users by "covering all the use cases".
We still add "bloat" features because we are trying to sell to new customers. On the flip side, customers do get new features that are useful to them without the price of their subscription changing.
If we froze features, and only fixed bugs (and browser compatibility), customers would eventually drift away over the long term because they do need some new features.
Why not sell it as an upgrade/add-on/DLC then? More money for you and less hassle and bugs for the customer to deal with.
But it is such a pain keeping track of who's got what features enabled, what the pricing structure is, more complex invoicing, customers are paying already etc.
We would for a new major "product" but we do not for smaller features.
Of course if we could isolate the whole domain the application fits in from external influence there might be a stable optimum feature set, but I don't think that's how it works in practice.
Wishful thinking maybe
Why shouldn't I use software that works best for me, even if it isn't the latest and greatest version? Why shouldn't I be able to use multiple versions of the same software as though they were different products because they do different things well? As I recall this was expected behavior in the before times, in the long long ago, when internet wasn't yet a thing.
[0] Oh, also the web-all-the-things! people.
[0] updates have been known to make software more vulnerable too you know.
Average app developer is clearly not trustable for keepimg a whole system secure (Zoom for a recent example). We have to go back to air gapping but do it on app and even internal component level instead of whole machine. Sandboxing and containers is the only way forward.
For example, cvedetails.com, some random website I found from Googling, lists 13 vulnerabilities for Photoshop and 31 for Libreoffice in the last few years.
Some of the very "best" vulnerabilities of all time have been attacks taking advantage of scripting features in Office.
I've done both, kept the latest version or rolled back to previous versions when I didn't like the latest changes. So, it's certainly doable, and I wish more companies offered this.
From Adobe's perspective, it offers a lot of benefits:
- they don't have maintain build farms or pay a CDN to host GBs of binaries of native installers (for different OSes);
- users will always be on the latest (read: most secure) version since there is nothing to install or nag the user to check for updates/apply security patches;
- browser-dependence implies near-persistent Internet access, making license management/enforcement a whole lot easier;
- they can upsell you on cloud storage so that all your assets are available from any web browser.
Also, as others often said, 5.0 seemed like a broken release, and the ".1" was a much bigger upgrade than is normally implied by a non-major-version number. So it is version 5.1, and not version 5.0, that is remembered fondly.
In other words, it was perfect for (WORLD.population - 500mm)
What's bloat for you may be an essential need for your fellow worder.
#funfacts:
https://www.zdnet.com/article/microsoft-boosts-languages-pro...
These days I write in markdown and it it has to be pretty format it in libre office (mdpdf works fine for 99% of my uses though).
To be fair there probably hundreds of subtle improvements over Windows 98, but no horrendous game changers like when Ubuntu went from Gnome to Unity.
It was what I used until recently and would go back to in a heartbeat.
So in a relative sense Cinnamon is vastly more efficient as percentage of system memory used.
Despite one's opinion of Flash as a web alternative or its license, it was a great way to run interactive content on a browser, and they kept adding features to their native IDE ("Flash" itself) and capabilities to the player (including the SWF spec).
It eventually reached a point where there was not much more to add to it: it could play video (novel at the time) and audio (including live synthesis), use sockets, etc etc, and do some pretty advanced stuff supported by the player/spec. But none of that sold Flash IDE licenses, so they _had_ to add more features to the IDE. One of these features was the ability to do Bones, a pretty common animation feature.
To me that's what marked the IDE decline. I used to create a lot of Flash content, but stopped using it at that point too. Not because of bones, but it was symbolic of the moment. I still created Flash apps for years, but it was always by creating fresh, "stage-less" projects, compiled from source code (the right way to go anyway).
Bones itself is a great feature, but at the time Flash the IDE was already way behind other animation tools that exported to Flash like ToonBoom. Adding that feature just made it clear that they didn't know what direction to go with the IDE: it wasn't the best animation tool (despite having kickstarted a market!), it wasn't the best dev tool, just a bit of both with very few people who needed both. No surprise it stopped selling even while the platform was thriving online, circa 2010.
Can we agree that, realistically, generally users are not in control of the software development process, despite any organisational structures that appear to let users drive it.
FL Studio is a long-standing, and much loved software package for audio production.
Since its beginning FL Studio has had the following policy: Once you buy the software, all updates are free for life.
The counterpoint is that each new version of the software has gotten better and better. Therefore, the purchase of FL Studio license both has fantastic current and future value, and has earned intense customer loyalty and online reputation, generating substantial word-of-mouth sales---like what I am doing right here, right now.
There are very few (and minor) things i'd change about that software and apparently its developers thought the same because the biggest change they did after that was to change the program's theme (in general i think when a commercial program has ran out of important stuff to add the next thing they do is to change the program's theme :-P).
Also Delphi 2 and C++ Builder 1. I refer to the IDE there (they're essentially the same IDE except one uses Object Pascal and the other uses C++), not the language (as a language the ideal would be Delphi 7 with some functionality from Free Pascal like dynamic arrays and generics). The only thing i like from later versions is the inclusion of auto-completion, but beyond that (and especially after Delphi 7) there is way more bloat than good.
And MS Paint up until the Vista version. The only thing it needed was a tool to draw arrows. I curse the Win7+ MS Paint every time i want to draw overlapping rectangles or a rectangle and then something else.
Also WinHelp, whatever was the last version was fine. This didn't "fall from grace" as much as it was outright killed. CHM/HtmlHelp is nice (everything else that Microsoft has produced on the help front sucks) but the ability to add CSS and JavaScript on it means that many programs do add CSS and JavaScript (though TBF authoring WinHelp shows that it is a hacky hack of great hackiness, but i'm referring to the overall UX as a user, not author).
And of course WinAmp 2.95, i do not think this needs explanation :-P
Finally i think Visual C++ 6 (with the addon to add tabs) is the best VC++ version - again about the IDE, not the language. Though overall i prefer Borland's C++ (C++ Builder, Borland C++) mainly because the compilers are much faster (and i do not use C++ much to care about any missing features).
On the Linux side the last version of Xpdf to use Motif was the best Xpdf, GNOME2 is the best GNOME and Gtk2 is the best Gtk. Though Gtk itself is lousy, the only reason to use it is for GNOME.
Mac OS X 10.6.8. It was good, and stable, and nothing that has come after has really added value to the product.
For you. Personally to me things like cross device copy-paste, airdrop, notes and reminders integrations are indispensable now. Metal has brought a huge improvement to rendering speed and of course security between now and then is incomparable.
Snow Leopard, iOS 6, Word 6 (or 2003 if we have to take the modern era), all seem easy choices, yet the companies doing it never seem to notice they jumped the shark. Dropbox 10x the size with built in messaging anyone? Thought not. :)
Things like adding features to solve a problem, when those problems only affect a small percentage of users, is something I see a lot. Especially in the beginning of a product when you’re not 100% sure what you’re making or who you’re making it for and you want to appease all of your customers so you don’t lose them.
Or the feature added is too complex to be useful for a user without training / tutorials, of which few users will undertake that time investment.
I have yet to be on a team where features were not trying to directly address a customer issue / complaint, but maybe I’ve been lucky.
We could see a renaissance in that area if technologies similar to Electron and ubiquitous app stores make these more feasible.
(To toot my own horn, I think https://tenet-lang.org/ would be helpful in building well versioned APIs to allow intercommunication with shared semantics.)
In every job I have had, I have begged to get out and talk to users before doing anything else. However, that idea makes folks in charge nervous. It's expensive. It might reveal secrets(?). The users might get annoyed.
One of the biggest issues is that time spent on research is time when the developers can't be developing. That seems to trump everything.
IIRC UX people here on HN has told me Ribbon was a perfect example of UX design done right: they tested it on users and chose the easiest one.
Yet the first version of Ribbon released with the most important menus hidden behind the round logo in the upper left corner.
You are probably a good ux designer, but in general, modern ux designers cannot be trusted ;-)
Only problem there is that as ASICs are developed, general purpose CPU mining rapidly becomes grossly inefficient, so you'd somehow need a decentralized coin optimized for extremely high usage scenarios that was also resistant to ASICs. Not really sure how you'd achieve that latter part without simply constantly changing the algorithm, but it poses a complex challenge of changing the algorithm in a purely decentralized fashion in a way that one can not build adaptive ASICs for. Though I would imagine this is a solvable problem.
For many crypto currencies being resistant to ASIC and even GPU miners is an explicit goal since it promotes decentralisation (everyone has a CPU, few have Asics). The usual way to achieve this is to make memory the bottleneck. ASICs are great for speeding up computation and massively parallelising it, but if the bottleneck is not compute but memory or even better memory bandwidth then an ASIC can't have a big advantage.
Not when you include performance in the "consumer friendliness" side. Existing software is already way too bloated and keeps assuming it's the only thing users run; cryptomining would only exacerbate that effect. Especially that to earn a measurable amount of money over the lifetime of the product, your typical chat app using this model would have to run CPU and GPU at 100% load.
This is really quite a perfect application for cryptoes where everybody could win, but there are a number of not yet solved problems that need to be overcome. One issue with this idea, and as with all good decentralized ideas, is that the person who does ultimately create it would likely receive little reward for it. It's not about making money, but about improving the state of software as a whole. There are only so many Tim Berners-Lees.
Beginning: Slow and almost no return. Slow being a lot of intellectual effort to lay the foundation. No return being the foundation does not do anything useful, yet.
Middle: Fast and linear return. Building on a sound foundation allow adding feature that is simple and with high quality; and the return is linear to the effort.
End-of-life: Slow and almost no return. Bloated software eventually is dragged down by historical burden (tech debt, legacy features, etc.). Massive effort is needed to add feature, and the return is almost painful to stand.
A lot of recent software took the approach of forced update to extend the middle life. Like the chrome today is considerably different thing than its beginning. Py3 tries to demolish its historical legacy, and embrace new foundations.
I side with you 100% on that
The meme about software being an act of non-stop bicycle reinvention has never been more true to life than it is now
Edit: I know more about Sifter than Basecamp. I login to Basecamp every few years and it seems like not too much has changed to my untrained eye, but maybe they did stuff under the hood. For sure I know that Sifter got to what they considered peak features and stopped.
And then youa add a plugin and extensions API, so people can continue adding features, without annoying anyone — although the product is "frozen".
Isn't browser like FF and Chrome an ok example of this b.t.w.?
..."add value"
My theory is MVP is what they ship, then it's about the monetizing.
Instead of really improving the product, features become checkboxes on the roadmap. Which eventually results in degrading the quality of the product, it becomes bloated, the UX becomes confusing (especially to new users), and existing features start to suffer because the "maintenance surface" becomes bigger and bigger.
What should happen of course is that the product's feature set is frozen at the "peak version", and only bug fixes and optimizations are happening, that's a hard sell to the bean counters of course, especially with subscription models and "software as a service" which they like so much. From the customer's point of view, bug fixes and optimizations are expected to come for free, because they are fixing defects in the original product and don't add any value, right?
Eventually progress and success is measured in features added, not in satisfaction of individual customers. And as long as KPIs are looking alright - meaning the 'average customer' (which doesn't exist btw) isn't pissed off enough to look elsewhere, all is good, even though everything is terrible.