The concept of software rot due to old hardware, dependencies, updates, connectivity, architecture/application changes is something different and has to do with the design of software and (as correctly stated) not with the ageing or fatigue of the software.
[0] https://en.wikipedia.org/wiki/Software_rot [1] https://en.wikipedia.org/wiki/Data_degradation
If I can't find hardware jumper information anywhere, some older cards are simple enough that knowing ISA or PCI bus pinouts, searching Octopart for datasheets, combined with a quality DMM can be used to painstakingly trace and determine functionality.
The other component necessary is the human brain-dump knowledge (wiki perhaps) of "what does what" to make sense of it.
The "let's delete everything old because old doesn't matter" mindset is how we lose past works forever. (If anyone can find "Mouse Commander", an independently-published TSR utility for Welltris to add mouse control, you'd be my BFF.)
PS: Interestingly, Matrox and the acquirer of Adaptec (Microchip) still have many drivers available. NVIDIA is also okay, but sometimes needs IA to get the last supported version of a particular driver.
In my experience, a sort of opposite of this sentence tends to be true.
Modern systems have too many dependencies, most of the time needlessly so, but still required. I recently used a Python package that required a specific version of the pandas behemoth to run, but it was only used to parse a date. Absolutely ridiculous.
On the other hand, the 40-year old Fortran code that everybody uses to compute special functions compiles and runs OK in a modern computer, and is completely standalone with 0 dependencies apart from the compiler.
Any non trivial 40-year Fortran code though works with a specific compiler good luck getting that to run on a modern computer.
Also to note is that date parsing is complex. I can see why most would prefer to use a properly tested lib to do it. I've seen far too many handcrafted date parsers that suck and break in crazy ways over the years.
This seems to be an unfortunate property of software related to web development and similar stuff. Fortunately, scientific computation moves at a more reasonable pace. There are new algorithms every day, but no new "frameworks"!
Catabolism is another aspect of thinking about code as an organic entity that I find useful. Anabolic (growth) processes and catabolic (teardown) processes always accompany each other in biological systems. Too often we neglect to continually tear down and remove unused aspects of our systems. Both anabolism and catabolism are always operating, though at different rates depending on the environment and needs of the organism. The funny thing is that catabolic processes will happily tear down important parts of the system, forcing them to be anabolically rebuilt. Things like bone and muscle mass. This seems wasted, but it has an extremely important purpose: uncontrolled anabolism is cancer.
I think the analogy to code is obvious. We've all seen codebases that have gotten out of hand (gotten cancer), and part of the reason they got that way is because the growth pressures had no countervailing teardown pressure. The market provides selective pressure in nasty ways: codebases and systems with cancer slow and die, and are replaced by younger codebases without uncontrolled growth.
How do we break that cycle? By encouraging catabolic activity culturally within our companies and codebases. Cleanup is incredibly valuable. Functionality that isn't being heavily used and is complicating implementation of new work should absolutely be on the chopping block. We don't have to be quite as aggressive as biological systems, but we shouldn't take their example lightly either.
This also provides insight into when cleanup doesn't matter: when the survival horizon of the organism is sufficiently short that cancer frankly doesn't matter. Startups shouldn't worry too much until they have product market fit. Once it's clear they'll be around for years more though, catabolic work will help ensure future health.
Today we've gone well past document-embedded-virus payloads and XSS and infected USB sticks to log4j, rowhammer, and spectre. And we've barely even scratched the surface. Just wait until JSON and XML exploits (i.e. exploiting differences in decoder behavior) become common!
Bitrot is only going to get worse, and we're going to need to design our systems and formats and protocols explicitly with change in their DNA so that they can evolve to meet new threats.
Bitrot is also one of the things we have been fighting for a long time. That is why we have new file systems that scrubs the whole disk now and then, checking for bitrot and repairs while it's still possible.
Edit: Saw now that the article isn't even about bitrot. In my world bitrot is when data on the disk changes without anyone doing anything to it. A bit flips from 1 to 0 by no help from humans. This can be corrected automatically with checksums and backups. Against humans changing things they don't understand nothing can help you :-)
1. People modifying a large codebase generally don't have a complete understanding of the codebase (and this becomes more common the larger the codebase is). 2. "Chesterton's fence", i.e. modifying something you don't understand often has downstream effects you are unaware of.
It's the codebase equivalent of the 2nd law of thermodynamics - entropy always increases =).
That viewpoint also partially explains Djikstras opinion; the software he made can be presumed to have been above average in quality so therefore it probably also aged better than most.
I am wary of hastily agreeing that Dijkstra missed something. He may have been talking about specific, general purpose algorithms, which do not change much once conjured. There is another type of software, though, a software that sits atop the immutable spellcraft, a software that attempts to shake the boughs of profit trees at specific points and places in time and space.
Dijkstra says “Famous is the story of the oil company that believed that its PASCAL programs did not last as long as its FORTRAN programs "because PASCAL was not maintained".”
The oil company folk are the kind who prefer tree-trembling to the deep and unchanging sea.
I, too, when cold and hugging uncertainty for warmth, prefer to cut down trees for fire than to spelunk for hard diamonds.
“…we aren’t yet good at thinking about the intended lifetime of a software system when we’re designing it.”
And sometimes the life expectancy is so short that any old (or new) design will do.
Anecdotally, I've seen software being developed for the sole purpose of an event that would last a couple hours, software whose client needed it for the evening when calling in the morning, etc. It's a form of bitrot too: the code, event-specific, is as useful to us as the memories of said event a couple years in.
From the Wikipedia article he linked for software rot:
“[software rot] is not a physical phenomenon: the software does not actually decay, but rather suffers from a lack of being responsive and updated with respect to the changing environment in which it resides.”
The software doesn’t physically rot. Its relationship to something (the world) does.
I attempted to draw a parallel of this to a database because, for many folks, the immediate environment of their app is a database of some kind. The world is kind of like a database, too, because it is read from and written to. But unlike an in-house data store, it changes without regard for dependant applications.
In the second paragraph I attempted to distinguish two kinds of programming endeavours. One is like chopping wood for fire, the other like retrieving and then cutting a hard substance. Whatever the purpose of the latter, it takes planning, experience, and the result is both intended to last a long time, and to be versatile. But the former is cheap and short and for the moment. You’ll have to do it again, many times, and in slightly different ways, depending on where you are, who you’re with, what the weather is like, and so on. Dijkstra’s seeming dismissal of rot may be directed against the latter, but not the former.
I guess my third commentary is that many, many software systems are not designed at the time of their construction, because they are sudden and their manifestation is opportunistic. This lack of design at the point of construction is an implicit assertion against the expected lifetime of any such system. It admits rot as a matter of course.
