Programming Trends: What Next?

Are you a software programmer wondering about what is going to be the next trend in field of software programming? If yes, this post might help you to answer some of your questions.

In last few decades we have seen transition of software development process from low level (binary) programming to High level languages (via assembly language programming). The main driving factors which called for change in programming model were increasing complexity of applications. We also realized that just “High Level Language” is not effective for modern applications. A high mismatch between the amount of software which needs to be written and the availability of software programmers( the later is less) calls for highly efficient software development methodologies. This inspired a lot of research on Software Processes and Design Techniques to improve the individual and team efficiencies, which has now matured to a great extent. Now the focus is on “Automatic Code Generation Tools“. Though there are a number of such tools available (for different languages), but it will need a lot more research to make these tools reliable and user friendly.

Coming back to the question of next trend in field of programming. Let us again have a look at what in past inspired changes in programming methodologies. The major driving factor was increasingly complex applications. What enabled the transition from simpler to complex applications? It was availability of complex hardware. We have transitioned a big way from days of 8085. The modern processor might have over a billion of transistors operating on GHz frequencies. So, in order to answer our main question, we first need to figure out, what is the current trend in processor design (this in turn will drive the next trend in programming)

The processing power of a processor depends on two major factors
(a) transistor count - which is a fair indication of processor’s actual power
(b) clocking speed- which tells how many times per second, processor can utilise its raw power. Doubling the clock speed will mean that you can utilize the actual power twice in a second.

VLSI design has reached such a stage where increasing the processor speed further is not possible (as per the current technology). Hence the processor designers are currently focussing solely on increasing the transistor count to increase the processor power. The modern processors contain multiple CPUs - which is the easiest way of multipying the transistor count. Intel’s Dual Core Processor is one of such examples, where a single CPU core is replicated twice on the chip. In next few years we might see multiple of such cores on a single processor chip.

Using a multiple core processor for multi-threaded applications is quite easy. The easiest way will be to run each thread on a given CPU core. But it becomes really difficult for a single threaded application, to utilize the multi-core architectures. Though a lot of domain specific work has been done (in Multimedia and Communications) to disect the commonly used tasks in to parallel independent tasks (which can be run on parallel cores), there is very less scope of parallel algorithm design in traditional PC based applications (e.g. a document editor, mail-box, browser).

Since the applications really can not be easily dissected in parallel, the main focus will be on designing intelligent compilers to utilize the multiple core CPUs efficiently. Compilers will understand the inter-dependency of given instructions and allocate them to different CPUs (as efficiently as possible). But this job can hardly be done with the current programming languages. Compilers will need some constructs in the programs, to understand the integrity of applications and instructions. This could work in two ways - design a completely new language, OR add some construct to the existing languages. Current focus is mainly on the later. There is lot of research being done on this “Parallel Languages” - most of these languages will evolve from C and C++. So, the programming construct in combination with intelligent compilers may drive the efficiency in coming years. Though MS is still suspicious about parallel programming (as it always is with competitors), Intel is heavily funding a number of research projects on parallel programming.

Let us wait and watch.