Programming languages have evolved from machine languages that directly manipulated hardware to higher-level languages that are further abstracted from hardware. First-generation languages used binary, while assembly languages (2GL) introduced symbolic codes. Third-generation languages like C and Fortran are machine-independent and compiled. Fourth-generation languages enhance productivity for tasks like querying, and fifth-generation languages use properties rather than algorithms for artificial intelligence applications like IBM Watson. Understanding which generation a language belongs to provides perspective on the level of control and work required.

1. COMPUTER PROGRAMMING: FROM MACHINE LANGUAGE TO ARTIFICIAL
INTELLIGENCE
Takeaway: As computing power has increased, programming languages have evolved to take
advantage of enhanced computing resources. Programming languages were used even before
computers were invented. For example, a player piano scroll, that long roll of encoded paper tape, is
considered an early form of programming because it contained the instructions needed to make a
piano play a tune. The first computers were programmed by flipping switches and changing the
configuration of the hardware. As a result, early programmers had to be intimately familiar with
computer hardware. But we’ve come a long way, and high-level programming languages require
little or no knowledge of the underlying hardware.
THE FIRST GENERATION - PROGRAMMING AT THE MACHINE LEVEL
First-generation programming languages (1GL) are often known as machine languages or machine
code. They operate at the lowest level of abstraction (closest to the hardware) of all languages.
First-generation languages deal directly with the binary zeros and ones that are used to store and
process information in a computer. Programs in higher-level languages must be compiled or
assembled into machine code in order to run. First-generation languages were used to program first-
generation computers such as UNIVAC I and the IBM 701.
THE SECOND GENERATION - SOME ASSEMBLY REQUIRED
Second-generation languages (2GL), often known as assembly languages, were developed largely
because of the difficulty in programming with first-generation languages. Although still low-level
languages, assembly languages introduced the use of symbolic codes (called mnemonics) to
represent instructions to the computer. A program in assembly language is translated into machine
code by means of a utility known as an assembler.
Since they operate at the lowest level of abstraction, second-generation languages offer the benefits
of speed and minimum code size. They also enable a programmer to directly manipulate hardware
components such as memory locations and registers. At one time, assembly languages were used to
program operating systems and applications that required smaller, faster-running code, such as
video games. Examples of games written in assembly language include console games for the Mega
Drive/Genesis platform and the Super Nintendo Entertainment System platform.
Although largely supplanted by higher-level languages, assembly languages are still used in
situations where hardware interaction is required or performance must be optimized. Some
compilers for higher-level languages compile source code to an assembly language before invoking
an assembler to compile to machine code.
THE THIRD GENERATION - GENTLEMAN’S C AND OTHERS
The third generation of programming languages (3GL) includes high-level languages such as C, C+
+, Fortran, COBOL, BASIC, C# and Java. Third-generation programming languages represent a
major improvement in usability over assembly languages.
Unlike assembly languages, third-generation languages are not machine-specific. When
programming with a third-generation language, a programmer writes the source code for the
program and then uses a compiler to translate it into object code (or machine code), which can be
understood by the targeted computer.
The development of programming paradigms such as structured programming and object-oriented
programming (OOP) coincided with the development of third-generation languages.

2. THE FOURTH GENERATION - PROGRAMMER ENHANCEMENT
Fourth-generation programming languages (4GL) were created to enhance programmer
productivity in specific domains such as database querying and report generation.
The syntax of a fourth-generation language is generally closer to human language than the syntax
from previous generations of programming languages. A single statement in a fourth-generation
language can automatically generate the equivalent of a series of instructions in a third-generation
language, reducing the time it takes to develop an application.
Examples of fourth-generation languages include Structured Query Language (SQL), Informix-4GL
and ColdFusion.
THE FIFTH GENERATION - WATSON, I PRESUME
Fifth-generation languages (5GL) are often used in the realm of artificial intelligence.
The traditional unit of computation is the algorithm, which is basically a step-by-step procedure for
calculating a solution. Fifth-generation languages attempt to go beyond the algorithm by defining
the conditions (or properties) for a solution and allowing the computer to determine the possible
solutions that meet the specified conditions.
An example of a fifth-generation language is Prolog, which was one of the languages used to
program IBM’s Watson in preparation for its participation on the television quiz show "Jeopardy!".
WHY SHOULD I CARE?
There you have it, the generations of programming languages really aren't that hard to understand.
A good mental model is the higher up you get, the further abstracted you are from the hardware.
This means less control, but also less work to accomplish something through programming.
Why does this matter? While theoretical, it's key to understand where your development fits in.
Many developers spend the majority of their day in an integrated development environment for a a
3GL language, so understanding that a language is 2GL or 4GL gives you some perspective as to
the level of detail required to produce usable code. In general, working with a 2GL language is
going to be more complex than a 3GL language. On the other hand, you can accomplish much less
with a 4GL language like SQL than with a 3GL like C.