Programming language: It is a formal, artificial language designed to communicate instructions
to a computer. These instructions are used to create software programs, applications, and systems
that perform specific tasks. Programming languages bridge the gap between human logic and
machine execution, allowing developers to express their ideas in a structured and understandable
way that can then be translated into machine-executable code.
Characteristics of programming languages include:
Syntax: A defined set of rules that dictate how code must be written to be considered valid
within that language.
Semantics: The meaning associated with the various syntactical elements and constructs within
the language.
Keywords and Operators: Reserved words and symbols that have specific meanings and
functions within the language.
Data Types: Ways to classify different kinds of data (e.g., numbers, text, Boolean values) that a
program can manipulate.
Control Structures: Mechanisms for controlling the flow of execution within a program (e.g
loops, conditional statements).
Examples: Python, Java, C, .C++, SQL etc.
Generation of languages: Computer languages are categorized into five generations, evolving
from low-level binary code to high-level languages that are increasingly human-readable and
abstract. This progression has made programming more accessible and powerful, with each
generation introducing new paradigms for communication between humans and computers.
First-Generation Languages (1GL):
Type: Low-level machine code.
Description: The only language a computer can directly understand, consisting of binary digits
(0s and 1s).
Characteristics: Extremely difficult for humans to read, write, and debug.
Second-Generation Languages (2GL)
Type: Low-level assembly languages.
Description: Uses mnemonic codes as substitutes for binary code, making it more readable.
Characteristics: Still low-level and processor-specific, but provides a slight improvement over
machine code.
Third-Generation Languages (3GL)
Type: High-level languages.
Description: Syntax is closer to human languages, abstracting away from the machine's
hardware.
Characteristics: Easier to write, read, and understand; examples include C, Java, and Python.
Fourth-Generation Languages (4GL)
Type: High-level, non-procedural languages.
Description: Statements are very similar to human language and are often used for database and
scripting tasks.
Characteristics: Focus on what needs to be done rather than how to do it, leading to faster
development; examples include SQL and Perl.
Fifth-Generation Languages (5GL)
Type: High-level languages for artificial intelligence and constraint-based programming.
Description: Focus on solving problems using constraints rather than algorithms.
Characteristics: Aim to allow computers to solve problems with minimal human
intervention; examples include Prolog and Lisp.
Low level language: A low-level language is a programming language that provides little to no
abstraction from a computer's hardware, making it close to machine code and allowing for direct
hardware control. Examples include machine code (binary 0 and 1) and assembly language.
These languages are used for performance-critical applications like operating system and device
driver development.
Characteristics:
Closer to hardware: Low-level languages are less like human-readable languages and more like
the computer's native instruction set.
Direct hardware control: They allow programmers to directly manipulate hardware, such as
memory and processor registers, for fine-tuned control and efficiency.
Not portable: Code written for one type of CPU architecture typically will not run on another
because it is optimized for a specific system.
Requires more detail: Programming in a low-level language requires a detailed understanding of
the computer's architecture.
High level language: A high-level language is a programming language that uses a human-
readable syntax, making it easier for developers to write and understand code compared to low-
level languages. These languages have a high level of abstraction from the computer's hardware,
allowing programmers to focus on logic and functionality rather than managing memory or other
low-level details. Examples include Python, Java, JavaScript, and C++.
Characteristics:
Human-readable: They use words and symbols that are closer to natural language, making them
easier for humans to write, read, and debug.
Machine-independent: Code written in a high-level language can often be run on different types
of computers with minimal changes because the language is independent of the underlying
hardware.
High abstraction: They hide complex, machine-specific details like memory management and
register usage, allowing developers to concentrate on solving problems.
Problem-oriented: They are designed to handle specific problems and allow programmers to
write cleaner, shorter code that accomplishes more per line.
Assembler in Computer:
Assembler in Computer: An Assembler is system software that converts assembly language
programs into machine code (binary code) that the computer’s processor can understand and
execute.
Explanation:
Assembly language uses mnemonics (like MOV, ADD, SUB) instead of binary numbers.
The assembler translates these mnemonics into machine-level instructions (0s and 1s).
It helps programmers write code more easily than directly using machine language.
Compiler in Computer:
A Compiler is system software that translates a high-level language program (like C, C++, Java)
into machine code that the computer’s processor can execute.
Explanation:
High-level languages are easy for humans to understand (using words like if, for, while).
The compiler converts the entire source code into machine code at once before execution.
This machine code is stored as an object file or executable file.
Interpreter in computer:
An Interpreter is a system software that translates and executes a high-level language program
line by line into machine code.
Explanation:
Unlike a compiler (which converts the entire program at once), an interpreter translates
one statement at a time.
After translating a line, it immediately executes it before moving to the next line.
If there’s an error in any line, the interpreter stops execution and reports the error right
away.
Translator in Computer:
A Translator is system software that converts programs written in one programming language
into another form — usually into machine code that a computer can understand and execute.
Explanation:
Computers can only understand machine language (binary form: 0s and 1s).
Programs written by humans are usually in high-level or assembly languages, so a translator is
needed to convert them into machine language
Types of Translators: There are three main types of translators:
Type Description Example
Assembler Converts assembly language into machine code. MASM, TASM
Converts high-level language into machine code all at
Compiler GCC, Turbo C, javac
once.
Converts and executes one line at a time from high-level Python Interpreter, BASIC
Interpreter
language to machine code. Interpreter
Loader in Computer:
A Loader is a system program that is responsible for loading an executable file (machine code)
into the main memory (RAM) so that the CPU can execute it.
Explanation:
After a program is compiled or assembled, it becomes an object program (machine code).
The loader takes this machine code from secondary storage (like a hard disk) and places
it into main memory.
It also allocates memory space, resolves addresses, and starts execution