If we had lots and lots of really smart people working on a new version of everything, though, my guess is that we would end up with pretty much the same stuff we have today. As another commenter said, a lot of software projects doing next gen rewrites from scratch fail. The reason is simple: they focus on solving painpoints and forget about the areas that were neatly addressed by the previous architecture.
The best approach IMO is to address the painpoints by refactoring them properly into the architecture. That is often very complex on its own but still has the best chance of succeeding.
But we can also invert our perspective and ask: Will there a dramatic shift to a New Way in the next half century? Since 1970 there have been at least 3 major transitions in how people work with technology, it’s easy to imagine more will come before 2070.
1. 1980s – 1990s Mainframe to PC
2. 1990s – 2000s PC to Web
3. 2000s – 2010s Web to Mobile
In each of these transitions the software written for the Old Way was incompatible with the New Way.
(There have also been shifts in data storage and network protocols that others might point to as major transitions.)
IMO hierarchical deep menus are logical but they take up precious time when you need to do that action 80 times a day. Same benefits can be obtained by well designed layout (with borders, background colors and proper labels).
Most people would find that dauting. I think hiding stuff behind menus is not a good idea even though on surface it might feel like making it less complex. In fact, the complexity is the same, just visual clutter is reduced. I argue that we're really good at looking at visual clutter, my professor's desk is a good example of that.
For the operating system layers, if you build a machine that doesn't expose an ISA, in which all code is run via a polyglot VM like the GraalVM/JVM, then you can more easily design a competitive CPU because suddenly you can use flat, direct physical address space mappings with an ISA that is throwing out old instructions whenever you need to. No need for an MMU, TLBs and all the other page table walking logic, IPC can be drastically simplified.
Singularity / Midori was the most complete exploration of this concept, by Microsoft Research. Unfortunately they kind of went down a few bad R&D paths, in particular, by trying to match the performance of C++ code and relying too much on formal methods - i.e. all stuff interesting to implementors - instead of researching things interesting to developers.
That's why the right way to re-invent computing is top down, not bottom up. Take an existing Linux distro and start to replace bits one step at a time, starting with the desktop environment, the app and data models, network protocols etc. But all the drivers and filesystem goop remains the same - limited potential for innovation there. That said, if you want to, these days you can reimplement drivers in userspace using whatever framework you like, reducing Linux to basically a fat microkernel.
Do you really think that it would be less thought out if we have lots of resources and smart people? I feel optimistic that we can bake in the lessons from the past and improve on existing layers/stack/protocols.