Laupäev, august 08, 2026

Logi sisse
Ajalugu

TÄNA AJALOOS, 28. juuli ⟩ Hiinas toimus 20. sajandi suurim maavärin

RSS

Programming languages have been classified into several programming language generations. This series of buzzwords was popular in the 1980s and 1990s. 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.

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 domain-specific, 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. New languages have emerged in that "generation" as well.

Generations

First generation (1GL)

A first-generation programming language (1GL) is a machine-level programming language and belongs to the low-level programming languages.[1]

These are the languages that can be directly executed by a central processing unit (CPU). This makes the language suitable for execution by the machine but far more difficult for human programmer to learn and interpret. First-generation programming languages are rarely used by programmers in the twenty-first century, but they were universally used to program early computers, before assembly languages were invented and when computer time was too scarce to be spent running an assembler.

It is also known as machine language. Originally, no translator was used to compile or assemble a first-generation language. The first-generation programming instructions were entered through the front panel switches of the computer system.

The instructions in a 1GL are made of binary numbers, represented by 1s and 0s (or occasionally via octal or hexadecimal to the programmer). This makes the language suitable for the understanding of the machine but far more difficult to interpret and learn by the human programmer.

First-generation languages are very much adapted to a specific computer and CPU, and code portability is therefore significantly reduced in comparison to higher-level languages. Modern tools such as native-code compilers are used to produce machine-level code from a higher-level language.

Second generation (2GL)

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

The term was coined to provide a distinction from higher level machine independent third-generation programming languages (3GLs) (such as COBOL, C, or Java) and earlier first-generation programming languages (machine code)[2][4]

Second-generation programming languages have the following properties:

  • Lines within a program correspond directly to processor commands, essentially acting as a mnemonic device overlaying a first generation programming language.
  • 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.[4]
  • The language is specific to a particular processor family and environment.[2]

Second-generation languages are sometimes used for parts of kernels or device drivers, and are sometimes used in video games, graphics programs, and other intensive programs.[1]

In modern programs, second generation assembly languages are rarely used.[5] Programming in second generation languages may yield speed benefits, but several disadvantages have led to its decline:

  • Programming is expressed in terms of individual processor instructions, rather than higher level logic.[2][3]
  • Low-level memory and hardware details must be manually managed which is often bug-prone.[2]
  • Programs are machine-dependent, so different versions must be written for every target machine architecture.[3]

The vast majority of programs are written in a third-generation programming language or a fourth-generation programming language. Assembly's main advantage, speed, has degraded by the fact that well written C code can often be as fast or even faster than handwritten assembly.[2][6]

Second generation languages are perhaps most significant in their place in computing history. For a long time, Second generation assembly languages were the only good option for development for many machines, such as the NES or the Commodore 64.[7][8] Second generation languages represented a massive step away from the tradition of programmers conforming to the needs of a machine, and the first step towards the machine accommodating for the programmer, a phenomenon that would be repeated in all subsequent programming language generations.[2][3]

Third generation (3GL)

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

A third-generation programming language (3GL) is a high-level programming language. They are much more machine-independent (portable) and more programmer-friendly than the machine code and assembly languages, while having a less specific focus to the fourth and fifth generations.[1] 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 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.

The main advantage of high-level languages over low-level languages is that they are easier to read, write, and maintain. Ultimately, programs written in a high-level language must be translated into machine language by a compiler or directly into behaviour by an interpreter.

These programs could run on different machines (they are portable) so they were machine-independent. As new, more abstract languages have been developed, however, the concept of high- and low-level languages have become rather relative. Many of the early "high-level" languages are now considered relatively low-level in comparison to languages such as Python, Ruby, and Common Lisp, which have some features of fourth-generation programming languages and were called very high-level programming languages in the 1990s.[9][10]

Fourth generation (4GL)

Examples: ABAP, Unix shell, SQL, PL/SQL, Oracle Reports, R, Halide

Fourth-generation languages are most often domains-specific languages.[11][12] 4GLs may include support for database management, report generation, mathematical optimization, GUI development, or web development.

The definition of 4GL has changed over time but it can be typified by operating more with large collections of information at once. Languages claimed to be 4GL may include support for database management, report generation, mathematical optimization, graphical user interface (GUI) development, or web development. Some researchers state that 4GLs are a subset of domain-specific languages.[13][14]

The concept of 4GL was developed from the 1970s through the 1990s, overlapping most of the development of 3GL, with 4GLs identified as "non-procedural" or "program-generating" languages, contrasted with 3GLs being algorithmic or procedural languages. 4GLs as originally defined found uses focused on databases, reports, and websites.[15] Some advanced 3GLs like Python, Ruby, and Perl combine some 4GL abilities within a general-purpose 3GL environment,[16] and libraries with 4GL-like features have been developed as add-ons for most popular 3GLs, producing languages that are a mix of 3GL and 4GL, blurring the distinction.[17]

History

Though used earlier in papers and discussions, the term 4GL was first used formally by James Martin in his 1981 book Application Development Without Programmers[18] to refer to non-procedural, high-level specification languages. In some primitive way, early 4GLs were included in the Informatics MARK-IV (1967) product and Sperry's MAPPER (1969 internal use, 1979 release).

The motivations for the '4GL' inception and continued interest are several. The term can apply to a large set of software products. It can also apply to an approach that looks for greater semantic properties and implementation power. Just as the 3GL offered greater power to the programmer, so too did the 4GL open up the development environment to a wider population.

The early input scheme for the 4GL supported entry of data within the 72-character limit of the punched card (8 bytes used for sequencing) where a card's tag would identify the type or function. With judicious use of a few cards, the 4GL deck could offer a wide variety of processing and reporting capability whereas the equivalent functionality coded in a 3GL could subsume, perhaps, a whole box or more of cards.[19]

The 72-character format continued for a while as hardware progressed to larger memory and terminal interfaces. Even with its limitations, this approach supported highly sophisticated applications.

As interfaces improved and allowed longer statement lengths and grammar-driven input handling, greater power ensued. An example of this is illustrated by Nicholas Rawlings in his comments for the Computer History Museum about NCSS.[20] He reports that James Martin asked Rawlings for a NOMAD solution to a standard problem Martin called the Engineer's Problem: "give 6% raises to engineers whose job ratings had an average of 7 or better." Martin provided a "dozen pages of COBOL, and then just a page or two of Mark IV, from Informatics." Rawlings offered a single statement, performing a set-at-a-time operation.

The development of the 4GL was influenced by several factors, with the hardware and operating system constraints having a large weight. When the 4GL was first introduced, a disparate mix of hardware and operating systems mandated custom application development support that was specific to the system in order to ensure sales. One example is the MAPPER system developed by Sperry. Though it has roots back to the beginning, the system has proven successful in many applications and has been ported to modern platforms. The latest variant is embedded in the BIS[21] offering of Unisys. MARK-IV is now known as VISION:BUILDER and is offered by Computer Associates.

The Santa Fe railroad used MAPPER to develop a system in a project that was an early example of 4GL, rapid prototyping, and programming by users.[22] The idea was that it was easier to teach railroad experts to use MAPPER than to teach programmers the "intricacies of railroad operations".

One of the early (and portable) languages that had 4GL properties was RAMIS developed by Gerald C. Cohen at Mathematica, a mathematical software company. Cohen left Mathematica and founded Information Builders to create a similar reporting-oriented 4GL, called FOCUS.

Later 4GL types are tied to a database system and are far different from the earlier types in their use of techniques and resources that have resulted from the general improvement of computing with time.

An interesting twist to the 4GL scene is realization that graphical interfaces and the related reasoning done by the user form a 'language' that is poorly understood.

Types

A number of different types of 4GLs exist:

  • Table-driven (codeless) programming, usually running with a runtime framework and libraries. Instead of using code, the developer defines their logic by selecting an operation in a pre-defined list of memory or data table manipulation commands. In other words, instead of coding, the developer uses table-driven algorithm programming (see also control tables that can be used for this purpose). These types of tools can be used for business application development usually consisting in a package allowing for both business data manipulation and reporting, therefore they come with GUI screens and report editors. They usually offer integration with one or more lower level dynamic-link library (DLL), generated from a typical 3GL for when the need arises for more hardware/OS specific operations.
  • Report generator programming languages take a description of the data format and the report to generate and from that they either generate the required report directly or they generate a program to generate the report (see also RPG).
  • Similarly, screen generators (also called forms generators) manage online interactions with the application system users or generate programs to do so.
  • More ambitious 4GLs (sometimes termed fourth generation environments) attempt to automatically generate whole systems from the outputs of computer-aided software engineering (CASE) tools, specifications of screens and reports, and possibly also the specification of some additional processing logic.
  • Data management 4GLs such as SAS, SPSS, and Stata provide sophisticated coding commands for data manipulation, file reshaping, case selection, and data documentation in the preparation of data for statistical analysis and reporting.
  • So-called "XTalk" languages, developed initially with Apple's Hypercard in 1987. Hypercard was the progenitor of more modern and powerful programs such as SuperCard, Toolbook and LiveCode.

Some 4GLs have integrated tools that allow for the easy specification of all the required information:

Examples

General use / versatile: 4th Dimension, Accell/SQL (4GL) from Unify Corporation., Broadcom 2e Formerly Synon 4GL RPG/COBOL Generator, CA-Telon 4GL Cobol/PLI generator , Clarion, Clipper, Cognos PowerHouse 4GL, DataFlex (Microsoft Windows, web, mobile), DATATRIEVE, dBase, FileMaker, FOCUS, Forté TOOL (transactional object-oriented language), GeneXus, Harbour, HyperCard (development and support were ended), IBM Rational EGL (Enterprise Generation Language), Infor, LabVIEW, LANSA, LINC, LiveCode, M-Power, NATURAL, Omnis Studio SDK, Oracle Application Development Framework, OutSystems (Productivity/PaaS), Jmix/CUBA Platform (Productivity/Framework), PowerBuilder, R:Base, SheerPower4GL (Microsoft Windows only), SQLWindows/Team Developer, Uniface, Unix Shell, Visual FoxPro (development and support were ended), Xojo Database query languages: FOCUS, 4D QL, Informix-4GL, NATURAL, OpenEdge Advanced Business Language (OpenEdge ABL), OpenROAD (Ingres 4GL), RAMIS, SQL

Report generators: Speedware EasyReporter, LINC, Oracle Reports, OpenEdge Advanced Business Language (former Progress 4GL) Query/Results, RPG-II Extract data from files or database to create reports in a wide range of formats is done by the report generator tools.

Data manipulation, analysis, and reporting languages: Ab Initio, ABAP, Clarion Programming Language, CorVision, Culprit, ADS/Online (plus transaction processing), Easytrieve, FOCUS, GraphTalk, IDL, IGOR Pro, Informix-4GL, JSL, LANSA, LabVIEW, LiveCode, M-Power, MANTIS, MAPPER (Unisys/Sperry) now part of BIS, MARK-IV (Sterling/Informatics) now VISION:BUILDER of CA, Simulink a component of MATLAB, NATURAL, NOMAD, Octave, PL/SQL, OpenEdge Advanced Business Language (former Progress 4GL), R, RAMIS, S, Scilab, SAS, SPSS, SQL PL, SSIS, SQR, Stata, Synon, Wolfram Language, XQuery, XSLT Software creators: 4th Dimension (Software), LiveCode, MATLAB's GUIDE, Omnis Studio, OpenROAD, OpenEdge Advanced Business Language (former Progress 4GL) AppBuilder, SuperTalk, Visual DataFlex, Xojo, XUL Can be used with XQuery Mathematical optimization: AIMMS, AMPL, GAMS, Mathematica, MathProg, MATLAB

Database-driven GUI application development: C/AL, Genexus, SB+/SystemBuilder, Unify VISION

Low-code / No-code development platforms:[23][24] 1C:Enterprise programming language , Appcelerator, Appian, Bizagi, DronaHQ[25], LANSA, M-Power, Microsoft Power Automate, Node-RED, OutSystems, Pegasystems, PNMsoft, OpenEdge Advanced Business Language (former Progress 4GL) Progress, ServiceNow, ViziApps Screen painters and generators: Oracle Forms, OpenEdge Advanced Business Language (former Progress 4GL) ProVision, SB+/SystemBuilder

Web development languages: ActiveVFP, CFML, LANSA, OutSystems, Wavemaker

Music Programming language: MaxMSP

Fifth generation (5GL)

Examples: Prolog, OPS5, Mercury, CVXGen,[26][27] Geometry Expert

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.[28] They may use artificial intelligence techniques to solve problems in this way. 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,[29] as is ICAD, which was built upon Lisp. KL-ONE is an example of a related idea, a frame language.

In the 1980s, fifth-generation languages were considered to be the way of the future, and some predicted that they would replace procedural programming with constraint-based programming for all tasks that could be framed as a series of logical constraints.[30] Most notably, from 1982 to 1993, Japan[31][32] put much research and money into their fifth-generation computer systems project, hoping to design a massive computer network of machines using these tools.

However, as larger programs were built, the flaws of the approach became more apparent. It turns out that, given a set of constraints defining a particular problem, deriving an efficient algorithm to solve it is a very difficult problem in itself. This crucial step cannot yet be automated[needs update?] and still requires the insight of a human programmer.

Common misconception

Vendors have been known on occasion to advertise their languages as 5GL. Most of the time they actually sell 4GLs with a higher level of automation and knowledge base. Because the hype of the 1980s faded away and the projects were eventually all dropped, 5GL awareness has also dropped; this has opened doors to the vendors to reuse the term in marketing their new tools, without causing much controversy among the current generations of programmers.[33]

See also

References

  1. 1 2 3 4 "Computer Hope, Generation languages"
  2. 1 2 3 4 5 6 7 Brookshear, J. Glenn (2012). Computer science : an overview (11th ed.). Addison-Wesley. pp. 240–241. ISBN 978-0-13-256903-3.
  3. 1 2 3 4 Vass, Péter. "Programming Language generations and Programming Paradigms" (PDF). Archived from the original (PDF) on 2020-01-29. Retrieved 2019-06-11.
  4. 1 2 "What Are Programming Language Generations?". wiseGEEK. Retrieved 2019-06-11.
  5. ↑ "Top Computer Languages 2019 - StatisticsTimes.com". statisticstimes.com. Retrieved 2019-06-11.
  6. ↑ Walls, Colin. "Why C is faster than assembly". Mentor, a Sieman's Business. Mentor Inc. Archived from the original on 2020-01-29. Retrieved 11 June 2019.
  7. ↑ Commodore corporation. "C64 programmer's reference" (PDF). Commodore corporation. Retrieved 11 June 2019.
  8. ↑ "NES assembly". Wikibooks: NES Assembly. Retrieved 11 June 2019.
  9. ↑ Tom Christiansen et al (eds.): USENIX 1994 Very High Level Languages Symposium Proceedings. October 26-28, 1994, Santa Fe, New Mexico
  10. ↑ Greg, Wilson (1999-12-01). "Are VHLLs Really High-Level?". oreilly.com. O'Reilly. Archived from the original on 2018-04-24.
  11. ↑ 35th Hawaii International Conference on System Sciences - 1002 Domain-Specific Languages for Software Engineering. Archived May 16, 2011, at the Wayback Machine.
  12. ↑ 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.
  13. ↑ 35th Hawaii International Conference on System Sciences - 1002 Domain-Specific Languages for Software Engineering Archived May 16, 2011, at the Wayback Machine
  14. ↑ Arie van Deursen; Paul Klint; Joost Visser (1998). "Domain-Specific witness Languages:An Annotated Bibliography". Archived from the original on 2009-02-02. Retrieved 2009-03-15.
  15. ↑ MacDonell, Stephen (November 1993). "Software development, CASE tools and 4GLs—A survey of New Zealand usage. Part 1". 750 New Zealand organisations. hdl:10523/928.
  16. ↑ "Roger Clarke's Software Generations".
  17. ↑ "Definition of fourth-generation language". PCMAG. Retrieved 7 May 2020.
  18. ↑ Martin, James. Application Development Without Programmers. Prentice-Hall, 1981. ISBN 0-13-038943-9.
  19. ↑ "IBM Punch Cards". www.columbia.edu. Archived from the original on 2019-02-16. Retrieved 2019-02-03.
  20. ↑ "RAMIS and NOMAD : National Computer Software Systems, Inc. (NCSS) conference call (transcript)". Computer History Museum. 2005-05-20. Retrieved 2025-07-28.
  21. ↑ "Data Mining Software, Data Analysis, and More: Unisys Business Information Server Features". Unisys. 2006-08-21. Archived from the original on 2006-08-21. Retrieved 2019-02-03.
  22. ↑ Louis Schlueter (1988). User-Designed Computing: The Next Generation. [book on report generator and MAPPER systems]
  23. ↑ Marvin, Rob (August 10, 2018). "The Best Low-Code Development Platforms for 2019". PCMAG.
  24. ↑ Sayer, Martin Heller and Peter (6 April 2018). "25 simple tools for building mobile apps fast". InfoWorld. Archived from the original on 18 November 2017. Retrieved 17 November 2017.
  25. ↑ "DronaHQ. Build apps without coding". www.dronahq.com. Archived from the original on 2019-08-09. Retrieved 2019-09-11.
  26. ↑ NAE, The Bridge, Autonomous Precision Landing of Space Rockets, December 19, 2016, Author: Lars Blackmore.
  27. ↑ CVXGEN: Code Generation for Convex Optimization, cvxgen.com, December 4, 2013.
  28. ↑ Dong, Jielin, ed. (2007). Network dictionary. Saratoga, Calif.: Javvin Technologies, Inc. p. 195. ISBN 9781602670006.
  29. ↑ E. Balagurusamy, Fundamentals of Computers, Mcgraw Hill Education (India), 2009, ISBN 978-0070141605, p. 340.
  30. ↑ Kahanwal, Brijender (4 October 2013). "A taxonomy for programming languages with multisequential processes". International Journal of Programming Languages and Applications. 3 (4). arXiv:1311.3293. doi:10.5121/ijpla.2013.3401.
  31. ↑ Richard Grigonis. "FIFTH-GENERATION COMPUTERS". Retrieved 2008-03-05.
  32. ↑ ALP. "Association for Logic Programming (ALP)". Retrieved 2008-03-05.
  33. ↑ Howard, Philip (17 January 2007). "What makes a 5GL?". The Register. Retrieved 28 November 2019.
allikas: https://en.wikipedia.org/wiki/Programming_language_generations

Related Posts

TÄNA AJALOOS, 8. august ⟩ Richard Nixonist sai ainus ameti maha pannud USA president

august 8, 2026

Uuring: Malta napp toidubaas sundis kiviaja kütte pikkadele mereretkedele

august 7, 2026

Leave a Reply

Veel nalja

Copyleft All Rights Reserved 2026 Theme: intimate by Template Sell.