Programming Languages: An Overview

General: Main page  Overview  Concept History  Alphabetical List
Timelines: Timeline #1  Timeline #2  Timeline #3
Languages: C/C++  Java  Visual Studio

What problem gave birth to programming languages?

Before high level programming languages existed, computers were programmed one instruction at a time using binary or hex. This was a tedious job and there were a lot of errors. Programs were difficult to read, and modification was extremely difficult because all programs had to be written using absolute addressing. Obviously, this job did not attract many people, so there was a shortage of programmers. Expensive computers sat idle for long periods of time while software was being developed. Software often cost two to four times as much as the computer. This led to the development of assemblers and assembly languages. Programming became somewhat easier, but many users still wanted floating point numbers and array indexing. Since these capabilities were not supported in hardware, high level languages had to be developed to support them.
Sources: "Concepts of Programming Languages" by Robert W. Sebesta, The Benjamin/Cummings Publishing Company, Inc, 1993^

Video, "The Machine that Changed the World", PBS

What Makes a Language Hot?

It seems that there are many factors in what languages are hot. We can boil them all down to one statement. A language is hot because many programmers are interested in programming in it. From this definition, we can also look at the factors that make a language desirable to program in. Also, the factors that make a language hot may not be the same that keep it hot. For example, both Fortran and COBOL became hot languages for ease of use reasons. They were simply easier to use that their alternatives. However, they stayed hot languages because of experienced programmers and legacy code.

Ease of use

This seems to be very important in the choice of a new language. Is this language going to be faster and easier to use then other languages. This should be viewed in an historical perspective. Is COBOL easy to use? Was it in 1960? New languages and programming paridigms change what we consider to be easy to use.

Language Features

A language may also be chosen because it has a particular feature. You would write in Java if you wanted to write an application that ran over the Internet. You would not use COBOL if you wanted to write scientific programs.


In some applications performance is a big issue. This alone will keep Fortran and C alive for a long time to come. Other applications don't need a high performance language to get good responses on some hardware. Why do we need to write interactive software in a very fast language?

Corporate Support

Is there a large corporation or organization that is pushing the language? Would C have become so popular if Unix had not been written in it? Also, the reappearance of Basic may be solely due to Microsoft's support of it.

Experienced Programmers

This is especially important on long projects. Are future programmers going to be able to understand the code and continue development? Also, you are more likely to program an application in a language you know well instead of a language you will need to learn.

Legacy Code

The amount of legacy code dictates the need for programmers to understand a language. This in itself can make a language hot. The prime example is COBOL. Long after this language should have faded away, it was still in heavy use. The only reason was the large amount of code written in COBOL that was still necessary to support.

Has the evolution of computer hardware influenced programming languages throughout history? Or vice versa?

The design of a computer system is a tradeoff between computer hardware cost-performance on the one hand and accessible programming functionality on the other. This trade off is reflected in the mutual influences between computer hardware design and programming languages and techniques.

Generally speaking, the trends of the hardware evolution never have direct effects on the evolution of programming language. The design of hardware and the design of programming language have never been combined or cooperative procedures. It is a common observation that with the improvement of computer hardware cost-performance ratio, programming languages tend to be more complex and less efficient.

However, it is not the trends in hardware evolution that affect the complexity and efficiency of programming languages. Programming languages are in their nature being developed to be more complex in accordance with the growth of the complexity of the problem we tend to cope with. Also, programming language designers have to sacrifice the efficiency of programming languages for a better program readability, modularity, and reusability.

What we can say is that with the decreasing cost and increasing speed of hareware we simply can afford the programming language to be more complex and tolerate the programming language to be less efficient.

Also, it is not that code efficiency is not as important an issue any more. Efficiency should always be the primary concern of programming language designers. First, the size and complexity of the problems we would like to deal with grow faster than the developing of hardware technologies, so we seem never have enough computing power to "waste". Second, at any time, efficient use of computing facility could yield a better productivity.


A primary concern of the hardware designer is with the functionality provided to the programming user and programming language compiler. The functionality is affected directly by the selection of an instruction set for the computer. A determinant factor of the instruction set efficiency is its usefulness to the compiler code generator and hardware implementation consideration. Although the actual performance differences in instruction set efficiency are slight, these differences still stir passions among hardware designers. Within the past decade, there has been a continuing debate over the cost-performance benefits of the RISC instruction sets over earlier instruction sets labeled CISC. Also, the issues are not ones simply of selecting new instructions and the ramifications thereof, but rather more subtle issues such as compatibility with older instruction sets no longer useful in the context of new applications, but whose functionality must be available to run old programs. However, RISC does not directly affect programming language, but it does make the life of compiler designer easier.


During the early days of the computer, hardware was very expensive and the system resources available to the programmers were fairly limited, especially in the term of main memory. In some early versions of C, programmers had to use such key words as NEAR and FAR to distinguish pointers to within-segment memory address from pointers to beyond-segment memory address. This was a huge burden to programmers. The demand of transparent access to large programmable memory spaces inspired the design of virtual memory management, which was a significant accomplishment of both hardware and software designers. This ability of the hardware to reference very large address spaces contained on disk in a manner that is transparent to the user enabled combinations of very large software programs to be available on a single processor platform, and provided the programmers with ample arena of creativity.


With the fast declining cost and increasing performance of the computer hardware, cost of software development became a significant part of the computer system cost. Thus, programming productivity becomes a more and more important issue, which leads to the idea of sharing programs across different hardware platforms to save time and cost on program development. The initial impetus went to designs of compatible families of machines such as IBM¡¦s System 360, which offered many cost-performance design points all sharing a common instruction set. Since the software was compatible across all implementations, this enormously improved the accessibility of users to shared programs. However, the nature of the evolution of the computer tends to favor the co-existing and competition among versatile hardware platforms and it is unpractical that all of these platforms can be unified. With the development of internet and web computing, the sharing of programs across heterogeneous platforms, the establishing of an unified programming and computing environment across the fundamentally heterogeneous world wide web become critical issues, which lead to the booming of brand new programming languages such as Java. Java may be not distinct in its way of programming, but it is definitely distinguished in the execution of its programs on different hardware platforms available at present or may not even exist right now. Another possible trend is the popularity of script language on the Internet. Script languages, such as JavaScript and Perl, have the merits of easy programming, modifying, and maintaining. With the availability of more and more powerful computing facilities, script languages executed by interpreter may be practical again.


Generally speaking, with the impressive improvement of computer hardware on cost-performance issue, programming languages tend to be more complex and less efficient. Since the cost-performance ratio of computer hardware tends to maintain its trend of fast improving, the programming language designer might as well take advantage of this to design the programming language with a little bit less efficiency but good readability, reusability, and program structure. However, it should still be kept in mind by the language designers that simplicity and efficiency are always the primary concerns because the magnitude of the size and complexity of the tasks we tend to deal with is growing faster than the cost-effectiveness of the computer.


Another architectural improvement that call for the innovation of programming language is parallel and distributed computing, which is becoming more practical because of the decreasing of the hardware cost and the fast developing of the computer network. New programming languages that can support this kind of computing activities are in great demand. There are currently two approaches to this special issue. One is to adapt currently available popular programming languages, for example C and FORTRAN, and equip them with special library. The results are parallel and distributed programming languages like CC++, pC++, and HPF (High Performance Fortran). Another approach is to design conceptually new language that exploit the fundamental principle of parallel and distributed computing. The results are programming languages like Linda.


[1] Michael J. Flynn. Introduction to "Influence of Programming Techniques on the Design of Computers". Proceedings of the IEEE, pp. 467 - 469, VOL. 85, NO. 3, March 1997.

[2] C. A. R. Hoare. Hints on programming language design. In A. I. Wasserman, editor, Tutorial Programming Language Design, pp. 43 - 52, IEEE, Oct. 1980.

Note: This page is modified from History of Programming Languages.