Platform independence is one of the best ways to encourage hardware designers to focus solely on designing better hardware, rather than worrying about supporting legacy hardware.  Most of the computers in the world today are based on x86 architecture and Microsoft based software.  This is not to say that x86 and MS are not a good platform for what we currently use computers for, but technology will change.  If the entire market was to use a platform independent solution for applications, there would be a greater variety of system manufacturers who would not need to make their system compatible with ANY other system. All they would need is the base UniOS abstracts for their hardware. With this, they could run any program made for UniOS. This sounds incredible, compared to what we currently have, however it cannot come to pass unless we change how our applications are distributed to the end user(s).

Applications must be distributed in a hardware neutral codified form.  What this means is, applications must not be distributed in a binary executable form for any specific machine... ever.  Rather, a codified (i.e.. Java Class File, Plain Text C++ code, etc.), form would be used.  Once the user receives the software,  the program is installed with a generic installer (also not machine specific, probably interpreted), and is compiled and optimized with the current hardware set, with the current hardware abstracts.  If the current hardware state was to change, then the program would have to be re-compiled (annoying, but necessary. Hopefully a background operation). This would allow us the greatest freedom of hardware design, and also potentially make applications faster, smaller, and more stable, by optimizing for the specific hardware and conditions of the machine.

This is of course pipe dream design philosophy, and is not perfect. This design allows for easy reverse engineering of code. Without some kind of protection in place, developers will not adopt this type of system.  Java, as an example uses the class system, which reveals which abstract was used, but not how the code was formed. This seems like a likely candidate.