Programming Languages

First Generation Programming language (1GLs)

First-generation programming languages (1GLs) are also known as machine languages.
They are the lowest-level programming languages and are the only languages that
computers can understand directly without translation. 1GLs are made up of binary code,
which is a series of 1s and 0s.
To program a computer in 1GL, the programmer must know the exact binary code for
each instruction and data item that they want the computer to execute. This makes 1GLs
very difficult to learn and use, and they are only used for very specific tasks, such as
developing device drivers and operating systems.
Advantages and Disadvantages of 1GLs:
Advantages:
• Very fast and efficient, as the computer can execute the code directly without
translation.
• No translator required.
Disadvantages:
• Very difficult to learn and use.
• Error-prone, as the programmer must know the exact binary code for each
instruction and data item.
• Not portable, meaning that code written for one computer cannot be easily
executed on another computer.
Examples of 1GLs include:
• Binary code
• Octal code
• Hexadecimal code
1GLs are no longer widely used, but they still play an important role in computer science.
By understanding how 1GLs work, programmers can better understand how computers
work and how to write more efficient and optimized code in higher-level languages.

Second Generation Languages (2GLs)

Second-generation programming languages (2GLs) are also known as assembly
languages. They are a step up from first-generation languages (machine languages) in
that they use symbolic names and abbreviations to represent machine code instructions.
This makes assembly languages easier to read and write, but they are still relatively low-
level languages.
To program a computer in assembly language, the programmer must know the basic
architecture of the computer, including the different types of registers and instructions.
Assembly language programs are typically compiled into machine code before they can
be executed by the computer.
Here are some of the advantages and disadvantages of 2GLs:
Advantages:
• More readable and easier to write than machine language.
• Can be compiled into machine code for different computer architectures, making
them more portable than machine language.
• Can be used to write very efficient and optimized code.
Disadvantages:
• Still relatively low-level and complex to learn and use.
• Error-prone, as the programmer must know the exact details of the computer
architecture.
• Not portable across different computer architectures without recompilation.
Examples of 2GLs include:
• Intel x86 assembly language
• ARM assembly language
• MIPS assembly language
2GLs are still used today for some specific tasks, such as developing device drivers,
operating systems, and embedded systems.
Symbolic names in assembly languages are used to represent machine code instructions
and data items. They are much easier to read and write than the equivalent machine
code, and they make assembly language programs more portable.
Symbolic names can be used for a variety of purposes in assembly language, including:
• Labeling instructions and data: Symbolic labels can be used to assign unique
names to instructions and data items in an assembly language program. This
makes it easier to refer to these instructions and data items in the program code.
• Defining macros: Symbolic names can be used to define macros, which are
reusable code templates. This can help to make assembly language programs
more concise and readable.
• Accessing memory: Symbolic names can be used to access memory locations
in a more convenient and portable way. For example, a programmer can use a
symbolic name to represent the base address of a data structure, and then use
that symbolic name to access individual elements of the data structure.
Here is an example of a simple assembly language program that uses symbolic names:
Code snippet
; Define a symbolic label for the start of the program.
start:

; Load the value 10 into register EAX.

mov eax, 10

; Add the value in register EAX to the value in register EBX.

add ebx, eax
; Store the result in register ECX.
mov ecx, ebx

; Halt the program.

hlt

In this example, the symbolic label start is used to mark the beginning of the program.
The symbolic names eax, ebx, and ecx are used to represent the EAX, EBX, and ECX
registers, respectively.
Symbolic names are an essential part of assembly language programming. They make
assembly language programs more readable, writable, and portable.
Here are some additional tips for using symbolic names in assembly language:
• Choose symbolic names that are meaningful and easy to remember.
• Avoid using symbolic names that are reserved by the assembler or operating
system.
• Use symbolic names consistently throughout your program.
• Document the symbolic names that you use in your program.

By following these tips, you can use symbolic names to make your assembly language
programs more readable, maintainable, and portable.

Third Generation Languages (3GLs)

Third-generation programming languages (3GLs) are high-level programming languages

that are designed to be easier to read and write than assembly language. 3GLs use more
natural language-like syntax and semantics, and they provide a variety of features that
make programming easier and more efficient, such as:
• Data types: 3GLs allow programmers to define different data types, such as
integers, floating-point numbers, and strings. This makes it easier to write code
that is correct and efficient.
• Control structures: 3GLs provide a variety of control structures, such as
conditional statements and loops. This makes it easier to write code that is logical
and well-structured.
• Subroutines and functions: 3GLs allow programmers to define subroutines and
functions, which are reusable code blocks. This makes it easier to write modular
and maintainable code.
3GLs are the most widely used type of programming language today. They are used to
develop a wide range of applications, including operating systems, compilers, web
applications, and mobile apps.
Here are some examples of 3GLs:
• C
• C++
• Java
• Python
 • Ruby
• JavaScript
• PHP
• Go
• Swift
3GLs are a powerful tool for programmers, and they make it possible to develop complex
applications in a relatively short amount of time. However, it is important to note that 3GLs
are not machine-independent. This means that 3GL programs must be compiled into
machine code before they can be executed by a computer.
The compiler process translates the 3GL code into machine code that is specific to the
computer architecture that the program will be running on. This makes it possible to write
3GL programs that can be executed on a variety of different computers.
3GLs have revolutionized the way that software is developed. They have made
programming more accessible to a wider range of people, and they have enabled the
development of more complex and powerful applications.

Comparison of 2GLs and 3GLs

Feature 2GL 3GL

Generation Second Third
Paradigm Assembly Procedural
Focus Machine-oriented Programmer-friendly
Examples Assembly language C, C++, Java, Pascal, COBOL
Uses Device drivers, operating A wide range of applications, including
systems, and embedded operating systems, compilers, and
systems scientific software

Here are some of the key differences between 2GL and 3GL:
• Paradigm: 2GLs are assembly languages, which means that they are very close
to machine code. 3GLs are procedural languages, which means that programmers
tell the computer how to solve a problem step-by-step.
• Focus: 2GLs are machine-oriented, which means that they are designed to be
efficient and to take advantage of the specific features of a particular computer
architecture. 3GLs are programmer-friendly, which means that they are designed
to be easy to learn and use.
• Examples: Some examples of 2GLs include assembly language, ALGOL, and
COBOL. Some examples of 3GLs include C, C++, Java, Pascal, and COBOL.
• Uses: 2GLs are typically used to develop device drivers, operating systems, and
embedded systems. 3GLs are used to develop a wide range of applications,
including operating systems, compilers, and scientific software.
Overall, 2GLs are more efficient and powerful than 3GLs. However, 3GLs are much
easier to learn and use.
It is important to note that some 3GLs, such as C and C++, can be used to develop highly
efficient and powerful applications. However, this requires a deep understanding of the
underlying hardware and operating system.

Fourth Generation Languages(4GLs)

Fourth-generation programming languages (4GLs) are high-level programming

languages that are designed to be even easier to use than 3GLs. 4GLs typically focus on
specific tasks, such as database programming, report generation, or web development.

4GLs often provide a variety of features that make them more user-friendly than 3GLs,
such as:
• Non-procedural programming: 4GLs allow programmers to specify what they
want the computer to do, rather than how to do it. This makes 4GLs easier to learn
and use for programmers who are not familiar with the underlying hardware and
operating system.
• Domain-specific features: 4GLs often provide a variety of domain-specific
features that make it easier to develop programs for specific tasks. For example,
a database-oriented 4GL might provide features for creating and managing
databases, executing SQL queries, and generating reports.
• Visual programming tools: Many 4GLs provide visual programming tools, such
as screen painters and report generators. This allows programmers to develop
applications without having to write a lot of code.

4GLs are widely used in a variety of industries, including business, finance, healthcare,
and education. They are also used to develop web applications and mobile apps.

Here are some examples of 4GLs:

• SQL
• PL/SQL
• T-SQL
• Transact-SQL
• Visual Basic
• PowerBuilder
• Delphi
• ColdFusion
• ASP Classic
• PHP
• Ruby on Rails
4GLs have made programming more accessible to a wider range of people, and they
have enabled the development of more complex and powerful applications.
Here are some of the advantages and disadvantages of 4GLs:
Advantages:
• Easier to learn and use than 3GLs, especially for programmers who are not familiar
with the underlying hardware and operating system.
• Provide domain-specific features that make it easier to develop programs for
specific tasks.
• Often provide visual programming tools that allow programmers to develop
applications without having to write a lot of code.
• Can be more productive than 3GLs for developing certain types of applications.
Disadvantages:
• Not as flexible or powerful as 3GLs.
• May not be suitable for developing all types of applications.
• May be more expensive to use than 3GLs.
Comparison of 3GL and 4GLs
Feature 3GL 4GL
Generation Third Fourth
Paradigm Procedural Non-procedural
Focus Generic programming Specific tasks, such as data
processing and database
handling
Examples C, C++, Java, Pascal, COBOL SQL, Perl, PHP, Python, Ruby
Uses A wide range of applications, Business applications, data
including operating systems, warehousing, reporting, and
compilers, and scientific software web development

Here are some of the key differences between 3GL and 4GL:
• Paradigm: 3GLs are procedural languages, which means that programmers tell
the computer how to solve a problem step-by-step. 4GLs are non-procedural
languages, which means that programmers tell the computer what they want to
achieve, rather than how to achieve it.
• Focus: 3GLs are generic programming languages, which means that they can be
used to develop a wide range of applications. 4GLs are typically focused on
specific tasks, such as data processing and database handling.
• Examples: Some examples of 3GLs include C, C++, Java, Pascal, and COBOL.
Some examples of 4GLs include SQL, Perl, PHP, Python, and Ruby.
• Uses: 3GLs are used to develop a wide range of applications, including operating
systems, compilers, and scientific software. 4GLs are typically used for business
applications, data warehousing, reporting, and web development.
Overall, 3GLs are more powerful and flexible than 4GLs. However, 4GLs can be easier
to learn and use, and they can be more productive for developing certain types of
applications.
Fifth Generation Languages (5GLs)

5GL stands for fifth-generation programming language. It is a type of programming

language that is designed to be more expressive and easier to use than previous
generations of programming languages. 5GLs often use artificial intelligence (AI)
techniques, such as natural language processing, to make it easier for programmers to
express their ideas.

5GLs are still under development, but they have the potential to revolutionize the way we
program computers. They could be used to develop new and innovative applications in a
wide range of fields, such as artificial intelligence, robotics, and expert systems.

Here are some examples of 5GLs:

• Prolog
• Mercury
• OPS5
• Visual Prolog
• Constraint Handling Rules (CHR)
• Functional Logic Programming (FLP)
• Logic Blox
• Ciao Prolog
• Gödel
• Oz
• Maude
• Curry

5GLs are declarative languages, which means that programmers tell the computer what
they want to achieve, rather than how to achieve it. This makes 5GLs much easier to
learn and use than imperative programming languages, such as C and Java.

5GLs are also typically very efficient, as they can compile their code into machine code
that can be executed directly by the computer. This makes them suitable for a wide
range of applications, from real-time systems to high-performance computing.
Here are some examples of how 5GLs could be used:
• A Prolog program could be used to develop a chatbot that can understand and
respond to natural language queries.
• A Mercury program could be used to develop a robot that can plan and navigate
its way through a complex environment.
• An OPS5 program could be used to develop an expert system that can diagnose
and treat diseases.
• A 5GL could be used to develop a compiler for a new programming language.
• A 5GL could be used to develop a theorem prover for mathematical proofs.

5GLs are a powerful new tool for programmers, and they have the potential to change the
way we develop software.
Comparison of 5GLs and 4GLs

Feature 4GL 5GL

GenerationFourth Fifth
Paradigm Non-procedural Declarative
Focus Data processing and database Artificial intelligence (AI) and
handling problem solving
Examples SQL, Perl, PHP, Python, Ruby Prolog, Mercury, OPS5, Visual
Prolog, Constraint Handling
Rules (CHR)
Uses Business applications, data AI research, expert systems, and
warehousing, reporting, and web natural language processing
development

Here are some of the key differences between 4GL and 5GL:
• Paradigm: 4GLs are non-procedural languages, which means that programmers
tell the computer what they want to achieve, rather than how to achieve it. 5GLs
are declarative languages, which means that programmers tell the computer what
the problem is and what the constraints are, and the computer figures out the best
way to solve the problem.
• Focus: 4GLs are typically focused on data processing and database handling.
5GLs are typically focused on artificial intelligence (AI) and problem solving.
• Examples: Some examples of 4GLs include SQL, Perl, PHP, Python, and Ruby.
Some examples of 5GLs include Prolog, Mercury, OPS5, Visual Prolog, and
Constraint Handling Rules (CHR).
• Uses: 4GLs are typically used for business applications, data warehousing,
reporting, and web development. 5GLs are typically used for AI research, expert
systems, and natural language processing.

Overall, 4GLs are more mature and widely used than 5GLs. However, 5GLs have the
potential to revolutionize the way we program computers, as they can be used to develop
new and innovative applications in a wide range of fields.