Programming language generations

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.

For programming languages grouped by ancestor language, see Generational list of programming languages.

Generations

First Generation (1GL)
Main article: First-generation programming language

Examples: machine-level programming languages

A first-generation programming language (1GL) is a machine-level programming language.[1]

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)
Main article: Second-generation programming language

Examples: assembly languages

Second-generation programming language (2GL) is a generational way to categorize assembly languages.[1][2][3]

Third Generation (3GL)
Main article: Third-generation programming language

Examples: C, C++, C#, Java, BASIC, Pascal, Fortran, ALGOL, COBOL

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)
Main article: Fourth-generation programming language

Examples: SQL, Unix Shell, Oracle Reports, R

4GL languages tend to be specialized toward very specific programming domains.[4][5] 4GL languages may include support for database management, report generation, mathematical optimization, GUI development, or web development.

Fifth Generation (5GL)
Main article: Fifth-generation programming language

Examples: OPS5, Mercury

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.[6] 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,[7] as is ICAD, which was built upon Lisp. KL-ONE is an example of a related idea, a frame language.

History

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.

See also

References
  1. "Computer Hope, Generation languages"
  2. Brookshear, J. Glenn. Computer science : an overview (11th ed.). Addison-Wesley. pp. 240–241. ISBN 0-13-256903-5.
  3. Vass, Péter. "Programming Language generations and Programming Paradigms" (PDF). Archived from the original (PDF) on 2020-01-29.
  4. 35th Hawaii International Conference on System Sciences - 1002 Domain-Specific Languages for Software Engineering Archived May 16, 2011, at the Wayback Machine
  5. 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.
  6. Dong, Jielin, ed. (2007). Network dictionary. Saratoga, Calif.: Javvin Technologies, Inc. p. 195. ISBN 9781602670006.
  7. E. Balagurusamy, Fundamentals of Computers, Mcgraw Hill Education (India), 2009, ISBN 978-0070141605, p. 340
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.