Why Software Rots
When looking at issues of operating system stability and maintainability, the most important thing to understand about software is that as it gets more complex, it becomes more difficult to maintain. (If you don’t believe me, search Google Scholar for “software complexity and maintainability.”)
Operating systems are inherently complex, especially when running multiple program atop hardware with multiple CPUs, so complex, in fact, that they become, for all intents and purposes, “non-deterministic” in the sense that when an error occurs it may be impossible to figure out exactly what went wrong.
Adding features to an operating system (or any complex program) makes it more complex and thus less deterministic in its behavior and thus increasingly difficult to maintain. The only way out of the cycle is to stop adding features, in which case the program will eventually enter a “steady state” where fixing bug A creates bug B.
Depending upon the prescience of the designers and the skill of the implementors, this steady state can be tolerable (as with Windows 10 and MacOS) or intolerable, as with Intuit’s Quicken, which was so poorly designed and implemented that each successive release was a bigger disaster than the previous release.
There are development techniques, like Object Oriented Programming (OOP), that some people believe can help a programming team handle greater complexity without creating so many stability problems. However, there’s no indication that I can find that OOP completely transcends the complexity/maintainability problem.
Even if OOP does improve maintainability (the jury is out on this), there are other factors inside most software development groups that make the problem much worse.
Chief among these is developer turnover. The person who writes a piece of code can always maintain it more effectively than somebody brought on board later. Software that’s around for a long time (like an OS) can often end up being maintained (and extended and updated) by a completely different group of programmers than those who originally built it.
Such personnel changes vastly decrease maintainability, especially if the new programming crew comes from a different programming culture or, even worse, a geographical culture that speaks an entirely different language, a non-uncommon event in a business world where outsourcing is the norm.
Developer hubris is another problem. When programmers (especially young ones) join a team mandated to maintain a complex program, they’re often motivated by their own pride to change something simply to “make their mark” upon the project. A good example of this was when Windows 8 idiotically removed the Start button.
Now, take all of the above and think, not just of an operating system, but of the entire ecosystem that includes the OS and all the applications that access it. Insofar as the applications running atop the OS can alter the behavior of the OS, the combination of the OS and all running apps creates a higher level of complexity.
Apple is well known for its ability to create operating systems that are stable and secure. However, that ability is always contrasted with Microsoft, which is well-known for taking decades to create Windows 10, which is secure and stable only when compared to its truly dreadful predecessors.
The fact that Apple has previously released fairly stable operating systems makes the FaceTime bug all the more troubling. Not to put too fine a point on it, Apple’s development team must be overwhelmed and confused for such an obvious and destructive bug would pass through to system release and for Apple to ignore the problem for nearly a month.
Similarly, Apple’s most recent release of MacOS, Mojave, appears to have had more than its share of stability problems, not to mention some clear indications of programmer hubris, such as the egregious and unnecessary removal of Cover Flow from the Finder application.
In addition, rotting software is a problem even when everybody involved has a clear sense of purpose and direction. But today’s Internet environment is full of bad actors, which range from hackers to predatory companies like Facebook and Google, who are determined to subvert Apple’s controls in order to pursue their own monetization.
Apple has slapped Facebook’s and Google’s wrists, but the very notion of providing these companies with the tools they’ve abused illustrates a conflict of interest in Apple’s software development. It’s not possible on the one hand to build secure systems and at the same time have an architecture open enough to be so blithely abused.
Whatever the root source, Apple’s operating software is well on the way to the kind of feature-creep/architectural rot that’s plagued every complex system. Flakey mistakes like the FaceTime bug will become increasingly common as the company attempts to extend functionality for programs that are already beyond the complexity level where effective maintenance is possible.
So expect more and worse blunders from Apple until such time as they cap new features and put their OSes into maintenance mode, at which case, if we’re luckly, the result will be a tolerable steady state similar to that “enjoyed” by Windows 10.
I find all of this incredibly sad, because while I use a huge Windows machine for animation, I do all my business-oriented work on an iMac and use my iPhone all the time. I have always looked upon Apple as a haven from the instability and insecurity of Windows but with the FaceTime bug can no longer ignore the obvious: Apple is losing it. Badly.