One thing I really like about software is that it can theoretically live forever.
I know bit rot is real, but with some maintenance, and even a quite small community, it can keep getting revitalized basically forever.[1]
The field is generally still young, so I look forward to good solid software just getting older and older and still working well. Makes it worth learning and internalizing.
C is in its 50s, and doesn't seem to be going anywhere (:
Part of what pains me about much modern software, with its always-online and tied-to-some-cloud-service nature, is that it tends to die. The learning you do goes to waste, when some fickle company pulls the plug in the future.
I like to build stuff that lasts, whether it's a cathedral or a bazaar, and I like to use stuff that was built in that way, too.
[1] Okay, forever is a long time. Maybe some day keyboards will be extinct, and that will make keyboard-centric software obsolete. Same could be true for screens, or even the broad architecture of computing hardware as we know it. But those changes tend to happen slowly, and there's time to adapt.
> One thing I really like about software is that it can theoretically live forever... ...The learning you do goes to waste, when some fickle company pulls the plug in the future.
I think you could say that software lasts forever when it's author wants it to. There is plenty of dead proprietary software that dates from before the era of cloud services; it's dead because, just like the SaaS company that pulls the plug today, nobody thought (or dared) to preserve the source code.
To make sure software really lasts, history shows us that the best thing one can do is to release the code as FOSS :)
One thing i like about Emacs is i can be reasonably sure it isnt going anywhere anytime soon. The GNU version was first released almost 40 years ago and its still actively used and maintained. I like investing my time learning quality tools that stand the test of time.
I think the most important thing for its survival is it needs young contributors who care and thus can one day take over, which seems difficult to do consistently.
It will keep evolving until it's faced with a situation where it just can't move on the correct direction. Probably because of some social reason, not a technical one.
It's hard to imagine this happening to Linux in particular because it's ridiculously flexible. But things always change.
my relatively myopic view: due to enterprise "laziness", we have been able to enjoy backwards-compatibility for the longest time. x86 has done a lot for this, and i wonder how much future code could benefit from this.
on the other hand, most new code sold is not designed with longevity in mind. everything has support lifetimes, and the same thing gets rehashed under new banner and sold. the incentives are not aligned for long-lasting stuff. can't have old opera buildings if the new concerts set up tents every season.
regardless, C is too big to never get worked on supporting for future hardware.
The field is generally still young, so I look forward to good solid software just getting older and older and still working well. Makes it worth learning and internalizing.
C is in its 50s, and doesn't seem to be going anywhere (:
Part of what pains me about much modern software, with its always-online and tied-to-some-cloud-service nature, is that it tends to die. The learning you do goes to waste, when some fickle company pulls the plug in the future.
I like to build stuff that lasts, whether it's a cathedral or a bazaar, and I like to use stuff that was built in that way, too.
[1] Okay, forever is a long time. Maybe some day keyboards will be extinct, and that will make keyboard-centric software obsolete. Same could be true for screens, or even the broad architecture of computing hardware as we know it. But those changes tend to happen slowly, and there's time to adapt.