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.

And the people who made the brittle architectural decisions aren't the ones suffering the fallout increasingly often; with companies shunning internal promotions and substantial raises, more and more developers turn into nomads who switch companies every other year just to keep up with inflation. They rarely if ever get a chance anymore to grow with a single codebase and learn what makes it stable and easy to iterate on long term.

Ugh. Ain’t this the truth. I’m stuck working with Laravel because of this. The two people that pushed for Laravel the most are now gone.

Bitrot is unavoidable, unless code is rewritten from scratch. Complexity rises proportionally to the number of links, which is `n(n - 1) / 2`, where n is a number of nodes, or `n²/2` for large n.

It takes significant effort and lots of experience to beat n², to keep code simple. The easiest way to reduce complexity is just to rewrite code from scratch. The harder way is to drop some old nodes (concepts, files, database columns, cases, fields, steps, etc.) when introducing new ones, which may shock somebody who has no formal training in software engineering.

Steve Jobs probably understood that.

I take pride and joy in the sheer Quality of my work. I am quite aware that most corporations consider the way that I develop software to be “inefficient” (i.e. doesn’t result in inbound cash flow).

But I work surprisingly fast. I often have to pause, in order to let the team catch up. That is what comes from over 30 years of programming experience, where Quality techniques become rote habit.

My approach doesn’t always win friends. The people I work with, absolutely love the results, but everyone else seem to think that I’m a “snob” (may have a point).

I’ve learned that it’s best to just keep my opinions to my own work (or the work of others, that I plan to integrate into my work).

Also as any historian will tell you there was a LOT of shitty quality stuff produced back in the day as well. It's just that nobody bothers to keep a wooden cabinet or a woolen greatcoat for multiple centuries unless it is absolutely magnificent. You can still get great quality bespoke furniture/clothing/etc today btw, but don't expect IKEA prices.

I also worked for a corporation (Japanese) that is pretty much synonymous with "Quality." It was a religion, there.

In most American companies, the running joke has always been, that if you have "Quality" in your job title, your career is over.

At this company, it meant that you were a high priest.

Amusingly, my career actually started with a Quality bearing title.

Maybe I should try a Japanese company one of these days. See how the real adherents of Demings-san do things.

For example, we used to joke about "The Japanese 'Yes.'"

This was where we would patiently explain how some command/policy/idea would not work, and the person that we would explain it to, would understand perfectly, and say "Yes, you are correct."

Then, they would instruct us to do it, anyway, because some higher-up said "Make it so," it was in the project plan, or it was corporate policy.

I'm much more tolerant of the straightforward "Yes, because..." than the American "but I can't".

One is still potentially a productive conversation, the other is a platitude, and exhausting. I will take that into advisement however.

https://dilbert.com/strip/1996-06-02

Analogously, people sometimes ask why the average perceived quality of classical music written in 1810 or so is so much higher than the quality of music being written today. Well, the real average quality of 1810 music wasn't higher; we just don't bother performing or listening to the bottom 99% of music written in 1810 that was not very good. We only listen to Beethoven and a few others who were at the very top. This creates the inaccurate perception that "most music was really great in 1810, much better than today; standards have slipped and nobody cares about quality music now."

Fifty years later the fence still surrounds the back and side yards of the house in Mountain View. As Jobs showed it off to me, he caressed the stockade panels and recalled a lesson that his father implanted deeply in him. It was important, his father said, to craft the backs of cabinets and fences properly, even though they were hidden. … In an interview a few years later, after the Macintosh came out, Jobs again reiterated that lesson from his father: “When you’re a carpenter making a beautiful chest of drawers, you’re not going to use a piece of plywood on the back, even though it faces the wall and nobody will ever see it. You’ll know it’s there, so you’re going to use a beautiful piece of wood in the back. For you to sleep well at night, the aesthetic, the quality, has to be carried all the way through.”

As a professional programmer and amateur cabinet maker, this is a weird quote. I get the point of what he’s trying to say, but the truth is that all the most beautiful wood goes to the veneer mill to make very expensive, very nice plywood. Plywood is not MDF or particle board and there’s absolutely no reason not to use it for the back of a cabinet.

If Steve cared about the user he wouldn't have had to say it. Because they would have found that bug in testing. So either they knew were incompetent and didn't know about it or they were incompetent knew about it and said fuck it the idiots would buy it anyway.

Did he? at least according to my experience Apple cared about the looks of things and not whether they actually work flawlessly.

That attention to detail was one of the reasons people loved Apple products and why so many Mac-only or truly Mac-native apps exist. Contrast with windows where most "native" apps are either Qt-based or some WPF monstrosity full of custom controls. Microsoft Office has its own UI stack ffs.

That doesn't mean his vision was always good though, or that he was a good designer (he was good at picking things and making sure they fit, but he didn't come up with them himself)... Some decisions are just baffling to me, seriously how long did macs stick with 1 button mice?

There are plenty of other examples, in interviews and stories from internal events, which corroborate he cared deeply about Apple products working well.

Raising the quality bar quite high before you call a feature done is generally the correct call. Yes, your software might not check off every box on some list, but you can ensure the features people care about work well.

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 :-)

Sadly, it did not stop there. When I worked as Windows sysadmin / helpdesk monkey, I had to install Windows 2013 on several machines because it just stopped working for no apparent reason.

On one machine, an update to Office 2013 broke Autodesk Inventor (by replacing/updating some vbs file, I suspect); reinstalling Inventor kind-of worked, but it caused MS Outlook to crash whenever the user tried to write an email (some might consider this an improvement, but not everyone agrees). Reinstalling Office fixed that without breaking Inventor again.

The worst part - from a helpdesk perspective - was that there was no rhyme or reason to it, this type of problem would pop up randomly on some machines, while other machines with practically identical hardware, OS, and applications installed ran perfectly fine.

> Electron may be new but it's as efficient as software has always been: insultingly, laughably so

Electron is definitely bloated, but it's possible to write sufficiently fast¹ software like Visual Studio Code. It can't be put on the same basket ("insulting") as Sage Payroll.

¹="sufficiently" fast, not "blazing" fast

https://github.com/microsoft/vscode/issues/118308

Can you provide references of this fork? It you actually look at the VSC manifest, you'll find that the vanilla "electron" is a dependency.

> And they're probably going to move to because electron is still slow and terrible.

I take you haven't used Visual Studio Code. As I wrote, it's certainly not the fastest editor, but it's fast enough for professional usage. It's actually faster (or comparable at least) to other "famous editors".

> https://github.com/microsoft/vscode/issues/118308

This doesn't have any actual technical content; it's essentially a variation of Rewrite It In Rust.

https://github.com/microsoft/vscode/blob/main/package.json -> "electron": "13.5.1",

Referenced github issue seems to have only random people unaffiliated with the project team.

I beg to differ on Electron: I have never seen a single use of it where it doesn't use an extraordinary amount of RAM and there mere concept of using an embedded web site browser for a GUI is simply an unacceptable thought, let alone a realisation of modern-day software. It should have never have happened.

This is meaningless without context, as editors typically run indexing processes in the background. I used to use $beloved_native_editor, which in some cases ran at 100% single-thread for extended amounts of time (due to indexing).

> It takes an age to load. It uses heaps of RAM with no projects open [...] I have never seen a single use of it where it doesn't use an extraordinary amount of RAM

I've taken some real-world measurements, with the disclaimer there is no universal interpretation of measuring memory:

  >  Private  +   Shared  =  RAM used
  >
  >   8.9 MiB +   9.1 MiB =  18.0 MiB
  >  17.0 MiB +  17.3 MiB =  34.3 MiB
  > 119.2 MiB + 149.4 MiB = 268.6 MiB
  > ---------------------------------
  >                         321.0 MiB
  > =================================


  >  Private  +   Shared  =  RAM used
  >
  > 332.1 MiB + 519.2 MiB = 851.3 MiB
  > ---------------------------------
  >                         851.3 MiB
  > =================================


  >  Private  +   Shared  =  RAM used
  >
  > 124.0 KiB + 176.0 KiB = 300.0 KiB
  >   1.1 MiB +   1.1 MiB =   2.1 MiB
  >  95.5 MiB + 200.2 MiB = 295.6 MiB
  >   1.3 GiB +   1.3 GiB =   2.5 GiB
  > ---------------------------------
  >                           2.8 GiB
  > =================================

The editors are vanilla installations, and I've opened the directory of a relatively large project. The machine is a modern desktop one.

The editor that people love to hate is not the one you'd expect.

I hope you are not describing Office 97 which is widely regarded as the best version of the Office suite. As for being bloated - today's "apps" would like to have a word with you ;)

Only in retrospect. I was in high school when it came out, and I vaguely remember one of my classmates griping about it being slow and/or bloated.

As for the rest. I don't specifically remember many issues with Windows XP, if the install was kept tidy. Symantec was probably the source of your woes and many people used to use AVG.

The other problems that people frequently had was that a lot of software used Win 95/98 only hacks which wouldn't run on XP (or anything NT based).

XP 64bit (for x64 machines) however was the best Windows OS I've ever used. Fast and super stable.

People used to complain about Vista being bad. However that was mainly a problem with 32bit Vista. 64bit Vista was again amazing.

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.

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.

A while back I came across a couple channels from various government agencies and organizations that document industrial accidents. They were quite interesting to watch, but after watching several they make me wonder if the companies do care with or without the laws.

Modern software is in fact more reliable than older software.

> Modern software is in fact more reliable than older software.

Putting this as "90s vs now" is borderline strawman IMO.

I genuinely believe the peak in terms of performance and polish was somewhere in the early-mid 2000s; developers of the time had experienced the 90s and true shortage of CPU time and other resources. The mindset was still alive, even if PCs had gotten very powerful by 2005.

Mid-to-late 2000s mark the start of mass webification and mobilification of software. "Mobile eats the world" and "nobody wants to install software." In my experience it's been downhill from there; software started being developed with a completely different mindset and completely different approach.

During the early phase of this transition, your bottleneck was invariably network I/O; so developers didn't really need to give a crap about CPU cycles or RAM. Lack of UI polish could be blamed on the web being what it is, a document platform coerced into becoming an application delivery platform. Most of the early "app web" applications were truly horrific compared to "native" software, but no matter, the web was considered more accessible and a better platform for developers. And users didn't have to INSTALL SOFTWARE! Woohoo.

Of course the constraints are not the same today, but the original mindset that held until early 2000s is long gone. For example, instead of trying to stick to your platform's long established UI conventions as you would if developing Windows software in 2000, designers nowadays are more concerned about branding and making up their own experience; every "web app" looks and feels and behaves different.

Now as for reliability, I can't say whether the mid 2000s were worse or better than today. 90s software definitely had a lot of issues, but I had no trouble running Windows XP SP2 with months of uptime. The nature of software failures has changed, and today you have less crashes (though they're still there), but on the other hand, I regularly see applications being confused about their state, being stuck trying to do something that evidently doesn't succeed, infinite spinners, "whoops, something went wronk", "we can't serve your request at this time" and "please reload and log in again." If we consider all these to be failures, then I think software in general isn't any more reliable than it used to be. Updates are another interesting phenomenon; back in the day, I wasn't forced to update. I never lost work or had to reboot and restart everything because of updates.

And then ignore all the stinking piles of garbage that actually made up the past.

This is nostalgia in action. Those rose-tinted goggles have slipped down over your eyes. You remember "Windows 2000 was great", you don't remember "Windows ME was so bad it was literally (not metaphorically literally - literally literally) unusable, and Microsoft STILL SHIPPED IT!".

I never actually said I agreed with the nostalgia; I was just clarifying the position of the person you were replying to, and what I perceive to be widely held opinions.

> Windows ME was so bad it was literally (not metaphorically literally - literally literally) unusable

Perhaps it was that bad for some people. If so, that's unfortunate. But I ended up with Windows Me sometime in college, and it was usable enough that I used it to develop and ship the first few versions of the first commercial software product that I was hired to develop. So it wasn't that bad. Still, once I could afford a PC with Windows XP, I got one and never looked back.

One of the weirdest examples I know of was a particular series of desktops, sold in the supermarket with ME. I knew 2 people buying identical machines in the same week from the same supermarket. One of them worked flawlessly. The other one was such a miserable crash prone machine. We forced Win98 on the crasher and all was well again.

It turns out it's not all roses and bliss. It's basically the same half-baked, mostly unusable, bucket of dirt you dig through to find the diamonds.

But everyone only ever remembers the diamonds.

I don't know if anyone is measuring this objectively, and I assume not. So we might not ever be able to say whether the claim is objectively true or just my subjective experience. But it's not fair to dismiss the whole argument by mischaracterizing it.

Faster, more capable hardware hasn't necessarily made modern software better. In many cases the opposite: apps are slow and gobble up computer resources with no restraints.

Not exactly a new phenomenon: applications always grow to exploit new features offered to them

Today, developers choose languages and tools that suit their comfort first. The user's comfort often takes secondary consideration.

So in my memory it was not the hardware.

There have been a lot of improvements in the meantime that have led to better software, amongst others: version control, automated tests, automated deployments and more useful programming languages.

I'm not sure those are reliability issues.

Perhaps the lack of memory protection and the catastrophic consequences of an app crashing made Mac developers more careful and aware of the importance of stable software.

Everyone I knew with an iMac had a toothpick or paper clip in the top handle, due to how common they needed to press the reset hole.

At the time my father used to edit a local news paper in PageMaker and it was particularly bad.

I went to a middle school that was "mac only" in the 90s. They were complete and utter crap.

They crashed constantly. The spinning pizza of death made a near hourly appearance.

We had two machines issued to each classroom, and most times the kids wouldn't even turn them on they were so bad.

What kind of Mac were you running?

The straightened paperclip was only there to eject recalcitrant floppy disks (early on), and then recalcitrant CDs later

Restarting the machine was always a menu option or physical button

Never heard of someone needing to reset any of them with a paperclip before

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.

I don't think you're negative at all, but the "fingers in their ears" is based on a misunderstanding. Companies have their ears wide open and their customers are telling them -- mostly indirectly by voting with their wallet -- that they want quick and dirty features over quality. Your suggestion to punish bad quality would actually help these companies by removing those perverse incentives.

One thing I've been banging on about at web teams I work with is to measure the relationship between time to first contentful paint against propensity to buy/click/watch/spend time-on-site/do whatever the relevant value metric is. For the analytics tooling that teams usually have in place, that's crossing two completely disconnected toolsets: you've got the behavioural analytics tools, which are typically owned by someone else in the business, and then you've got the technical observability tools, which are usually owned by the development team, and marrying the two up can be astonishingly hard to make happen.

this

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.

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?

Do they get the choice to?

It's not like I can get a less buggy version of MS Windows by paying an extra $20.

And while many open source projects accept donations, and many enterprise products offer support contracts, it's not like $20 gets you a guaranteed bug fix.

I agree with your point that companies don't always have a good business case to produce quality software - but we can hardly blame customers for not buying things we aren't selling :)

Yes. At least somewhat. There's a reason lots of competing products become popular, e.g. Google Sheets taking some of the popularity of Excel. New features like live sync actually matter. And to the extent that users actually care about quality, software with better quality will evenutally also win.

I mean, I'm using an iPhone. I'm using a Mac. I'm paying a huge premium over someone on Android and Windows. I do it largely for the quality of the Apple ecosystem.

But yes, there are still problems. The world of products is hard. :)

On that note, Google Sheets became popular because you can use it in your browser and because of Google Drive which is what locks you in. Sheets is much more open than my examples.

For an open source project, consider what it would cost to hire a contractor to implement the fix and get it to a state where the fix would be accepted by the project.

In a lot of cases, the customers aren't buying it, it's "free" (the cost being not monetary but elsewhere) and no new entrants can compete with the giant piles of cash the incumbents are sitting on

It has mainly settled at a local maximum. The software is good enough, money is tight, the priorities are different and procedures are bureaucratic.

Switching to new and better software means, first making it a priority. The procedure for larger schools also mean getting legal on board, writing an invitation to tender, etc.

* 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.

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.

He's also often collaborates with Jonathan Blow.

It feels like it could be a possible scenario that we otherwise end up in a situation where software in general become unmaintainable in practice.

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.

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.

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.

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.

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.

Now everybody does.

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.

Of all the answers proposed in this entire thread, this is the one I agree with the most. You put into words exactly what I’ve been thinking for years.

The fundamental problem is the lack of accountability for the product owner.

Consider the film industry: A reputable film director owns the film in the sense that their reputation and career depends on the quality of the final product. They still hire/outsource massive swaths of the work needed to produce a movie, but they are the person held ultimately responsible.

Contrast that with some well-known software like Microsoft Teams. Teams is probably the worst piece of shit software I’ve used in 30 years. Who the fuck owns Teams? Not Satya. I have no idea. I bet no one at Microsoft can answer that question. The answer is probably nobody at all.

I sort of wonder whether software engineering is just weird, in the sense that in theory a director could probably do most of the jobs in a movie production, e.g. point a camera, select cast members, acting, set construction. They would do them badly, but they would have some idea of what is involved and what they want.

Software is so iceberg-like that such equivalent direction seems impossible without a technical background.

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.

I've seen some movement in some aspects - I no longer have to fight for introducing automated testing - however this is mostly cargo-culting which means I have to fight for doing things in a relevant way instead of accepting copy/pasting stack overflow.

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.

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.

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.

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.

Still, I think that this is somewhat corrupted. A beautiful, comfortable, durable chair is better than a ugly chair that breaks after 1 year. Still, probably the ugly chair will have a way larger financial margin. Guess what companies are going to produce?

I guess it's yet another demonstration that no matter how perfect a system is, it won't set people free from morals, from taking their own responsibility to make the world a better place. Beauty and good will always need to be fought for.

Slack or Teams? I've never heard anybody say they prefer Teams, yet it is used everywhere. Probably because of lower direct costs and it integrates with all the other Microsoft stuff and active directory automatically. Maybe if we could measure happiness and productivity costs it would turn out to be much more expensive.

WhatsApp or Signal? If you value privacy Signal is definitely better, but if none of your friends is willing to use it that doesn't matter a lot.

In this case - probably yes, and even making own one is feasible.

It is not as bad case as with mobile OS where making own is infeasible and among existing ones all are terrible. You can only select flavour of terribleness.

> in general, the incentives given to developers by companies / society does not align with better quality software

Exactly

> Still, probably the ugly chair will have a way larger financial margin. Guess what companies are going to produce?

Ideally there would be both company producing cheap ones (IKEA) and ones producing masterpieces (carpenter making one-off furniture on request) and anything in range.

> Beauty and good will always need to be fought for.

++

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.

I just had a video call with someone halfway across the world, but got bored, so I pressed the home key on my android so it became a windowed call so I could scroll through Instagram instead. All on a $500 phone.

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.

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.

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.

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.

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.

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).

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.

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.

Indeed. I weep every time I see how many layers of layers today's software is build upon.

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.

Unless you meant Visual Studio, but that wouldn't be a fair example at all.

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.

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.

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.

Why bother caring?

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 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.

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.

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.

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.

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.

- 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.

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.

GUI and Web frameworks seem to change too quickly to make it worth the while to study them. Despite advances in software engineering elsewhere, frameworks in these two areas have become more complex instead of more simple.

Rapid pace of change, technical debt, proliferation of options even for one language.

The good news is there's plenty of work to be done here to clean things up. The bad news is this isn't something that one can do alone (as much as I like Linux, on the desktop applications lack uniformity much more than on MacOS X or Windows).

The solution? Smart app developers build the business logic as API and try to maximally decouple the UI from the business logic. But this doesn't work well for all kinds of applications: e.g. it's hard to do for a WYSIWYG word processor, whereas it may be very easy for an image format converter.

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.

- 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

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.

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!

I'm using Linux as my daily driver, usually work from the commandline and have multiple screens which I can cycle through with a keyboard combination.

This way, I'm at least 3x more productive (speed, efficiency, ease of use) than Windows. Most of the time, I'm not even using a mouse.

I said 2 years ago I would switch to the Raspberry 4 as my main driver, but it's still on my side monitor, with the keyboard on the side!!!

I'm waiting for higher KWh prices... probably next winter I'll have to switch!

I can't fix that employers are exploitive due to prevailing incentives; I can't get rid of the Jack Welch wannabes, the unethical fintechs or feature mills, the daftness that is the perpetually inflating asset bubble, etc... Yet despite that I try hard on a real regular basis to help people navigate an ungodly complex networked world a smidge easier every day; and all I've gotten out of it is trauma, hate, discontent, and a precious handful of really amazing people that all try to keep each other sane while we watch the world seem to burn down around us.

I never sacrificed, nor accept the sacrifice of standards, and I will continue to pound those into to anyone mildly receptive. Until everyone stops seeing Software as the latest lottery ticket though, this isn't going to stop. At all.

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.

Minor renames and similar fixes would be fine, but at work I'd get in hot water sooner or later if I added (more) random fixes to my pull requests.

While this is not the case all the time, a very good reason is that some times one persons bug might very well be another persons feature.

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

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-...

MS could afford to do it right - hire a few dozen elite native developers who can code it up in native C# with 10x the speed and 0.1x the resource consumption like they did for every other MS Office application, rather than this half-baked layering of 3rd party frameworks on top of an interpreted language on top of a web browser...

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

Pick any or all of them as fractional contributors.

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

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.

It sounds like OneDrive is a file syncing solution where they hacked on some photo browsing functionality to preview a handful of pictures in a directory and it's not thought through for people who actually want to use it for more than that.

Some people might really be happy with having 500 images in a directory.

With 130,000 local thumbnails and the right data structures you'd think you could browse quickly, but it is a lot of thumbnails (might not want to store that much.) It would make a big difference if you had SSD or a hard drive or could afford to store a lot in RAM. If it is based on cloud storage you have an entirely different problem but also different solutions available (e.g. when you log into the application a huge amount of data gets spooled into RAM sequentially so temporarily you are using vastly more resources than would normally be available; this is a lot of why gmail and google analytics are so responsive.) There also are tricks that would make scrolling from the beginning to the end seem really fast but not be so good at scrolling into the middle.

In my case I am dealing with 50MB RAW files from my camera which are admittedly excessive (most of the pixels are surplus, I shoot pictures that look great on a screen or on a 8.5x11 print but if I zoom in they rarely look 'tack sharp') The scaling of that is a different story than 0.5MB JPEG files.

I remember iPhoto being absolutely awful circa 2010 with 10,000 local files on a magnetic hard drive. You're telling me it is much better w/ cloud storage in 2022.

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 was not tested with that large folders.

too few developers enjoy their job

managers are incompetent but multiply like flies

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

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

growing faster than competition

distribution networks

growth hypothesis > value hypothesis

Sufficiently Strong Optimization Destroys All Value

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.