No such limits exist on software beyond maybe performance and memory constraints. But both of those are in abundance, so we can and do patch over crap endlessly. Every one of us has had that moment where we think or say, "how does this even work?" But until the user hits the wrong edge case they have no idea how rickety the underlying code is.
> This happens billions of times a day, all across the world, and mostly flawlessly.
No, I'd argue it's much more common for there to be flaws. They're just not obvious. They're random crap like my phone continuing to vibrate after I've answered the call until I get another call or text. Or options disappearing from a web app because something didn't load 100% correctly. Or the joys of flaky Bluetooth pairing. The list is endless.
"Have you tried turning it off and on again" is evidence of this. It's normal for software systems to get into such inscrutably subtle bad states that the only fix is to wipe everything and reload from scratch.
This is kind of what I'm talking about. The absolute massive complexity within your device that you and billions of people to seamlessly make calls from anywhere in the world to anywhere in the world with devices made by all different companies using infrastructure made by all different companies and it all works so incredibly well that we mostly take it entirely for granted.
But yes, sometimes the phone doesn't stop vibrating.
It's one thing to appreciate the natural world around us and how it all seems to work together flawlessly to provide the reality we all experience together—but that's because it's natural, not artificial, like the world of software we have created. When things work less than perfectly in software, there are human causes behind it, which, once identified, could be resolved in order to improve everyone's lives. But instead, most people share your "good enough—it's a miracle it all works!" mentality, which causes acceptance of any and all software issues, which leads to further issues down the line as we say "good enough" and build yet another layer atop it.
It's the stuff at the edges that appears to be less reliable but that's mostly because it's new. It doesn't really feel like that is getting worse though. We are constantly interacting with more and more software than ever before but it's not like everything is broken. The fact that you can reliably make a phone call is far more significant than the fact that the vibration doesn't stop. Both are build on ever-increasing stacks of abstractions.
The difference in that example isn't some emergent complexity -- it's just that one is more important than the other. There are lots of analogies in the physical world where less-important things are crappier than more important things. We don't consider that some crisis of abstraction.
One thing good programmers do well is choosing abstractions that are tested and validated, not popular or hyped.
The stack has not changed I decades. E.g It's still TCP, memory allocations and perhaps SQL. Whether you don't want to learn those is up to you. Learn them and you will know your way around for decades to come.
I failed to communicate clearly. Yes, I agree, the scope of human achievement is amazing, software included. However, the issues with software go far deeper than just the trivial example I gave of the phone. It's pervasive and pernicious. I assume most software developers understand this as lived experience, but I'll elaborate more.
Almost every single person I know who is not an IT professional of some sort regularly comes to me, my son, and others who are IT professionals for help with things that are broken and non-functional to the point that they cannot use it without assistance. And that's just the show-stoppers. There is tons of crappy software that they've just found workarounds for, and they've gotten so used to having to find workarounds that they've just stopped complaining. Not because it's working correctly, but they would rather be happy and accept it than get constantly worked up about something over which they have no control. This is not entirely unique to software, but there isn't really any other mass technology that is as bad as software.
Software is simultaneously miraculous and horrible. Because of computing we have capabilities that would be seen as science fiction or magic not too long ago. But because of the things called out in this article, these magical tools and technologies are plagued by endless amounts of things that just don't work right, break randomly, and fail in unexpected ways.
With physical systems and hard sciences we identify the physical constraints, model the system, and then engineer solutions around those models, refining our solutions as we refine our models. With software we make up the models, rarely fully document them, and slap things together as we go. Some companies do better than others, and some domains take quality and reliability seriously, but in my experience even that correlates to distance from physical constraints. In general the portions of our industry that are closer to real-world constraints (chip manufacturing, control interfaces, etc.) have historically been better about delivering quality software.
If I come across as frustrated it's because I am. I love building software, and I used to love using software, but I am incredibly frustrated by the gap between what we've built and what is possible.
I could keep going, but I'll end this comment with one other observation. I'm not an Apple fanboy by any means, but Apple used to be the exception to this general rules of "software just kind of generally sucks." Apple used to be "it just works." And that was because Steve Jobs was the forcing function on quality. It's possible.
Again, this isn't unique to software. Excellence in any domain requires someone to be the standard bearer. At a restaurant it may be the head chef, refusing to let anything out of the kitchen that doesn't meet their high bar, for example. In every domain there exist various pressures that push quality down (time, cost, etc.) but software lacks the natural floor established by physical constraints, and is unique riddled with problems, IMHO.
> But because of the things called out in this article, these magical tools and technologies are plagued by endless amounts of things that just don't work right, break randomly, and fail in unexpected ways.
There is way more software out there than one can even imagine responsible for literally every aspect of human society. There is an insatiable need for more software and there simply isn't enough software developers in the world to do it all. What you get is triage -- things half baked because of effort. There isn't some problem specific to software with regards to physical constraints. Cheap stuff made quickly breaks whether it's software or power tools or children's toys. It's that simple.
> And that was because Steve Jobs was the forcing function on quality.
Exactly. What does that have to do with abstractions or the lack of physical constraints?
> What does that have to do with abstractions or the lack of physical constraints?
Someone like Steve Jobs becomes a forcing function to maintain a high bar of quality. He's the exception that proves the rule. In the general case you can't rely on someone like Steve Jobs, but in other domains you still have a higher minimal quality bar driven by physical constraints.
I concede that in every domain it is true that "cheap stuff made quickly breaks." My argument is that even then there is a minimal bar that is set by physical constraints. If the bridge doesn't stand it doesn't get built. If you cut too many corners or rush too much it just doesn't get built, or has to be rebuilt. This leads to overages and delay, but at the end of the process the bridge meets the physical specs or it falls over. I think the lack of any such physical constraints means that there is no such minimal bar for software and the floor of quality is therefore much lower, even in software by large, successful, and well-funded, "marquee" companies.
All the same factors are at play: poor planning, insufficient resources, bad management, inexperienced workers, insufficient funding, lack of testing.
Plenty of construction projects have corners cut. Just like with software, it is someone's job to patch it later.
So it’s not so much that we don’t have people pushing for quality, we do. We just can’t agree on what quality even looks like.
Completely agree with this. The number of good+reasonable solutions is almost infinite, and the number of bad solutions is also almost infinite.
What makes it even worse is that we really don't have a good method of communicating the design+structure of our models to others (tech and non-tech). As the system gets more complex the issue gets worse.
We carry so much info in our heads about system models, and that info is painstakingly acquired through inefficient communication methods and trial and error and thoughtful analysis.
It would be amazing if we could create tools that allow us to describe the essence of the model and make it directly available to our brains so we could all collectively reason about it and manipulate it collaboratively.
Fuck that, I need a job.
But I don't think that's the real motivation for articles like these: the real motivation is that things just seem out of hand.
But I think as an experienced programmer you have to balance that feeling of overwhelm with what needs to be done. It's taken me a while to arrive at this conclusion, but I believe it's important. Things will never be completely figured out and you have to be okay with it.
Over the years I've started to tune out articles that say everything is doomed or articles that propose the silver bullet to fix everything. Things are not terrible -- they are, in fact, always getting better. It's never been a better or easier time to be a software developer. But, because of that, the problems we have to solve are harder. The demands are greater. I think this appears to many like we're stuck in place because we always feel like we're behind the 8 ball. The appetite for software is insatiable.
You want a binary answer as in "it never happens with X"? Because for most kinds of project, we say it didn't go well when 1 or 2 of those happen, while we declare a victory in software if we manage to avoid 2 of them.
> And then how much software is actually pretty great?
And now I'm curious about your bar for "pretty great" software. This is obviously subjective, but most people wouldn't look at any practical software and call it great.
This what I think is insane. We interact with probably thousands of pieces of software every day (and I'm probably off by an order of magnitude) and none of it is great? What is the bar here?
It's funny that something that was absolutely amazing yesterday is no longer even so much as great today. I can instantly connect to a remote server from my phone, type some text, and generate a pretty good poem about my cat and all of that is already "meh".
I do not consider a text generator to be the pinnacle of "great software", regardless of how well the code was written. I don't think "meh" is the wrong word.
Literally five minutes after this absolutely crazy-ass technology was released to the world, it's already the baseline.
Most of which you enumerate, if not all, can be traced back to two fundamental concepts; communication and understanding.
Communication because this is how understanding can be propagated and the lack thereof remedied.
Understanding because this is fundamental to the success of any endeavour. Without it one or more of the symptoms above will manifest. With it, they may still, but at least there can exist a pathway to success.
In my experience, the majority of problems in the software engineering industry are people problems. Not technical, nor technology, nor process problems.
This is why communication and understanding are vital to success.
Except for your brain manipulating, and taking signals from, and reasoning about, the computer. ;)
When we press the power button on our computer and it gets to a desktop, our computer has already run through hundreds of abstractions. Just at that desktop it is already the most complicated machine we have or will interact with all day. This happens billions of times a day, all across the world, and mostly flawlessly. And that's just one tiny example.