Fitting tomorrow’s need without introducing problems today is a sensitive issue. Every item in the “adaptability” criterion means more abstractions in the system, and more abstractions means more complicated (i.e. buggier) code and more bloat. I think that the following issues should be considered during development :
- Hardware portability : First and before anything else, this does not mean that this OS should run on quantum computers and be able to command a matter-antimatter fusion powered spaceship. Work on hardware independence should remain focused on predictable evolution of today’s hardware without aiming to support any possible evolution of it in the future. Acceptable candidates are adaptation to multiplication of processors and touch-based pointing device, along with management of a large amount of RAM : hardware like that already exists, and will probably be more widespread in the future, without its support requiring too much change from nowadays’s one support.
This OS should also adapt itself to the possibility of a decay in hardware performance, too. This means that its hardware requirement shouldn’t increase exponentially. Everyone has seen Microsoft’s failure at predicting the appearance of netbooks that forced them to maintain a somewhat outdated Windows XP, and we don’t want to go this way. In times of economic crisis and focus on mobility, low-performance hardware is more likely to sell widely, and this should not be overlooked.
- User adaptability : The user needs and taste may change, too. User and programmer interface should be based on concepts that are not likely to change in the future (WIMP, processes and threads, etc…), and everything that might get out of fashion should be based on fashion-independent standards so that it may be modified while keeping consistency and application compatibility.
- Simplicity : This is a major component of adaptability, as modifying simple code is easier than modifying complicated one. However, as we’ve seen before, too much hardware support is killing simplicity and hence, ironically, makes adding up support for new hardware more difficult… There is an optimum for this, which we are trying to find.
- Powerful updates : To enforce good adaptability, updates should not become too much of a hassle. They should be easy to apply and not imply frustrating things like having to reboot the computer or wait for hours before it finally shuts down. They should also be manageable on a system-wide basis, and not in a per-application basis, so that the interface remains consistent and there’s less annoying popups. The operating system should help this by providing easy update-related APIs (allowing for example to save an application state, update it, restart it so that changes are applied, recover its old state, all that without significant user annoyance).