How do you explain the sloppiness of modern software?

I think companies like Google, Apple and Microsoft have realized that QA departments and software quality aren't worth it. People have gotten used to buggy software. At Apple, there's no Steve Jobs that cares about whether things actually work. Releasing new features to get media attention is more profitable than making sure the features actually work. We'll never see something like Snow Leopard again with its "no new features". Internally at these companies, there's also no reason for developers to care about quality. It's not rewarded by the managers.

Additionally, we as developers keep building software using more and more complicated tools that seem fancy and new to us, but are brittle and don't deliver good software in the end. We keep adding more and more layers of abstraction, both on the frontend and backend. Why? To put it on our CV. Things are moving so fast that we're afraid to get left behind. We're at a point where things just keep getting more and more complicated – actually keeping something alive (let alone building new features or making those features work) takes more and more man hours.

I'm not sure how far back you'd consider "modern" but back in 2000, Microsoft Office was unreliable, bloated crap that would occasionally refuse to open, reinstall or be repaired; I had to occasionally resort to reinstalling Windows entirely. Adobe Flash would randomly chew up the entire CPU after playing certain applets, even after the browser closed. Browsers? When they crashed, which they did often on some machines, they had no session restore. Boom.

Sage Payroll across a network - even a 100Mpbs/switched setup was laughably slow because it would IO bytes at a time.

Symantec's antivirus would refuse to update, even on freshly-installed servers. Norton had official instructions on troubleshooting LiveUpdate which included having to unplug the modem to fool it into thinking you were offline.

Windows would hang, crash, run like treacle, die if you plugged in a printer, insert a blank CD-R that hadn't been formatted properly.

When iTunes first came out? Oh god, one early version broke the Windows Installer somehow, killing all MSIExec-based software in the same way.

IME, software is just as bad as it always has been. Microsoft still ignore their own best practices, design guidelines and even user consent recommendations. Electron may be new but it's as efficient as software has always been: insultingly, laughably so. Installing printer drivers seems easier until you realise, three months later that it's pointing to an IP address, not a host name, when it's given a new one. Forced to set up an online account to scan, or even just login to your computer.

I don't even have to work on enterprise software which is why I do not have grey hairs :-)

There is a parallel in the history of workplace safety, e.g. i picked this one from google at random, all these histories tell the same thing:

https://eh.net/encyclopedia/history-of-workplace-safety-in-t...

  The sharp rise in accident costs that resulted from compensation laws and
  tighter employers’ liability initiated the modern concern with work safety
  and initiated the long-term decline in work accidents and injuries.

There was a long history of companies not caring about accidents and death in industry machinery. Companies claimed it was unavoidable, blamed their workers for doing this wrong, etc... Then the law made them care. The unsolvable non-problem turned out to be a solved problem in a few years. We also got some red tape as a side dish, but that's a good deal, all in all

Software is the same: If organizational leadership felt immediate pain from sloppiness, that sloppiness would disappear quickly. But now, we have fallen in a point where software gives no warranty at all, users have accepted the low quality as a regrettable fact of life, and companies attribute their low productivity to vague nebulous unsolvable mysteries instead of sloppy software. So here we are.

It's easy to forget how bad software was back in the '90s. Third-party software on Windows 95 was horrible--crashes due to drivers and such were a constant source of headaches that we just don't deal with to anywhere near the same frequency anymore. You could WinNuke anyone connected to an IRC server. A Web page could blue screen you by embedding c:\con\con in an image. "Microsoft Word crashed" was just a constant thing people had to live with; there was no good way for Microsoft to know about the crashes before telemetry. "Starting Java..." would regularly kill your browser. Over on the Linux side, forgetting to run LILO after recompiling a kernel would render your system unbootable. XFree86 was a nightmare to configure. Etc.

Modern software is in fact more reliable than older software.

The answer is there is low ROI on quality and businesses are hyper optimised for ROI. Only when the customers lose their shit publicly it affects ROI and quality will improve.

We got into a situation where people are so disempowered by design and poor access to routes to complain and demotivated to complain so poor quality is the norm.

If you want this to stop we have to collectively rip a new asshole in every half baked pile of muck out there loudly. Really loudly. Start burning up people’s ROI. Buy an app and it’s shit? Get a refund and then tell everyone everywhere exactly how bad it is.

When I do this I am repetitively told that I’m negative and this is not a productive attitude but I disagree and see this as a defence of the improper norm. The first step of quality is acknowledging you have a problem which needs to be shouted in most companies faces until they can hear through the fingers in their ears.

Software was always terrible, it's just that it was smaller in scope and so the suckiness was more contained. Waterfall had its problems but a strong QA/QC phase did help to avoid the worst issues. Nowadays proper QA is too expensive and pushing updates too cheap, so you get telemetry and permanently half-broken software instead.

However, even worse is that the complexity of software has grown to absurd levels:

- Massive distributed microservice architectures for simple chat apps and news websites.

- Huge distributed teams that need to coordinate rapidly in an Agile environment (which was never meant for teams that size, which is why you have crap like SAFE).

- Team churn due to lousy pay without changing jobs every 2 years.

- Bad practices that are still taught as best practices to this day in university, e.g. OO-inheritance hierarchies.

- Terrible foundations, how do you make a native windows UI again? The web grows at a rate that's impossible to keep up but even desktop apps build on that these days because the OS APIs are so lousy (even Apple is starting to crumble there).

- Sheer size of software with shorter time to market, leading to lots of open source code reuse, which is a big pile of code that can contain a big pile of bugs you probably can't do much about. I work on a piece of software that has thousands of dependencies if you count them transitively.

It's all just... too much, it's too hard to keep up and shortcuts are constantly taken (tech debt yada yada). There's good software out there but it tends to be small, focused, slow to evolve and developed by a small team.

Because it doesn’t matter, and none of this is a labor of love anymore.

Quality is a cost, and users don’t generally pay for the marginal value of a less buggy app, they pay for the massive value of the categorical problem being solved.

You sat there for two hours viewing a single directory, clearly making the page faster doesn’t mean you’ll use their service more, so why should they make it snappier?

Many reasons really. Some others have alluded in other comments:

* Fixing bugs isn't sexy. Constantly pushing new features is. Tech debt therefore isn't managed properly. I am leaving a job right now because of this.

* Problems with performance arise because developers frequently only test the application on their machine and/or phone and developer typically will have nice hardware that will run the application quickly.

* Mobile applications only get tested in areas where there is a good signal and issues that occur when signal strength and/or bandwidth are poor aren't accounted for.

* Decisions on what get prioritised are based entirely on user metrics collected in app. Which means anyone that blocks this reporting or doesn't fit neatly into the most common scenarios will be left out in the cold or issues de-prioritised and possibly never fixed.

* Tech debt at these companies is insane. Your app probably has a large client and server side solution that probably takes months for someone to be proficient even in making the most basic changes. There will be 500 lines in each switch statement blocks, classes that are 1000s of lines long etc. etc. This is due to tech debt not being managed and people just hacking to get stuff done to sprint deadlines.

* There will be 1000s of long standing bugs that can only be reproduced on particular devices (which may or may not affect you). Frequently devs might not even be able to get their hands on the device to actually fix said issue.

* I would wage in some cases the info-sec team will have ridiculous hang-ups about plugging in a phone via USB to a PC / Mac to debug. Frequently issues will be debugged via archaic or jerry rigged solutions which seem ridiculous to most freelance / non-corp devs.

Jonathan Blow has interesting ideas and views to share.

Please watch the [Preventing the Collapse of Civilization (1 hr)] presentation by him going into details why it is happening what you observe.

https://www.youtube.com/watch?v=ZSRHeXYDLko

Edit: Corrected the uppercase spelling of person's name.

This is not a new phenomenon. As early as the late nineteen sixties, people were debating the so-called software crisis and arguing how to improve the perceived lack of quality.

The simple answer is that a lot of software is simply good enough. It's doesn't have to be perfect under all circumstances. And making it much better than good enough has diminishing returns because it requires non trivial investments in quality.

In this case, you pushed an app out of its comfort zone and ran into some issues. Simple suggestion, use something more suitable for what you are trying to do and accept that this maybe isn't what this specific thing was designed to do or even do well.

In a nutshell, this is what I'm going with these days: Compositionality failure.

Software is built without thinking about whether will compose. How it will compose.

The elements that make things compose can be defined as the strange word compositionality. The "laws" that make things composable if they are followed. The properties that things can have to make them composable.

An API is more composable than a stateful mishmash of library functions. Now let's imagine that underneath the API there is a core data structure that has its properties and relationships clearly and usefully defined. Can we automatically generate the API code for it? We should be able to, at least to a significant degree. Then that's more composable. More compositional.

You all must've experience a different past than I did. Sure there were exceptions, but software in the 80s (lol), 90s, 00s, and 10s were generally slower, buggier, and uglier than what we have now. We're talking minutes to start some programs, sometimes it just stopped working and you couldn't use it on that computer ever again without reinstalling your OS. Software regularly crashed - like once an hour for Word. Sure, there were some fast programs, but they often did very little or have any modern conveniences. Global, fast search basically didn't exist in most programs. Rendering issues all over the place. "Oops, that file you were working on is now permanently corrupted!" was not some bizarre occurrence, but something you regularly prepared for by making copies of your files as you worked.

I think this is similar to video games - people see a pixelated edge in a game and think it is crap because it rarely happens.

Now if you remove "modern" from the question, and just ask how you explain the sloppiness of software, then all the same answers come back up. Today, where software development feels about 90% gluing stuff together, it's because there is so much stuff out there we can't even be aware of it anymore.

It used to be that a person could be read on nearly everything (100+ years ago), then you could do so within your field and be aware of everything else, then, for most of the 20th century, you couldn't know everything in your field, but you could mostly know it and be aware of everything else. Sometime about 10 years ago we hit an inflection point, where you can no longer even be aware of everything in your specialty. If you are a database "specialist", you can't even know of all the databases that exist, let alone understand them.

So weird, and so impactful to us and our society.

Anyway, old man rant over.

Software developers tend to think there's something special about our field, something inherently different.

There isn't.

Building products is hard. Building complex products, like software tends to be, is incredibly hard.

If you ever want to read about how terrible pretty much everything is when it comes to design, read "The Design of Everyday Things". It's a classic for a reason. It shows how so many products that people rely on every day are just terribly designed, even something as simple as a door or a remote control.

Software isn't uniquely bad. It's just regular old bad. Incentives are, like in every field, to make money. Up to a certain level quality is hugely important, and after that level it isn't important (for making money).

I mean, the question isn't actually would you want this or that bug fixed or not. It's would you give up other pieces of software that are important to you, so that some bug that most likely doesn't affect you is fixed. Because that's the tradeoff. More quality = less products, because to a large extent it's the same workforce.

And btw, modern software is way better than most older software. Way more features, and largely more stable.

My personal theory is that the the demand for IT workers in general (devs, QA, "architects", program managers, ops, sysadmins... Etc) is so damn high relative to supply that our industry attracts and retains large quantities of people that are just plain shouldn't be here.

Witness the distressingly high number of devs that fizzbuzz catches out.

I don't know if they are in the wrong industry / career, are just generally incompetent, or could be good and just don't care, but it seems like the percentage of incompetents is rising.

If you think this is exclusive to software, you're deluding yourself. We live in a very aggressively profit-seeking society. If it will produce a short-term profit, well and good. If not, then it's not going to be prioritized. Those of us on HN see this phenomenon reflected through software, but look at literally any other facet of modern society and you will notice the same thing.

> It is an app written by one of the largest and most ancient software companies in history, so they should know something about making apps.

I think tradition and collective experience matter very little with the issues you're describing. It is hard to form and keep a team that is both technically excellent and will make sensible UI choices.

Additionally, I don't know if this is true, but I get the feeling that pulling "product" and "UX" into totally separate professions has meant that ownership of the overall quality is now theoretically in the hands of people who can't ensure it. A similar idea to the principal-agent problem, although in reverse.

Software now is too complicated. Too many things are taken for granted. Methods like agile / scrum often force developers to do things a certain way to keep up the impression of speed. There's rarely time to think carefully.

Software development seems very vulnerable to cargo culting. People are not deciding the tool that they need and the architectures of their applications because of what technically makes sense but because of what is popular. One could start to suspect that what requirements the customer has actually has no influence on what architecture is chosen...

As both a military officer and a senior JavaScript developer for a Fortune 50 company the problem, industry-wide, in this slice of software is weak leadership completely opposed to quality in institutional terms.

Institutionalized quality would include:

* Uniform minimum accepted standards of practice.

* Uniform foundations of minimum accepted product quality.

* Uniform accepted measures and metrics.

* Formal training dedicated to standards and software as a platform, not tools.

* Credentials to certify standards of practice and conformance to ethics therein.

Instead children are left to drive the bus and cry about how hard life is. Anytime this subject comes up there appears to be no adults in the room.

My rule of thumb is that the quality of software is inversely proportional to the distance between the user and the programmer. If the programmer is in direct contact with the user you generally get good software. If there are layers and layers of people in between user and programmer, the software gets progressively worse.

Talking about OneDrive type apps - lets discuss Dropbox. Who's idea was it to make file revisions - even as a paid subscriber, limited to 30 days (or whatever it is). This essentially makes one of the best features of Dropbox (sharing files and not having to create "v2 final final final.doc" copies), useless unless you're on the highest tier. Well they lost my business pretty quickly after that.

Oh there's many reasons for sloppy software but I wouldn't call it all bad. There's plenty of good software around but of course people generally point at the faults first.

I'd say top 2 reasons are tied to either adversity in software engineering or simple economy. Devs are pressured to work fast, overtime, in understaffed teams, prioritizing features over quality. Once a project becomes old enough changes suddenly become much more expensive and issues start getting lost in the bottom of backlog. Large projects are chock full of tech debt, bad design decisions that used to be good at the time of writing, undocumented features, untested edge cases. IT workers constantly changing jobs means knowledge slowly evaporates. And lets not forget how fast tech becomes a piece of legacy and all the associated difficulties of working with old tech.

The economy part is simple. Businesses prioritize profit. If people can live with a few quirks they'll stay there indefinitely. If a company gets X cash for a project they'll maximize the profit by doing as little as possible while getting it done. If a product isn't really making that much profit it goes to maintenance mode sacrificing quality for a shiny new thing that will hopefully be more profitable. Projects once they go to maintenance mode only fix what's being payed for and that's the bare necessities.

We saw another fun anecdote illustrating what happens here on HN recently. It was an unnamed MS engineer who explained the issue with post-Win7 design at microsoft was, that even though the actual programmer engineers _building_ it knew which way north was, the design struck out for them was dictated by Designers who themselves would only ever touch Macs (if touch any computer at all, not to smirch their design genius), and not lower themselves to consider how LEGACY WINDOWS (ie windows from 6 months prior) actually worked - which would anyway be IRRELEVANT, as they were responsible for designing the FUTURE, and you don't do that by looking at the PAST.

And this is how we end up with the world's most succesful desktop OS having "Title menu bars that can no longer be used to drag the window", menu-bars consisting of ALLCAPS to hint it might possibly be a menu, a start-menu that you can no longer browse, where your installed programs never show up or disapppear, and where central OS windows no longer follow basic UI guidelines (goodbye incremental-keyboard-search, and the ability to sort and resize list columns), and hello scrolling lists without scrollbars, and goodbye indicator of how big this scrolling list is, and whether there are further items below to scroll into view. It is telling that Microsoft has not been able to produce a viable GUI framework/toolkit since 2006. Interestingly, WPF still sports 'the worst folder picker in the world', even though Forms has offered an excellent and superior folder-picker for around 20-22 years by now.

Just wanted to vent that, for whatever reason, after about half hour, let's say one hour of constant chatting on Google Hangouts the whole interface starts to lag, inputting text certainly "develops" a lag, it becomes very annoying, often times I have to close and re-open the browser instance just to kind of "reset" the whole thing.

I'm on a MacMini from 2018 (I think) with 16GB of memory, on the latest version of Chrome, still can't believe Google "bug-regressed" on something as basic as online chatting through a browser. I was able to chat in a Netscape 4 instance on a 5x86 (or similar) more than 20 years ago with no such inconveniences.

The question: are you still using OneDrive? Have you switched to something competing?

Would you be willing to pay more - or pay at all - for a better solution? Or write own software?

People overall are accepting tragically user-hostile sofware. How many stayed on Windows after it got ads in the start menu?

-----------------

In case of OneDrive following things can happen:

- people escape to superior competing solutions - someone spots that noone provides high quality solution and makes own and earns money on that - people accept low quality - OneDrive gets improved

(multiple can happen for multiple groups of people)

-----------------

How much you are willing to pay for cloud storage?

How much you are willing to pay for high quality search engine without ads? (I would say that 20-50 euro per month may be viable for me if search quality is noticeably better than Google - I am aware about Kagi but not sure is it actually giving better results)

How much you are willing to pay for open data navigation not tracking you? (in my case I put significant effort into OpenStreetMap)

Note that for many people answer to all above is "nothing at all" so services provided to this people care about stuffing as many ads as possible rather than about quality.

-----------------

Also, software in many aspects is strictly superior that what was available in past.

Alright I guess I'll take the other side of this.

Most of the software I use is great. Absolutely, mindblowingly great. This is in the face of seriously hard challenges with physics and mathematics. I get that you're having some weird troubles with Google Drive, that I've personally never had, but when I sit back and think about just how much software I use I'm astonished that I'm not frustrated more often. I send messages, they get delivered. I take a photo, it has crazy high quality for the size of the lens and sensor. I google a python question, I get an answer. I look for music, it's there ready for me to listen to it.

You have high standards, I get that, but software is hard. It moves so fast and even seemingly simple things are way harder than first glance. I don't know why the edge case you hit was so bad, but in general the GSuite has been great for me. It's always possible it was something weird like a browser extension.

Anyway, what I'm trying to say is that so much of software works well that you may have stopped appreciating it. I try not to forget what computers were like twenty years ago. It was madness.

Move fast and break things. The cicd model of delivery means that engineers are encourage to deliver functionality and polish things only if they are critical. The consequence is that people tend to reuse solutions of intermidiary problems no matter if those solutions are optimal. This accumulates technical debt that nobody really wants to repay because it is not a solution of a business requirement.

Additionally, the Moor's law and the well-paid jobs of developers mean that the machines where the code is written are not the machines where it is ran with the difference often being a few generations of processors, graphic cards, and monitors.

The hiring process is bad. Real skills get rejected while leetcode gets a job.

Empathy is the key in my experience so far.

No amount of discipline and techno trickery will get you to a happy user if you lack the capacity to feel what they may be feeling while using your software.

In most large organizations the breakdown is obvious. Too many layers. Opportunity to engage empathically is lost to some twitter support bots. Everyone on the inside is reduced to seeing some polished interior of a mindless corporate automaton.

Steve Jobs is an excellent example of how to cut through this problem in a large org. He reinjected the actual feelings of the end user from the top. Few other corporate leaders do this today.

I think one reason is failure to embrace simple, open standards. The railways worked because, despite essentially infinite choices of track gauge, they picked standard gauge and stuck with it. Is it the perfect gauge? Probably not. But it works well enough and having a single standard gauge is far more valuable than optimising the gauge for each new line.

In modern software, integration wins. Look at MS Teams. Complete shite. A buggy, bloated mess. But it wins because it integrates many different services together. Be honest, every time you have done any kind of integration between two pieces of software there have been hacks. But appealing to standards never works. Instead you are just told to make it work. Those who make it work are rewarded. Those who appeal to standards are sacked. You've basically hacked your train wheels to make them work on dodgy track and then wonder why the train derailed.

It's not all bad. From the TCP layer down we have all agreed to a few standards that work. It's all the stuff above it that breaks.

Yesterday I had exactly the same thoughts: I had to RESTART a windows PC in order to print a word document because the driver refused to recognise that there was actually paper in the printer afterall. I'd be ashamed to ship stuff with such obvious failings.

My other gripe is how, with increasing screen resolutions, UIs are eating more space totally unneccessarily. That Word print dialogue box is a good example - it must use 1/3 of a 4k res screen's estate only to display a dialogue with a button that is confusing, as it isn't consistent with Windows overall UI.

In general there are a lot of factors, in the example you give I would point out that it relates to cargo cult followers of a poor summarizations of best practices.

TDD/BDD proposes a world where all things work and remain working when investigated by an automated test. The automated test is built up step by step and happy to do everything from start to finish to look at the one feature and the feature may remain and continue to get repairs long after it continues to make any sense in a flow and with very little observation of how broken it might be in natural use.

At least where I work, the only thing project managers care about is releasing the next big feature for their resume or next promo packet. Making it work well or be well tested is very low on the priorities. In fact, if you time budget that in as an engineer, they'll find someone else to implement it who will estimate half the time.

> This is a recurring theme on HN, so I think you all have very good opinions on this topic: why does modern software seem so unpolished, slow, bloated, unprofessional?

Major software companies rediscovered that users will tolerate crap, so they've adopted processes and mindsets that serve the company at the expense of the user.

Also, in many ways the web sucks compared to native software, and the modern impulse is to web-all-the-things. So what was once a relatively slim desktop app is now some bloated website in a can.

The mean is now some shitty website or shitty website in a can. And no matter how good a software company starts out, it's run by businessmen and most of them will push it back towards the mean ("Why are we developing this fast, slim native app? We can reduce duplication and cost by shipping an Electron app that just repackages our web version).

Cause sadly KR > O

Management is by now mostly "OKR: Objective Key Result" driven.

But the performance review mostly focused on the KR as its designed for measurbility, the O is an afterthought.

Should be the other way round. Isn't. I by now quite often (when the company works with OKR but the quality that comes out product wise sucks over multiple time periods) recommend to trash the KR completely and only focus on the O.

No one in the comments mentions complexity.

The complexity of the interactions you described is orders of magnitude anything software in, say, the 80s had to deal with. Just imagine how many technologies you are using to display photos from "somewhere in the cloud" into your TV.

Now we can discuss how much is essential and accidental complexity, what alternatives are there, and whether the tradeoffs are worth it.

A properly installed Ubuntu on a fairly modern laptop, with i3, firefox, xterm, webstorm/sublime text and VLC for the occasional video works like a breeze. Rarely use more than a few gigs of RAM even when multitasking on multiple projects. Runs for weeks. Never crashes.

Compared to the Windows Millenium of yore with its blue screen every now and then, Visual which would take forever to load, firefox would crash miserably every few hours.

I don't deny your experience but this is just anecdata. The whole tendency of software is to get more reliable over time. Even if the complexity can set reliability back sometimes.

I suspect it’s the tools, frameworks, and the way the majority of software developers are taught. And also the computers we develop on.

The tools and frameworks add bloat. One some level we do this because the complexity of what we’re dealing with gets in the way of the problem we’re trying to solve. We add a layer of abstraction to hide the details and the solution becomes tractable.

We were supposed to be able to have our cake and eat it too but it turns out that a lot of these abstractions aren’t free in terms of performances.

The other factor is that a lot of developer tooling is designed for developer convenience. This is nice when you want to try out an idea. But the prototype often becomes the product. It’s nicer to work with, perhaps easier to add features to it, but that trade off is still there: performance.

And we’re taught to feel guilty or told we’re doing it wrong if we show any concern about performance. I’ve seen developers accused of the dreaded, “premature optimization,” sin for making suggestions in PRs to avoid code that would introduce poor performance. Or for suggesting anything performance related.

Lastly a lot of developers get to work on the latest and greatest hardware. They probably don’t spend any time or effort testing on older or low-tier hardware. This leads to designs that are “good enough” on these machines but will be slow as molasses on anything an average consumer would use. There’s a highly myopic view about platforms and is often not even considered.

There is monetary value being first and rolling out new features that generate news which attracts new users. Once a user is hooked more difficult for them to leave. Also it's a lot easier now to issue a patch/update over the internet instead of send out CDs etc. There really isn't and good reason to be as bullet proof as possible as there used to be unfortunately. This is especially true the bigger a company gets, nobody is leaving apple/Google over a bug.

imagine, in a world where there wasn't a concept of clean code but to write code as simply as possible. not having thousands of classes with indirection. what if your code logic was simple functions and a bunch of if statements. not clever right, but it would work. what if your hiring process was not optimizing for algorithm efficiency but that something simply works reliably. imagine a world where the tooling used by software engineers wasn't fragile but simple to use and learn. oh the world would be a wonderful place, but the thing is most people don't know how to craft software. but here we're building software on a house of cards

Culture of the product company.

That is, move fast and break things (cause it works for them) vs let's get this right (else we'll be targeted on HN).

In the case of Google, they don't really have an incentive to do better product. The products are simply a smokescreen for their search / advertising monopoly.

Furthermore, you and your One Drive, Cast, etc. are more of a source of data to be harvested than a means to bringing joy and satisfaction into your life.

The internet brought with it constant updates, and with that, we have now entered the age of planned obsolescence. Now the majority of users with spending power are forced to upgrade to the latest devices, which has removed the hardware constraints of old. With little to no hardware constraints on both the user and developer end, performance optimization has now taken a back seat in the list of priorities for shipping product.

The extra cost to produce high-quality software is not offset by higher profits from that software. If low-quality software generates 90% of the revenue for 30% of the cost, why bother with that extra work? It makes sense from the management's perspective, however frustrating it is from the user's end.

I face the same thing. I'm locked into using a particular GIS software package for my work, supposedly a central system accessible from any device. However, in practice they have 3 different apps and 2 different web interfaces, none of which have the same feature set. And often I want to use data that's accessible on one of their platforms to do processing that's only available on another of their platforms. And there are backend problems for which I've periodically been sending in support/suggestion tickets for a decade without any fixes. However, their marketing feeds are constantly bragging about new features and integrations. Why? Fixing their broken shit is harder work for less payoff. So they just don't. And they've got the patents, so they don't have to care.

Short answer: features above all. Yes, modern software and technology in general are irrevocably broken and will only get worse. The good news is, they are not essential to our everyday lives… right?

In the US, I can get paid very well to do mediocre work. Despite our buggy software, we keep raising more money and our valuation increases. PMs and managers get paid more if they delivery new features. At some point the company will get acquired or fail. Either way, the code will be gone and I'll be at another job.

Why bother caring?

It is dead simple, the sloppiness of the software does not affect its ability to generate money for shareholders. That is all that matters for those in charge. Ship things fast; explain that you'll fix stuff with frequent updates; each update breaks something else; explain fixes are incoming; keep making money.

User resources: time, computer CPU and memory, user network bandwith, etc. are free for company. Why care?

In free software, developers are users, so they care. Software is free, but developer_as_user time is not free, so it better to spent 1 hour time once to save 1 minute every time in the future.

In commercial software, developers are not users, so they don't care. Software is paid, so ROI is important, thus it better not to spent 100 hours of developer time + 1 hour of upkeeping time every month to save 1 minute of users time, unless it's important to crush a competitor.

Commercial producers are quadruple prices, until users stop to buy, drops quality, until users stop to buy, stuff ads in, until users stop to buy, shrinkflate, until users stop to buy, and so on.

Did you switch to a competitor product? No? Then why company should care? Vote with your money.

Monopolies, Linux and race to the bottom.

Monopolies like Microsoft, Google, Apple for stuff that have no real competition, so the manufacturers have no incentive to polish their products.

Linux for products made by volunteers that work when they can, how much they can and have the attitude "you get what you paid for, so don't complain too much". it is totally fair, but it leads to sloppy software.

Race to the bottom, like our MES supplier that fired most of their US based people and hired juniors in India; the quality went downhill, but the lack of better alternatives (again ... monopolies) makes it good for them, financially, for a while. Their CEO gets the bonus for the savings this year, not for the death of the company 5 years later.

EDIT: adding Internet, the way you can ship shitty software that you may partially fix later.

Public cloud trend, growing development and deployment stack complexity that takes consumes large portions of developer productivity away from quality and polish. We are expected to release features in limited timeframes, if so - and we have to battle what the cloud providers have been pushing in form of hundreds of services, multitude of stacks, or in frontend understand dependencies between thousands of packages to understand impact of a particular change, then we eat up time that we could've spent on quality. Unless of course there is a dedicated QA team that is responsible for testing - but that's obviously too expensive, and has its drawbacks itself, as can introduce the wrong mentality (outsourcing caring about quality to another department).

Software is shit because we (programmers) don't need to do better. Doing anything is not just about doing that thing, it's also a kind of an optimization problem, quality being just one of the variables. In software, writing whatever on fast machines and huge abstract framework is fast, and gets the job done, which keeps the income flowing, for both the developers and their product managers, managers, etc. The annoyance, or actual grief of the end user is secondary to many other aspects.

This is what ended up pushing me into the open source / free software world. As long as I need to deal with shitty software, I'd rather deal with the annoyance of not being cared about, than with the dark pattern galore of the proprietary world.

Incentives are pretty much always to push out software as fast as possible.

If you're the one guy who takes twice as long to write code, even if it works really well and needs little maintenance, you'll be the one who doesn't get bonus / gets laid off.

Easy. Management decides to use new tech without giving time to devs to learn it; new tech has huge blind spots making it impossible to do anything serious above Hello World; devs need time to figure out how to go around new tech’s limitations, no such time is given, ever to anyone; a management mandated culture where the dev that closes the ticket first is praised even though that means that he skipped almost all the edge cases; product owners and managers that lead the way but they have no clue about UX and dev, the blind leads the way.

I've worked only once in a decade with real QA Analysts. It was a relief as a software developer.

It's really a hard sell. I feel uncomfortable and I even try to do more testing by myself, but I fell pressure to deliver more features and scrum points than polishing some corner cases.

People do point out to me the pareto distribution (solve 80% of the ROI, forget the 20% that has less value and costs a lot), but it's stupid when your service scales to high thousands or millions of users when the chance to have edge cases poping up are increased.

By the current economic model.

Is food in the mass market fast foods quality food? Are mass produced electronic gadgets and toys of good quality? So on and so forth. The most amount of money is to be made in bringing mass quantities of shiny crap to the market.

Educated clients - the lack thereof. As opposed to the past where most software was for professional use these days the software that brings the most bucks is for mass consumption. And not very long lived either, people get bored fast.

As the economy changes consuming habits will change too, I think.

- Open plan offices and presenteeism culture "you're working if you're sitting in an office".

- The industry disincentivises people to stay long at any one job, encouraging loss of institutional knowledge, and discouraging possibilities of fixing issues that might require fixing over a long time period (years).

- Sales lead growth is a double edged sword, when you sell a piece of software without the features existing, which means you might have an impossible timeframe to complete those features without cutting corners.

In my opinion there are two main reasons:

1. Parallel programming is hard: Everybody programs for multiple cores now, but this makes the program architecture much more complicated and dealing with errors much harder. You have all kinds of threads or green threads doing things in the background, each of which may fail in various ways, and you to deal with this asynchronous command execution somehow. The indeterminacy of such processes is the cause of unexpected behavior that makes an application look unprofessional. As a drastic example, you press a button, it starts doing something, and then shows a spinning wheel of death until an automated timeout is met after 2 minutes.

2. GUI frameworks are much worse today than twenty years ago: For example, web application frameworks consist of layers of different programming languages and document formats (JS, HTML, CSSS, frameworks on top of that, and maybe another programming language connecting with all this mess) running in web browser (or some kind of half-baked emulation of a web browser!). It's a wonder these work at all. Desktop and mobile frameworks not based on web technology are often thin layers on top of SDL nowadays. This means they reinvent everything, and it's very, very hard to do this correctly. Even native OS controls/widgets often have problems, and these have been fine-tuned by Apple and Microsoft for decades. Your multiline edit field behaves weird? That's the reason why. Write your own multiline rich text editor with image support and you'll see why this is hard.

In terms of QA, it seems that once native user interfaces are given up, an "anything goes" mentality becomes prevalent. Maybe it's because companies think they compete with web apps (=even worse user interface) rather than native apps.

Tl;dr Programmers have been piling crap on top of crap for two decades now, and if you combine that with parallel programming and connections between multiple layers, it's going to be fragile and error-prone.

> Are the incentives given to developers so at odd with app quality?

Yes.

To expand, as others have said QA is a cost centre, and they often reported things it wasn't clear that users would actually view as a problem.

By cutting that out you get two theoretical benefits:

1. The people actually using your software will be the ones telling you where the problems are. This helps you prioritize work.

2. You don't spend as much money on QA people or dev time on fixes, which means more on feature work.

Maybe a not so obvious side effect of agile development is that it sort of reorganized software development into feature-focused development, meaning developers' bonuses at a lot of companies are often tied to the amount of new features they implement, and there's almost no focus on maintenance or fixes.

The same thing happens in politics: The incentive is on shiny new things, rather than maintaining the old things everyone uses constantly and desperately need the repairs. It isn't until bridges start literally falling down that tunes change on this.

Basically, if your performance is measured by how many new features you're able to deliver on time, to timelines set by a manager or executive who also has a bonus tied to how many new features or products their teams were able to deliver in a quarter, you're not going to think about QA at all if you can help it.

Here are some reasons I can think of that impact software quality:

- Profitability prioritized over user experience

- Design prioritized over functionality

- Never-ending push towards new (mostly useless) features

- Poor product specification for new features

- Insufficient involvement from customers/users in the Product life cycle

- Technical team not involved in Product decisions

- Lack of investment to reduce overall technical debt

- Disregard to system architecture and coding conventions

- Deficient onboarding/training of new developers

- Desire to adopt new tools/frameworks instead of proven/established ones

Software is bad because it's good enough. Management doesn't care if it's not optimal. There's always something else that needs attention.

The adage for software is “fast, cheap, good - pick two”, but it has devolved further into “fast, cheap, good - pick fast”. This is obviously a generalisation, but the reality for most software development is that speed to market, pivot and patch trumps everything else. I expect it will get worse before it gets better.

I disagree with the sentiment here. Modern software is much more polished and professional but perhaps more slow.

I remember installing stuff 10-15 years ago it would constantly fail with weird errors and bugs. Using linux was a real pain. Everything was much more monopolistic than it is today. You had to use x for that, you had to used y for this. While we still have a lot of issues today it is vastly better than it used to be.

I haven't had any machine crash with a BSOD on windows for years and on linux everything just kind of works and I have fewer and fewer issues. I can work remotely 100% of the time and do impressive things in the browser, stuff that was simply not possible at all 10-15 years ago.

I remember what a big deal Gmail was when it came out and today we take that kind of service for granted. Even with all the warts modern software has, it is still better than it used to be.

One word: energy!

As we burned all hydrocarbons we eventually discovered the personal computer and the internet AFTER we decoupled our economy backing from hard assets.

Now that energy, which is just stored sunlight, is running out and so everything else will slow down and have to be optimized.

We are at peak EVERYTHING, both good and bad!

Personally I'm staying on HTTP/1.1, SMTP and DNS, OpenGL (ES) 3, SPI, JavaSE on server, C+ on client (C syntax with C++ compiler), vanilla HTML, .css, .js for GUIs for life.

Windows 7 is still the best Windows. Linux is still the worst desktop.

Hardware is NOT getting better, I'm staying on socket 1151 until they become too expensive to power!

Intel Atom as load balancer, Raspberry 2/4 as file/compute servers, Raspberry 4/Jetson Nano as desktop and Raspberry Pico as mobile communication is the only viable future.

Let's get busy and build a low energy future!

Comfortable office workers and computer users are more aware now than ever of the billions of people in the world less fortunate than them. It just feels gauche, these days, to get too upset if the loading spinner on your diet tracking app freezes for one frame when the animation loops.

Well, I mean, old software was also pretty bad; there may be an aspect of rose-tinted spectacles here...

For instance, see Lotus Notes.

There does seem to be an increased tolerance for UI latency in _consumer_ software over the last decade or so, and I'm not totally sure why. Pretty much any electron app is laggier than pretty much any consumer app from the early 21st century, and people seem to be broadly okay with that.

Also, Microsoft may at this point view OneDrive as basically an enterprise thing, and you can get away with practically anything in enterprise software. Without seeing statistics, I would guess that OneDrive is not commonly used for consumer purposes vs the competition; it definitely _feels_ like an also-ran. Microsoft's enterprise offerings have always been pretty awful.

Ultimately: our version of capitalism. Which focuses on growth. Which translates to features. Which rewards proofs of concept. And devalues things like longevity, maturity and stability.

It's the TODO that's the killer. We are constantly adding tech debt, and never paying it back.

>> 3) The app in general is inconceivably slow. What is taking so long? I am viewing the same directory for 2 hours, why is it still so slow to load?

Practically speaking that's probably because nobody has tested the app with more than a dozen pictures in a folder. At a guess?

Have you seen the world we live in? I have seen inside many organizations which on the outside look polished with great brands....underneath politics, discord, and in some areas chaos. The state of software reflects this...

They release app just to provide minimum features. Sometimes they have better UX on webapp than mobile app.

I think people should create a ticket and ask for support. If nobody reports, they don't know there is a demand for a particular feature or fix.

I saw a page talking about Microsoft updating Team to make it less bloated [1]. I think they have higher priority for popular product.

[1]: https://tomtalks.blog/microsoft-teams-2-0-will-use-half-the-...

Unrealistic, arbitrary delivery timelines, so that someone looks good on their performance review, leads to cutting corners in development, testing and finally accepting non-showstopper defects as release-ready. Oh, and I don't think teams working in AGILE helps, unless every team is coordinated with others so that no one steps over each other's feet (I've unluckily not been able to see this work).

But this is not a modern problem. I saw this from when I started working in software 25 years ago.

Increased cycle budget, developers much less into 'hardcore' stuff (algorithms), move fast and break stuff, automatic updates.

Pick any or all of them as fractional contributors.

Speed. Everything has to move fast now for some reason.

Money. Every dollar of QA is potentially a dollar wasted on making something better than what customers can tolerate.

Everything being revenue optimized and run by MBA people

5000 pictures is a lot of pictures. Adobe Lightroom struggles with that many.

It seems to me that if somebody said ‘let’s make a program that can easily view 10,000 picture albums on a high-end computer’ it could be done. You would have to think through the data structures and apply the methods used in high-end video games.

It seems to me nobody is taking the problem seriously enough.

Fail fast culture.

In the end, you need to decide between features and stability. You can certainly write a very stable, simple app without all the extras that make it complex, stuff like Google Cast. But unless users demand it by paying more for a simple but stable app than a fully-featured app, there is no incentive to invest in stability instead of features.

I see a slippery slope in ML engineering, where to make something “production ready” engineers layer a relatively simple workflow in about 8 different technologies. I sometimes wonder if it’s preferable to just deal with occasional issues as they occur than to anticipate every deployment bug under the Sun.

Good thing is, if one searches for it, one can find really good, stable, fast software from developers who care about bug reports for most tasks. It’s not always easy, it’s most time more expensive, and you’ll probably not get all those shiny features that look good on landing pages. But it exists.

Easy - nowadays value is not created from software itself, but from data lock-in and "capture".

Profit motive and relentless ruthlessness in business by every company exploiting their customers.

It's probably already been written below, but the core problem appears, when the software is not being SELECTED by INFORMED receivers. In that case, no 'evolution'/survival-of-the-fittest is happening.

E.g. when you are using an app tied to a service you are already sold on, you cannot select an alternative app to use (because e.g. your fitness-chain only has their own app). Similarly, if you are a gmail user, most users are not informed enough to figure out they could access their mail with an alternative IMAP client.

Good software happens when you can choose between competing alternatives. But the world is currently filling up with siloed monopolies that don't have to compete.

I see something similar with christmas calendar candles. Every december, supermarkets stock christmas candles of horrible quality. They get away with it, because every shopper only needs to buy a single calendar candle, and every shopper is an inexperienced christmas-candle buyer. Meanwhile, the rest of the year, you can buy big candles of the same size, of excellent quality, just without the dates of december marked out. TL;DR: A lot of inexperienced candle buyers exist only in december.

It’s people who code for money not passion and borderline nefarious product managers.

People still haven't gotten used to magic that works. We're still in the snake oil phase of this technology. "The wonder isn't how well the bear is dancing -- it's that the bear can dance at all."

Start with your base assumption first, is software now worse than it used to be?

> The directory list view keeps "losing" the position at which I am, so every time I share a photo, I have to scroll down to where I left (in a directory with 5000 pictures)

It was not tested with that large folders.

no dogfooding

too few developers enjoy their job

managers are incompetent but multiply like flies

Its because of JIRA :P

As others have already pointed out, at large, software is much more reliable today than it used to be. But you also have more of it, some % of which is bad.

Did you pay for that app? If you did pay, did the license allow you to hold the seller accountable for any bugs? No? Ok then.

Ambition. Most software is created too quickly, and the projects are driven by people with more money than wisdom.

> the last straw for me has been OneDrive

Did you ever use Windows 95? Seems like the quality of now and then is a bit the same.

Interesting responses in here.

It's all so vague, it's all to easy to see one's favourite enemy as the culprit.

And if you copy and paste to any of the other apps this firm sells, good luck with the formatting!

Not addressing your question, but your problem: OneDrive is crap, use Dropbox instead.

People get the software they deserve. The market is rewarding that type of software.

Simple answer. Software companies have HR departments.

It's made by giant org charts.

time to market

growing faster than competition

distribution networks

growth hypothesis > value hypothesis

Sufficiently Strong Optimization Destroys All Value

SW in its current state of things is horrible and unacceptable. I agree. I cannot understand how remotely is it possible basic basic intuitive logic fails. I've been in this industries for decades as QA, SW, Pgm Mgr/TPM. And the fault is at all levels. Not just QA.

QA: For the most part QA always wants to do the right things and push but they are so low in say, it matters very little to none. And having worked at FAANG/M, QA's are wives/friends/no industry experienced hires as favors of engineers who couldn't spell QA if their lives depended on it.

ENG: they do what they are told and agreed to an absolute minimum. I.E. don't even bother with boundaries yet alone check corner cases and don't even bother with basic smoke/regression testing before checking in. They rather just break the build and spend 2-3 days on retraction than to spend the 2-3 days of being thorough, complete and working.

TPM/Prj/Pgm Mgrs: Meeting their own badly projected schedules and/or trying to meet unrealistic schedule driven by factor outside of their control.

Prod Mgr: Badly researched, designed and defined product. A good product doesn't need to be explained. It should be designed to just work. Thanks Steve Jobs for pushing that mantra. It's like products for babies designed by people who has no concept of a child, or designing Autonomous driving by a person who doesn't own a car or drives.

A clear example what happened to me today. I have Googl home thingy in every room. As a father to a toddler, having voice control at times is indispensable. Today, I tried to get a mini to stream music but it tried to stream a video stream and complained that I couldn't on that device, but it proceed to then stream the audio portion? And before I noticed that it was, I clarified my request by saying to stream music. So it did...BUT it was streaming the audio portion of the video it says it couldn't do and the new content. I tried everything under the sun to stop one or the other or all on every device...NOTHING. It kept playing. I was bathing my kid and had to dry my hands, get to a phone to manually pull up the home app and kill the streams. OMG. Now my toddler screams one thing and only one thing because that's all that is screamed in our house; "Hey Googl....STOP!"

There is no question the idiot who said, "move fast and break things" is being literally executed everywhere.

Love and hate with Tesla the same. For every update, there are 10 things they break/step backwards.

I have no solution and it's a mindset of next gen companies to give their users quality and quantity. I loved gadgets, tech and all things shiny shiny but the disappointed is almost unbearable.

PS> Now that we have literally an army of geriatrics with time and money. Someone should create the "Grandparents tested and approved" certification. If they can find what they need to do without intervention, you got gold.

I reject the premise

Bad programmers.