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. As early as May 1966 computers were advertised as third generation computers. This buzzword was reused to advertise programming languages as third generation languages within the same year. It is synonymous to the buzzword high-level programming language which was coined 1964 or a bit earlier. In 1957 Bob Bemer still called programming with a high-level language “automatic programming”. Machine code languages were retroactively named first generation and assembly languages second generation languages.

Niklaus Wirth, who designed Pascal, wrote in 2008 that high-level language was “a poorly understood buzzword” and contrasted C with high-level programming languages.

Around 1973 fourth-generation language was coined. It was used for declarative languages (such as Prolog), “database languages” 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.

Also around 1973 very high level language (VHLL) was coined. It remained rarely used and is about as vague as 5GL. The only consistent thing about it is that it is supposed to be higher-level than high-level language. In 1974 English was called a VHLL. One paper from 1974 says VHLL are supposed to be nonprocedural (declarative) languages. In 1983 a paper calls the procedural languages APL, SETL and BDL VHLLs. In the 90s it was sometimes used to refer to scripting languages like Perl and Python.

"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.

In 1988 in the German computer magazine Computerwoche Jürgen Dyrda, Managing Director of Progress Software GmbH, said that the discussion of 5GL is absurd. The article further claims that a few years prior 4GL disputed too and that at the time anyone who wants to be taken seriously in the market included the term "4GL" either before or after the product name of his database software.

In 2017 Computerwoche wrote that 4GL is a “a rather vague term that was primarily used for marketing purposes in the 1980s” and that 5GL is “even more vague. But has something to do with artificial intelligence”.

In the September 1994 issue of the Scientific American Bill Curtis says in an interview with W. Wayt Gibbs, “In the 1970s structured programming was also touted as a paradigm shift. So was CASE [computer-assisted software engineering]. So were third-, fourth- and fifth-generation languages. We’ve heard great promises for technology, many of which weren’t delivered.”

Generations

First generation (1GL)

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

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 a 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. 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)

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.
  • The language is specific to a particular processor family and environment.

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.

In modern programs, second generation assembly languages are rarely used. 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.
  • Low-level memory and hardware details must be manually managed which is often bug-prone.
  • Programs are machine-dependent, so different versions must be written for every target machine architecture.

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.

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. 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.

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. 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.

Fourth generation (4GL)

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

Fourth-generation languages are most often domains-specific languages. 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.

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. Some advanced 3GLs like Python, Ruby, and Perl combine some 4GL abilities within a general-purpose 3GL environment, 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.

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 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 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.

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. 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 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. 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.

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: 1C:Enterprise programming language , Appcelerator, Appian, Bizagi, DronaHQ, 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, 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. They may use artificial intelligence techniques to solve problems in this way.[citation needed] 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.

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. Most notably, from 1982 to 1993, Japan 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.

Another view published in The Register in 2007 is that the concept of 5GL doesn't make any sense and languages advertised as such are basically the same as a 4GL with extras.

See also