Programming language generations
From Wikipedia, the free encyclopedia
Programming languages have been classified into several programming language generations. Historically, this classification was used to indicate increasing power of programming styles. Later writers have somewhat redefined the meanings as distinctions previously seen as important became less significant to current practice.
Contents |
[edit] Historical view of first three generations
The terms "first-generation" and "second-generation" programming language were not used prior to the coining of the term "third-generation." In fact, none of these three terms are mentioned in an early compendium of programming languages.[1] The introduction of a third generation of computer technology coincided with the creation of a new generation of programming languages.[2] The marketing for this generational shift in machines did correlate with several important changes in what were called high level programming languages, discussed below, giving technical content to the second/third-generation distinction among high level programming languages as well, and reflexively renaming assembler languages as first-generation.
[edit] First generation
As Grace Hopper said about coding in machine language: "We were not programmers in those days. The word had not yet come over from England. We were coders."[3] The task of encoding an algorithm wasn’t thought of as writing in a language any more than was the task of wiring a plug-board. But even by the early 1950’s, the assembly languages were seen as a distinct "epoch".[4] The distinguishing properties of these first generation programming languages are that:
- The code can be read and written by a programmer. To run on a computer it must be converted into a machine readable form, a process called assembly.
- The language is specific to a particular target machine or family of machines, directly reflecting their characteristics like instruction sets, registers, storage access models, etc., requiring and enabling the programmer to manage their use.
- Some assembler languages provide a macro-facility enabling the development of complex patterns of machine instructions, but these are not considered to change the basic nature of the language.
First-generation languages are sometimes used in kernels and device drivers, but more often find use in extremely intensive processing such as games, video editing, graphic manipulation/rendering.
[edit] Second generation
Second-generation programming languages, originally just called high level programming languages, were created to simplify the burden of programming by making its expression more like the normal mode of expression for thoughts used by the programmer. They were introduced in the late 1950s, with FORTRAN reflecting the needs of scientific programmers, ALGOL reflecting an attempt to produce a European/American standard view,[4][5] and COBOL providing a “natural language” for developers of commercial software.
The most important issue faced by the developers of second-level languages was convincing customers that the code produced by the compilers performed well-enough to justify abandonment of assembler programming.[6] The FORTRAN compiler was seen as a tour-de-force in the production of high-quality code, even including "… a Monte Carlo simulation of its execution … so as to minimize the transfers of items between the store and the index registers."[7]
Second-generation programming languages evolved through the decade. FORTRAN lost some of its machine-dependent features, like access to the lights and switches on the operator console. Most second-generation languages employed a static storage model in which storage for data was allocated only once, when a program is loaded, making recursion difficult, but Algol evolved to provide block-structured naming constructs and began to expand the set of features made available to programmers, like concurrency management. In this way (Algol 68) began the movement into a new generation of programming languages..
[edit] Third generation
The introduction of a third generation of computer technology coincided with the creation of a new generation of programming languages.[2] The third-generation languages emphasized:
- expression of an algorithm in a way that was independent of the characteristics of the machine on which the algorithm would run.
- the rise of strong typing – by which typed languages deprecated or severely controlled access to the underlying storage representation of data. Complete prohibition of such access has never been a feature of major-use programming languages, which generally simply provide barriers to accidental access, e.g. coding them as "native" methods.
- block structure and automated management of storage with a stack – introduced in the Algol family of languages and adopted rapidly by most other major modular languages
- broad-spectrum applicability and greatly extended functionality – which was intended to service the needs of not only the previously separated commercial and scientific domains. The extended functionality often included concurrency features, creation and reference to non-stack data,
[edit] Re-characterization of first three generations
Since the 1990s, some authors have recharacterized the development of programming languages in a way that removed the (no longer topical) distinctions between early high-level languages like Fortran or Cobol and later ones, like Ada.[8][9]
[edit] First generation
In this categorization, a first-generation programming language is a machine-level programming language.
Originally, no translator was used to compile or assemble the first-generation language. The first-generation programming instructions were entered through the front panel switches of the computer system.
The main benefit of programming in a first-generation programming language is that the code a user writes can run very fast and efficiently, since it is directly executed by the CPU. However, machine language is a lot more difficult to learn than higher generational programming languages, and it is far more difficult to edit if errors occur. In addition, if instructions need to be added into memory at some location, then all the instructions after the insertion point need to be moved down to make room in memory to accommodate the new instructions. Doing so on a front panel with switches can be very difficult. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer. Architectural considerations make portability difficult too. For example, the number of registers on one CPU architecture could differ from those of another.
[edit] Second generation
Second-generation programming language is a generational way to categorize assembly languages. The term was coined to provide a distinction from higher level third-generation programming languages (3GL) such as COBOL and earlier machine code languages. Second-generation programming languages have the following properties:
- The code can be read and written by a programmer. To run on a computer it must be converted into a machine readable form, a process called assembly.
- The language is specific to a particular processor family and environment.
Second-generation languages are sometimes used in kernels and device drivers (though C is generally employed for this in modern kernels), but more often find use in extremely intensive processing such as games, video editing, graphic manipulation/rendering.
One method for creating such code is by allowing a compiler to generate a machine-optimized assembly language version of a particular function. This code is then hand-tuned, gaining both the brute-force insight of the machine optimizing algorithm and the intuitive abilities of the human optimizer.
[edit] Third generation
A third-generation programming language (3GL) is a refinement of a second-generation programming language. Whereas a second generation language is more aimed to fix logical structure to the language, a third generation language aims to refine the usability of the language in such a way to make it more user friendly. This could mean restructuring categories of possible functions to make it more efficient, condensing the overall bulk of code via classes (eg. Visual Basic). A third generation language improves over a second generation language by having more refinement on the usability of the language itself from the perspective of the user.
First introduced in the late 1950s, FORTRAN, ALGOL and COBOL are early examples of this sort of language.
Most "modern" languages (BASIC, C, C++, C#, Pascal, and Java) are also third-generation languages.
Most 3GLs support structured programming.
[edit] Later generations
"Generational" classification of these languages was abandoned after the third-generation languages, with the natural successors to the third-generation languages being termed object-oriented. C gave rise to C++ and later to C#, Lisp to CLOS, ADA to ADA95, and even COBOL to COBOL2002, and new languages like Java have emerged in that "generation" as well.
But significantly different languages and systems were already being called fourth and fifth generation programming languages by language communities with special interests. The manner in which these generations have been put forward tends to differ in character from those of earlier generations,[10] and they represent software points-of-view leading away from the mainstream.
[edit] References
- ^ Sammet, Jean E. (1969). Programming Languages: History and Fundamentals. Englewood Cliffs, NJ, USA: Prentice-Hall.
- ^ a b Rico, DF; HH Sayani, RF Field (2008). "History of computers, electronic commerce and agile methods". Advances in Computers (Academic Press) 73: Emerging Technologies.
- ^ Hopper, Grace (1981). "Keynote address". History of programming languages. New York: ACM Monographs, Academic Press. pp. 7. ISBN 0-12-745040-8.
- ^ a b Naur, Peter (1981). "The European side of the last phase of the development of Algol 60". History of programming languages. New York: ACM. pp. 83.
- ^ Perlis, Alan J. (1981). "The American side of the development of Algol". History of programming languages. New York: ACM. pp. 77.
- ^ Backus, John (1981). "The history of FORTRAN I, II, and III". History of programming languages. New York: ACM. pp. 28. "In view of the widespread skepticism about the possibility of producing efficient programs with an automatic programming system and the fact that inefficiencies could no longer be hidden, we were convinced that the kind of system we had in mind would be widely used only if we could demonstrate that it would produce programs almost as efficient as hand coded ones and do so on virtually every job."
- ^ Backus, John (1981). "The history of FORTRAN I, II, and III". History of programming languages. New York: ACM. pp. 35.
- ^ Linda Null, Julia Lobur (2006). The essentials of computer organization and architecture (2 ed.). Jones & Bartlett Publishers. p. 435. ISBN 0763737690.
- ^ Gerard O'Regan (2008). A brief history of computing. Springer. p. 74. ISBN 1848000839.
- ^ Sammet, Jean E. (1996). "From HOPL to HOPL-II (1978-1993): 15 years of programming language development". History of programming languages--II. New York: ACM. pp. 18.
|
|||||
|
|||||
