Evolution of Programming Languages Generations of PLs
Dec 29, 2015
Evolution of Programming Languages
Generations of PLs
First generation computers relied on machine language, the instructions of which are long strings of binary codes.
http://fahmirahman.wordpress.com/2011/01/04/five-generations-of-computer/
Generations of PLs1GL – Machine language
. String of 0’s and 1’s
. Directly executed by CPU2GL – Assembly language
. Symbolic equivalent of machine language3GL – Procedural language
. Give how to do/ algorithm. E.g. Pascal
4GL – Declarative language. Specify what to do. E.g. SQL
5GL – Related to artificial intelligence
Low Level and High Level PLs • Low Level PLs (1-2GLs)
– Instructions directly operate computer hardware– Need to have machine level knowledge in order to
write programs– Machine dependent– Machine language and assembly language
• High Level PLs (3-5 GLs)– More English like– Closer to human language
1 GL – Machine language
• A low level language• Consists of strings of 0’s and 1’s• Directly executed by the CPU• Difficult and tedious to write and maintain• Quickly replaced by assembly language (2GL)
2 GL – Assembly Language• Instruction has a one-to-one correspondence
with its machine language equivalent• Instruction consists of opcode = operation code
Action Memory Address, register or value
e.g. ADD AX, 3 ; increase AX by 3
Opcode Operand(s)
• Machine instructions are symbolized using mnemonics into assembly language instructions
A sample machine language program and the corresponding assembly language program
2 GL – Assembly Language
• A low level language• Translated into machine language for
execution• Manipulate computer down to register level• Hardware dependent• Difficult to learn and debug• Directly control of CPU operations, therefore
the codes produce are more efficient
Extended Reading
Microsoft Windows DEBUG Textbook P.6 Act. 1 - Writing a real assembly language program
General registers
AX
BX
CX
DX
The 80x86 CPU has four general registers
The accumulator AX stores the results of math operations.
The base register BX stores the address or pointer.
The counting register CX is used in counting and looping.
The data register DX stores data.
Commands of DEBUG
Command/Prompt
Operation
- A prompt for accepting command
r Display the contents of CPU registers.
rax Display the contents of AX.
: A prompt for accepting value to the register being worked with.
a Start assembling (translating) symbolic instructions into machine codes. i.e. Start to accept assembly language program.
t Trace the program. i.e. Execute the program and show the contents of the register.
q Quit DEBUG.
A sample assembly language program explained
Assembly Instruction Explanation
mov ax, 5 Move the value 5 (hex) to register AX.
mov bx, 3 Move the value 3 (hex) to register BX.
add ax, bx Add the values stored in register AX and BX and the result back to register AX.
int 20 Call the DOS interrupt 20 to terminate the program.
Choose run > cmd to open the command prompt window
Enter debug to the command prompt to run debug
Want to try it out yourself?
P.6 Activity 1 Writing a simple assembly language program using DEBUG
5 minutes
Typo in textbook P.8 Step 9: the first -t should be -r
3GLs (high level)• Close to human language, more English like• E.g. Pascal, FORTRAN, BASIC, COBOL, C,...• Programmers can focus on solving problems
rather than manipulating registers and memory addresses
• Easy to write, debug and maintain• Loss of direct control of CPU operations and
memory addresses• Programs more portable (machine independent)
Assembly language Pascal
185B:0100 mov ax, 5185B:0103 mov bx, 3185B:0106 add ax, bx185B:0108 int 20185B:010A
var a, b : integer;begin a := 5; b := 3; a := a + bend.
The same program written in assembly language (2GL) and Pascal (3GL). The use of variables, data types and mathematical expression syntax in 3GL hides the complexities of CPU’s internal operations from the programmer.
4GLs• Declarative / non-procedural• Specify what to do/ not how to do• In 3GLs, detail steps in solving a problem has to
be coded, in 4GL fewer statements are necessary• More towards solving specific problems
- SQL to make queries on relational database - SPSS to perform data analysis
SQL statement for outputting the number of female students in each class from the database table student:
SELECT class, COUNT(*)
FROM student
WHERE sex = "F"
GROUP BY class;
5GLs• Related to artificial intelligence (AI)• Able to search for solution of the problem by
itself• Based on constraints and conditions given• Programmers can focus on what problems
need to be solved and what constraints and conditions are to be satisfied, rather then algorithm to solve the problem
• E.g. Prolog
Prolog (Program Logic)
In Prolog, the program logic is represented by relations,
and queries can be constructed and run on these relations.
Relations are defined by clauses
and there are two types of clauses: facts and rules
Facts in Prolog loves(peter, snacks).
- a fact clause that defined the relation loves between two
objects peter and snacks
- note that a clause must end with a full stop
- object names must be in lower case (upper-case is for variable)
- the fact defined can be interpreted as ‘Peter loves snacks’
(not the other way round)
The following 5 clauses define 5 facts:
loves(peter, snacks).
loves(peter, mary).
loves(mary, fruit).
loves(mary, snacks).
loves(mary, tom).
Queries in Prolog
loves(peter,tom).
can be interpreted as ‘Does Peter love tom?’
loves(peter,X).
can be interpreted as ‘What/ who does Peter love?’
loves(X,snacks).
can be interpreted as ‘Who loves snacks?’
Notes:
- X is in upper case to indicate that it is a variable
- loves(peter,tom). can be a fact clause or a query,
depend on usage
Query Result loves(peter,tom). no
loves(peter,X). X = snacksX =
loves(X,snacks). X =X =
Queries in Prolog
Fill in the table based on the following facts:
loves(peter, snacks).loves(peter, mary).loves(mary, fruit).loves(mary, snacks).loves(mary, tom).
Petermary
mary
Rules in Prolog
loves(peter, X) :- loves(mary, X). means Peter loves X if Mary loves X
lovers(X, Y) :- loves(X, Y), loves(Y, X). means X and Y are lovers if X loves Y and Y loves X
Given the 5 facts and the ruleloves(peter, snacks).
loves(peter, mary).
loves(mary, fruit).
loves(mary, snacks).
loves(mary, tom).
loves(peter, X) :- loves(mary, X).
The query loves(peter, X) returns X = snacks
X =
(and more ...)
Given the 5 facts and the ruleloves(peter, snacks).
loves(peter, mary).
loves(mary, fruit).
loves(mary, snacks).
loves(mary, tom).
loves(peter, X) :- loves(mary, X).
The query loves(peter, X) returns X = snacks
X = mary
X = fruit
X = snacks
X = tom
Given the 3 facts and the ruleloves(tom, mary).
loves(peter, mary).
loves(mary, tom).
lovers(X, Y) :- loves(X, Y), loves(Y,X).
The query lovers(peter, mary). returns The query lovers(mary, tom). returns The query lovers(tom, mary). returns
no
true
true
Your turn now (P.15 Activity 2)
Step1: Create a text file named loves.pl storing all the relations (facts and rules)
Step2: Open GNU Prolog enter the command consult('s:/loves.pl').
Step3: Make queries
Generations of PLs1GL – Machine language
. String of 0’s and 1’s
. Directly executed by CPU2GL – Assembly language
. Symbolic equivalent of machine language3GL – Procedural language
. Give how to do/ algorithm. E.g. Pascal
4GL – Declarative language. Specify what to do. E.g. SQL
5GL – Related to artificial intelligence . E.g. Prolog
Hierarchy of programming languages
Try it out with GNU Prolog
Step1: Create a text file named loves.pl storing all the relations (facts and rules) Step2: Open GNU Prolog enter the command consult('s:/loves.pl').Step3: Make queries
Reminders: - don’t leave out the full stop - place loves.pl in your S drive ~ simpler path