First-generation programming language

Download 29.58 Kb.
Size29.58 Kb.

First-generation programming language

From Wikipedia, the free encyclopedia

Jump to: navigation, search

A first-generation programming language is a machine-level programming language.

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 main benefit of programming in a first-generation programming language is that the code a user writes can run very fast and efficiently, since it is directly executed by the CPU. However, machine language is a lot more difficult to learn than higher generational programming languages, and it is far more difficult to edit if errors occur. In addition, if instructions need to be added into memory at some location, then all the instructions after the insertion point need to be moved down to make room in memory to accommodate the new instructions. Doing so on a front panel with switches can be very difficult. Furthermore, portability is significantly reduced - in order to transfer code to a different computer it needs to be completely rewritten since the machine language for one computer could be significantly different from another computer. Architectural considerations make portability difficult too. For example, the number of registers on one CPU architecture could differ from those of another.

Computer Programming Generations


First Generation

Machine language, hard-wired instructions, numeric instructions and addresses, machine-dependent programming.



Second Generation

Symbolic instructions and addresses, translation of program with an assembler, machine-dependent programming. Typical languages: IBM BAL, VAX Macro.
calc: decL R5

pushL R5

calls #1, recfib

movL R0, R6

decL R5

pushL R5

calls #1, recfib

addL R6, R0



Third Generation (3GL):

Problem-oriented languages, translation with compilers or interpreters, structured programming, database management systems. Typical languages: COBOL, FORTRAN, Pascal, Ada, C, BASIC, PL/I.

Fourth Generation (4GL):

non-procedural languages, integrated data dictionaries, dynamic relational databases; makes possible rapid system development and prototyping. Typical: FOCUS, Powerhouse.
access admissions

set report device printer

set report device disc

set report name AD32

select if term = "961" and (app-status="AC" or app-status="PP")

sort on ad-source on name

report id name ad-source class hs-code entrance-code app-status

footing at ad-source skip 2 "Total for: " ad-source "=" count skip 3

final footing "Total enrollment " count

set report nolimit


The Next Generations?

The evolution of programming languages and software development tools has not ended with the 4th Generation. It has been suggested that Object-Oriented programming represents a new generation of tools. Object-oriented development is based on the use of "objects" that represent both the data structures and the processes that can act on the data. A major strength of such objects is that once they are defined they can be used over and over again, thus reducing the effort needed to develop systems.

Later generations of program development tools may look less and less like "languages" in the traditional sense of instructions written in text that must conform to a specific grammar or syntax.

programming language generations

- In the computer industry, these abbreviations are widely used to represent major steps or "generations" in the evolution of programming languages.

1GL or first-generation language was (and still is) machine language or the level of instructions and data that the processor is actually given to work on (which in conventional computers is a string of 0s and 1s).

2GL or second-generation language is assembler (sometimes called "assembly") language. A typical 2GL instruction looks like this:

ADD 12,8

An assembler converts the assembler language statements into machine language.

3GL or third-generation language is a "high-level" programming language, such as PL/I, C, or Java. Java language statements look like this:

public boolean handleEvent (Event evt) {

switch ( {

case Event.ACTION_EVENT: {

if ("Try me" .equald(evt.arg)) {

A compiler converts the statements of a specific high-level programming language into machine language. (In the case of Java, the output is called bytecode, which is converted into appropriate machine language by a Java virtual machine that runs as part of an operating system platform.) A 3GL language requires a considerable amount of programming knowledge.

4GL or fourth-generation language is designed to be closer to natural language than a 3GL language. Languages for accessing databases are often described as 4GLs. A 4GL language statement might look like this:


5GL or fifth-generation language is programming that uses a visual or graphical development interface to create source language that is usually compiled with a 3GL or 4GL language compiler. Microsoft, Borland, IBM, and other companies make 5GL visual programming products for developing applications in Java, for example. Visual programming allows you to easily envision object-oriented programming class hierarchies and drag icons to assemble program components.

A Journey Through Programming Language Generations

Article 2 byMohamad Johan Bin Mohd. Nasir

Programming languages have evolved tremendously since early 1950's and this evolution has resulted in over hundreds of different languages being invented and used in the industry. This revolution is needed as we can now instruct computers more easily and faster than ever before due to technological advancement in hardware with fast processors like the 200MHz Pentium Pro developed by Intel®. The increase in quantities and speed powerful computers are being produced now, more capable of handling complex codes from different languages from this generation, like Appware and PROLOG, will prompt language designers to design more efficient codes for various applications. This article will be going down memory lane to look at past five generations of languages and looking at how they revolutionise the computer industry.

We start out with the first and second generation languages during the period of 1950-60, which to many experienced programmers will say are machine and assembly languages. Programming language history really began with the work of Charles Babbage in the early nineteenth century who developed automated calculation for mathematical functions. Further developments in early 1950 brought us machine language without interpreters and compilers to translate languages. Micro-code is an example of the first generation language residing in the CPU written for doing multiplication or division. Computers then were programmed in binary notation that was very prone to errors. A simple algorithm resulted in lengthy code. This was then improved to mnemonic codes to represent operations.

Symbolic assembly codes came next in the mid 1950's, the second generation of programming language like AUTOCODER, SAP and SPS. Symbolic addresses allowed programmers to represent memory locations, variables and instructions with names. Programmers now had the flexibility not to change the addresses for new locations of variables whenever they are modified. This kind of programming is still considered fast and to program in machine language required high knowledge of the CPU and machine's instruction set. This also meant high hardware dependency and lack of portability. Assembly or machine code could not run on different machines. Example, code written for the Intel® Processor family would look very different for code written for the Motorola 68X00 series. To convert would mean changing a whole length of code.

Throughout the early 1960's till 1980 saw the emergence of the third generation programming languages. Languages like ALGOL 58, 60 and 68, COBOL, FORTRAN IV, ADA and C are examples of this and were considered as high level languages. Most of this languages had compilers and the advantage of this was speed. Independence was another factor as these languages were machine independent and could run on different machines. The advantages of high level languages include the support for ideas of abstraction so that programmers can concentrate on finding the solution to the problem rapidly, rather than on low-level details of data representation. The comparative ease of use and learning, improved portability and simplified debugging, modifications and maintenance led to reliability and lower software costs.

These languages were mostly created following von Neumann constructs which had sequential procedural operations and code executed using branches and loops. Although the syntax between these languages were different but they shared similar constructs and were more readable by programmers and users compared to assembly languages. Some languages were improved over time and some were influenced by previous languages, taking the desired features thought to be good and discarding unwanted ones. New features were also added to the desired features to make the language more powerful.

COBOL (COmmon Business-Oriented Language), a business data processing language is an example of a language constantly improving over the decades. It started out with a language called FLOWMATIC in 1955 and this language influenced the birth of COBOL-60 in 1959. Over the years, improvements were done to this language and COBOL 61, 65, 68, 70 were developed, being recognised as a standard in 1961. Now the new COBOL 97 has included new features like Object Oriented Programming to keep up with current languages. One good possible reason for this is the fact that existing code is important and to totally develop a new language from start would be a lengthy process. This also was the rationalisation behind the developments of C and C++.

Then, there were languages that evolved from other languages like LISP1 developed in 1959 for artificial intelligence work, evolving into the 1.5 version and had strong influences languages like MATHLAB, LPL and PL/I. Language like BALM had the combined influence of ALGOL-60 and LISP 1.5. These third generation languages are less processor dependent than lower level languages. An advantage in languages like C++ is that it gives the programmers a lot of control over how things are done in creating applications. This control however calls for more in depth knowledge of how the operating system and computer works. Many of the real programmers now still prefer to use these languages despite the fact the programmer having to devote a substantial professional effort to the leaning of a new complicated syntax which sometimes have little relation to human-language syntax even if it is in English.

Third generation languages often followed procedural code, meaning the language performs functions defined in specific procedures on how something is done. In comparison, most fourth generation languages are nonprocedural. A disadvantage with fourth generation languages was they were slow compared to compiled languages and they also lacked control. Powerful languages of the future will combine procedural code and nonprocedural statements together with the flexibility of interactive screen applications, a powerful way of developing application. Languages specifying what is accomplished but not how, not concerned with the detailed procedures needed to achieve its target like in graphic packages, applications and report generators. The need for this kind of languages is in line with minimum work and skill concept, point and click, programmers who are end users of software applications designed using third generation languages unseen by the commercial users. Programmers whose primary interests are programming and computing use third generation languages and programmers who use the computers and programs to solve problems from other applications are the main users of the fourth generation languages.

Features evident in fourth generation languages quite clearly are that it must be user friendly, portable and independent of operating systems, usable by non-programmers, having intelligent default options about what the user wants and allowing the user to obtain results fasts using minimum requirement code generated with bug-free code from high-level expressions (employing a data-base and dictionary management which makes applications easy and quick to change), which was not possible using COBOL or PL/I. Standardisation however, in early stages of evolution can inhibit creativity in developing powerful languages for the future. Examples of this generation of languages are IBM's ADRS2, APL, CSP and AS, Power Builder, Access.

The 1990's saw the developments of fifth generation languages like PROLOG, referring to systems used in the field of artificial intelligence, fuzzy logic and neural networks. This means computers can in the future have the ability to think for themselves and draw their own inferences using programmed information in large databases. Complex processes like understanding speech would appear to be trivial using these fast inferences and would make the software seem highly intelligent. In fact, these databases programmed in a specialised area of study would show a significant expertise greater than humans. Also, improvements in the fourth generation languages now carried features where users did not need any programming knowledge. Little or no coding and computer aided design with graphics provides an easy to use product that can generate new applications.

What does the next generation of languages hold for us? The sixth generation? That is pretty uncertain at the moment. With fast processors, like in fifth generation computers, able to have multiple processors operating in parallel to solve problems simultaneously will probably ignite a whole new type of language being designed. The current trend of the Internet and the World Wide Web could cultivate a whole new breed of radical programmers for the future, now exploring new boundaries with languages like HTML and Java. What happens next is entirely dependent on the future needs of the whole computer and communications industry. Microsoft simply says, "Where do you want to go today?"

Download 29.58 Kb.

Share with your friends:

The database is protected by copyright © 2023
send message

    Main page