The Five Generations of Software

First Generation Languages (1GL)

The earliest computers were based on vacuum tube technology and hardware design was in its infancy. The only way to program these computers was to enter the machine language instructions directly into the hardware. Writing programs for these early computers had many limitations:

Programming was tremendously time consuming,
The programs were prone to errors
Debugging often took longer than writing the original program
Programmers needed a great deal of skill and specialized training and
Machine languages were different for every type of computer.

Second Generation Languages (2GL)

Some improvements were made during the 1950s with the development of assembly languages. Early software pioneers, such as Grace Hopper, realized that they could write programs in a type of programming short-hand and then have the computer translate this short-hand notation into machine code. The advantages of Assembly Languages included:

Operations are given a meaningful name
Names are assigned to storage locations
Programs are easier to read and therefore easier to debug
The Assembler program does the tedious translation of the program into machine language.

Disadvantages include:

Assemblers are machine dependent and programmers needed very specific skills
It is still a complex language and writing programs is slow and tedious to debug.

Third Generation Languages (3GL)

By the late 50s and early 60s, the computer industry was in full production. Many large and medium businesses as well as most universities and government departments were installing computers. Along with this boom came a crucial period often called the Software Crisis. While advances had been made in writing software such as assemblers, every computer system still required custom written software. There simply were not enough programmers and time to do it all. The solution: develop a faster way of writing and debugging software.

Leading thinkers such as Alick Glennie and Grace Hopper realize that they could extend the concept of the Assembler even further. The result was a series of computer programs (compilers) that translated high-level programming languages into machine code.

These high-level or 3GLs are characterized by their use of English-like commands in place of the obscure codes of Assembly languages. Each line of code in a 3GL often corresponds to many lines of machine code. These are often called procedural languages because the programmer must develop a clear logic to carry out each procedure within the program. Since 3GLs are portable or machine independent, international standards have often been developed. This has greatly simplified the training and preparation that software engineers need.

Some of the most significant 3GLs are:

FORTRAN: (FORmula TRANslation) Developed in 1957 by a team headed by John Backus, Fortran was designed for scientists and engineers. It is geared to make programming mathematical formula quick and easy.
COBOL: (COmmon Business Oriented Language) By 1959, the business community had their own programming language designed to handle business processes.
PL/1: (Programming Language /1) was an attempt in the mid-60s to develop a language that could satisfy the needs of both the business and scientific communities. It combines the ease of writing formulas of Fortran with the string handling features of Cobol.
BASIC: (Beginner's All-purpose Symbolic Instruction Code) Late in 1963, John Kemeney and Thomas Kurtz sat down and began to develop a new programming language written from the point of view of the user. It was designed to be easy to learn, more accessible to the user and accessible so that the average person might be able to write programs. By May 1st, 1964 with a lot of help from their students BASIC was born.
C: C is a general-purpose computer programming language developed between 1969 and 1973 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating system
Pascal: (named after the French mathematician, Blaise Pascal) from '68 to '72 Niklaus Wirth developed Pascal to provide his students (and others) with a relatively easy to learn language that maintained the principles of structured programming.
C++: see the accompanying notes on Object-Oriented Programming.

Fourth Generation Languages (4GL)

The examples of 3GLs given above are all procedural languages because the programmer must list each instruction and indicate the order that these steps are to be executed through the use of logical control structures (Sequence-Selection-Iteration). Fourth Generation Languages are non-procedural languages. This means that the programmer does not specify a step-by-step method for executing a given problem. Instead, the inputs and required outputs are given and it is left up to the language to determine the step-by-step details.

The major disadvantage of 4GLS is that the resulting programs may not use the computer's processing power efficiently. Consequently more powerful computers are needed to run this type of program. The most significant advantage, however, is that 4GL programs are much easier to write. They contain a minimum of syntax rules and even people not trained as programmers can write applications.

One of the more common forms of 4GLs are query languages. These are frequently used to retrieve information from databases. An example of a query is "display all clients with date-of-birth before 1931". Other types of 4GL are report generators and application generators.

Firth Generation Languages (5GL)

Not commonly listed in the generations of software are the Fifth Generation programming languages. Connected closely with Artificial Intelligence research and expert systems, there are few commercially available 5GLs.

LISP is one of the oldest programming languages still in use but it has been updated with 5GL programming methodology. The result is that most expert systems are coded in LISP. PROLOG is another 5GL that was developed in France in 1972. It has been expanded and improved over the last few decades and is used in Artificial Intelligence research.