It seems that the computer hardware development has been stagnant for about a year now. If the projection of the industry from a couple of years ago still holds, we would be seeing mainstream computers running at 10GHz, utilizing 8GB of main memory nowadays.
But it seems that the chip manufacturing process had encountered numerous problems while moving down to 65nm process and below and the maximum power envelope has become and increasing problem in modern processor design.
Now the trend in processor development is multi-core CPUs. While multi-core processors can alleviate the burdens on CPUs running multiple processes, traditional single-threaded programs unfortunately would not benefit much since they are not able to fully utilize multiple processing units. And, for the foreseeable future, we would not see the majority of programs converted to utilize multi-core processors either, since there is a huge gap between current programmers skills in developing multi-threaded applications and rewriting all existing software would be prohibitively expensive.
Unfortunately, the software industry has been betting on the fast growth of computer hardware. A lot of new applications require much beefier computers to run. On the one hand, software has become more and more sophisticated and indeed needs more processing power on the clients end. But on the other hand, optimizing code has become a lost art for many fellow developers because for the past ten years there has never been such a need to write faster code to perform the same functionality. You have always heard such arguments as dont waste your time trying to squeeze more juice out of the existing software, you can afford a faster box to run it and the problem would go away. This thought is no longer true however as todays software becoming more CPU bound than IO bound.
A few of things are bound to happen should the current trend in hardware development continue:
- C and C++ based application will become popular again : Java and .Net are the most popular platforms under which many new applications are developed. While productive, the drawback is that the byte code (or MSIL) needs one more level of compilation (just in time compilation) at run time. Also, garbage collection is not a guaranteed process and always kicks in at the most unfortunate time. Many of the advantages these modern languages offer could be justified only when the underlying hardware can absorb the overhead that they have. And if we do not see any significant improvement in the hardware realm, sooner or later, these modern languages would become too inefficient for us to write any large scale software. C and C++ however are very efficient and scale very well by nature. They do require more thorough understanding of programming however. But if the hardware trend holds, software efficiency would become a major factor in deciding what kind of languages we use.
- Programmers will be forced to become more sophisticated and write multi-threaded applications : Traditionally, only hardcore game developers and operating system kernel developers utilize multithreading heavily in their day-to-day development. The majority of developers would prefer simplicity; they would develop multi-threaded applications only when it is absolutely necessary. The constant improvement in computer hardware has made this approach forgivable. If a single processor can just run so fast and the only choice is to spread the workload over multiple processing cores, all of a sudden, we will find that writing multi-threaded applications is no longer a luxury, but a necessity.
- Programmers will need to re-learn the lost art of optimization : Less than ten years ago, you would find lots of articles discussing how to write an efficient routine to handle a certain task. Youd always find the debates such as how to do a certain kind of calculation as fast as you could, or whether to use double or float in your application because of the performance ramifications As it turned out, most of those fine-tuning process become obsolete since the computer nowadays run so fast that saving a couple of processing cycle makes little perceptive difference. This situation however would likely to change as most of todays software is so bloated that probably less then ten percent of all the processing power is actually utilized. If a process must be single threaded, it can run just so fast if the efficiency is not improved.
- Software architects will have to re-evaluate the now-popular heavily tiered approach in designing new applications : A multi-tiered approach is favorable in most businesses because it reduces maintenance cost by allowing a single tier to be swapped out without affecting other existing code base. Every tier, however, adds more inefficiency to the system from a pure performance perspective. If hardware development becomes stagnant (or slows down), software architects will have to re-evaluate their approach to developing high performance software. Some maintainability considerations have to be dropped in favor of performance.
Whether or not we see these assertions becoming realities, one thing is for sure: we can no longer just count on hardware to give us performance. As developers, we need to pay more attention to what we write and how it translates into real world performance.
