The symptoms are quite obvious to notice however:
- Our current idea of programming is hardwired to the Von Neumann architecture - which doesn't just imply a shism between "processor" and "processed" (thus creating the memory bottleneck), but also singlethreading. It's that age-old idea of a singular subject/god, that commands slaves/objects around. Like mathematics. This also is why our programs must either be perfect or fail totally. Current processors may have multiple cores next to each other, and current programming languages may allow multithreading, but this is all just patchwork - the whole mentality and "approach" is based on singlethreading - not just on the software-level, but also on the hardware-level. The cpu has to babysit EVERYTHING. This isn't something that can be redesigned "on top" - backwards compatibility would need to be axed from the bottom up (slow emulation of the current scheme may however be possible - but who wants to buy a computer that runs current apps slower, yet costs more?)
- Related to the above: Memory is addressed centrally in 1D, but the datastructures become less and less 1D, plus addressing systems get layered on top of each other and become more and more distributed. Thus, the amount of pointers to emulate multidimensional datastructures and virtual memory explodes. Application routines now consist primarily of pointers, and the cpu is mostly busy just jumping around memory locations for no reason except of to emulate nD data, and the virtual memory that OSes and CPUs are supposed to provide, but simply do NOT provide (current vmem is good for nothing, besides of swapping to disk).
- CPUs are small electronic circuit-systems. Heck, ALL our electronic systems are based on circuits. This means that signals travel along clearly defined "channels" - like water flowing through pipes. But what if you make the pipes smaller and smaller and smaller, until you arrive at a point, where the thickness of the walls is thinner than paper? Right, the water/signals leak out of the pipes. This isn't about future - they are already thin enough to leak right now on the machine on which you're reading this post. It's just that the leakage is still low enough to notice it when it happens and then just retry. When however you continue to make them even thinner, the leakage eventually becomes higher than the non-leakage - not to mention that the temperature becomes so high, that the pipes may not even be able anymore to tolerate the heat. This isn't a problem that can be fixed with some magical new invention - it's unfixable for circuit systems.
With the above data i dont mean to imply that its generally impossible to increase practical performance. For starters, you will with the current system see CPUs that are multiple times faster than the current ones - there is some room for improvement left - but the brickwall is already on the horizon. At that point, humans can just make computers larger, rather than smaller (i.e., by adding more cores) - the power usage and heat will become ridiculous (you know, even more than like.... now), but it is doable, if one doesnt care much about efficiency and sanity. After that buffer is also depleted, one may still get practically multiple times more speed, simply by writing applications more efficient than the current bloat of one hundred middlewares stuck together and on top of each other, all of course programmed with 20 abstraction layers. Another alternative would be faster FPGAs that can at runtime reconfigure to implement coderoutines in hardware (though, at that point we're already leaving the von-neumann concept, and "programming" changes)
Beyond this, the circuit-based von neumann machine, would be at the end of the road - conceptually (manageability) and physically. Doing something else would be so different, that for practical purposes, it isn't even a computer as we know it anymore. Who wants to do the whole IT world from scratch? Not gonna happen soon
