Programming language generations
This article needs additional citations for verification. (November 2015) (Learn how and when to remove this template message)
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.
First Generation (1GL)
A first generation (programming) language (1GL) is a grouping of programming languages that are machine level languages used to program first-generation computers. 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 instructions in 1GL are made of binary numbers, represented by 1s and 0s. This makes the language suitable for the understanding of the machine but far more difficult to interpret and learn by the human programmer.
Second Generation (2GL)
Examples: assembly languages
Third Generation (3GL)
3GLs are much more machine-independent and more programmer-friendly. This includes features like improved support for aggregate data types, and expressing concepts in a way that favors the programmer, not the computer. A third generation language improves over a second-generation language by having the computer take care of non-essential details. 3GLs are more abstract than previous generations of languages, and thus can be considered higher-level languages than their first- and second-generation counterparts. First introduced in the late 1950s, Fortran, ALGOL, and COBOL are examples of early 3GLs.
Most popular general-purpose languages today, such as C, C++, C#, Java, BASIC and Pascal, are also third-generation languages, although each of these languages can be further subdivided into other categories based on other contemporary traits. Most 3GLs support structured programming. Many support object-oriented programming. Traits like these are more often used to describe a language rather than just being a 3GL.
Fourth Generation (4GL)
4GL languages tend to be specialized toward very specific programming domains. 4GL languages may include support for database management, report generation, mathematical optimization, GUI development, or web development.
Fifth Generation (5GL)
A fifth-generation programming language (5GL) is any programming language based on problem-solving using constraints given to the program, rather than using an algorithm written by a programmer. Most constraint-based and logic programming languages and some other declarative languages are fifth-generation languages.
While fourth-generation programming languages are designed to build specific programs, fifth-generation languages are designed to make the computer solve a given problem without the programmer. This way, the user only needs to worry about what problems need to be solved and what conditions need to be met, without worrying about how to implement a routine or algorithm to solve them. Fifth-generation languages are used mainly in artificial intelligence research. OPS5 and Mercury are examples of fifth-generation languages, as is ICAD, which was built upon Lisp. KL-ONE is an example of a related idea, a frame language.
The terms "first generation" and "second generation" programming language were not used prior to the coining of the term "third-generation"; none of these three terms are mentioned in early compendiums of programming languages. The introduction of a third generation of computer technology coincided with the creation of a new generation of programming languages. The marketing for this generational shift in machines correlated 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 while retroactively renaming machine code languages as first generation, and assembly languages as second generation.
Initially, all programming languages at a higher level than assembly were termed "third-generation", but later on, the term "fourth-generation" was introduced to try to differentiate the (then) new declarative languages (such as Prolog and domain-specific languages) which claimed to operate at an even higher level, and in a domain even closer to the user (e.g. at a natural language level) than the original, imperative high level languages such as Pascal, C, ALGOL, Fortran, BASIC, etc.
"Generational" classification of high level languages (third generation and later) was never fully precise and was later perhaps abandoned, with more precise classifications gaining common usage, such as object-oriented, declarative and functional. C gave rise to C++ and later to Java and C#, Lisp to CLOS, Ada to Ada 2012, and even COBOL to COBOL 2002, and new languages have emerged in that "generation" as well.
- "Computer Hope, Generation languages"
- Brookshear, J. Glenn. Computer science : an overview (11th ed.). Addison-Wesley. pp. 240–241. ISBN 0-13-256903-5.
- Vass, Péter. "Programming Language generations and Programming Paradigms" (PDF). Archived from the original (PDF) on 2020-01-29.
- 35th Hawaii International Conference on System Sciences - 1002 Domain-Specific Languages for Software Engineering Archived May 16, 2011, at the Wayback Machine
- Arie van Deursen .; Paul Klint; Joost Visser (1998). "Domain-Specific Languages:An Annotated Bibliography". Archived from the original on 2009-02-02. Retrieved 2009-03-15.
- Dong, Jielin, ed. (2007). Network dictionary. Saratoga, Calif.: Javvin Technologies, Inc. p. 195. ISBN 9781602670006.
- E. Balagurusamy, Fundamentals of Computers, Mcgraw Hill Education (India), 2009, ISBN 978-0070141605, p. 340