3.8 KiB
Future-Proof Technology
Future-proof technology is technology that is very likely to stay functional for a very long time with minimal to no maintenance, even considering significant changes in state of technology in society. In a world of relatively complex technology, such as that of computers, this feature is generally pretty hard to achieve; today's consumerist society makes the situation even much worse by focusing on immediate profit without long-term planning and by implementing things such as bloat, intentional introduction of complexity, obscurity, dependencies and planned obsolescence. But with good approach, such as that of LRS, it is very possible to achieve.
A truly good technology is trying to be future-proof because this saves us the great cost of maintenance and reinventing wheels and it gives its users comfort and safety; users of future-proof technology know they can build upon it without fearing it will suddenly break.
Despite the extremely bad situation not all hope is lost. At least in the world of software future-proofing can be achieved by:
- Free (as in freedom) software -- making your source code available, legally modifyable and shareable is a basic step towards making it easy to repair, backup and adopt to new technology (e.g. compile for new CPU architectures etc.).
- Building on top of already well established, time-tested and relatively simple technology such as the C language or comun. Choosing to use the older standards with fewer features helps greatly as the less-feature-rich versions of languages are always more supported (for example there is many more C89 compilers than C17 compilers) and can even be relatively simply reimplemented if needed. Another example is e.g. OpenGL -- you should use the oldest (simplest) version you can to make a program better future proof.
- Minimizing dependencies to absolute bare minimum and offering alternatives and fallbacks in cases where you can't avoid introducing a dependency (e.g. you should always offer an option for software rendering in any program that by default uses GPU for 3D graphics). Dependencies are likely the single greatest cause of software death because if one of your dependencies dies, you whole project dies, and this goes recursively for all of the dependencies of the dependencies etc. This usually means software libraries but also goes for other software such as build systems and also hardware dependencies such as requiring GPU, floating point, special instructions etc.
- Practicing minimalism and reducing complexity which minimizes the maintenance cost and therefore raises the probability of someone being able to fix any issues that arise over time. Minimalism is necessary and EXTREMELY important, bloat will make your program very prone to dying as it will depend on a big community of programmers that maintain it and such community will itself always be very prone to disappearing (internals disagreements, stopped funding, lose of interest, ...).
- Making your program portable -- this ensures your program can be adapted to new platforms and also that you use abstractions that untie you from things such as hardware dependencies.
- Generally just avoiding the hyped "modern" "feature-rich" (bloated) technology arising from the consumerist market.
- ...